import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
private ProtectedPKIMessage finaliseMessage(PKIHeader header, DERBitString protection)
{
    if (!extraCerts.isEmpty())
    {
        CMPCertificate[] cmpCerts = new CMPCertificate[extraCerts.size()];

        for (int i = 0; i != cmpCerts.length; i++)
        {
            cmpCerts[i] = new CMPCertificate(((X509CertificateHolder)extraCerts.get(i)).toASN1Structure());
        }

        return new ProtectedPKIMessage(new PKIMessage(header, body, protection, cmpCerts));
    }
    else
    {
        return new ProtectedPKIMessage(new PKIMessage(header, body, protection));
    }
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
private PKIMessage addProtection(PKIMessage pkiMessage, AuditEvent event) {
    try {
        return CmpUtil.addProtection(pkiMessage, getSigner(), getSender(),
                getCmpControl().sendResponderCert());
    } catch (Exception ex) {
        LogUtil.error(LOG, ex, "could not add protection to the PKI message");
        PKIStatusInfo status = generateRejectionStatus(
                PKIFailureInfo.systemFailure, "could not sign the PKIMessage");

        event.setLevel(AuditLevel.ERROR);
        event.setStatus(AuditStatus.FAILED);
        event.addEventData(CaAuditConstants.NAME_message, "could not sign the PKIMessage");
        PKIBody body = new PKIBody(PKIBody.TYPE_ERROR, new ErrorMsgContent(status));
        return new PKIMessage(pkiMessage.getHeader(), body);
    }
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
protected PKIMessage buildErrorPkiMessage(ASN1OctetString tid,
        PKIHeader requestHeader, int failureCode, String statusText) {
    GeneralName respRecipient = requestHeader.getSender();

    PKIHeaderBuilder respHeader = new PKIHeaderBuilder(
            requestHeader.getPvno().getValue().intValue(), getSender(), respRecipient);
    respHeader.setMessageTime(new ASN1GeneralizedTime(new Date()));
    if (tid != null) {
        respHeader.setTransactionID(tid);
    }

    ASN1OctetString senderNonce = requestHeader.getSenderNonce();
    if (senderNonce != null) {
        respHeader.setRecipNonce(senderNonce);
    }

    PKIStatusInfo status = generateRejectionStatus(failureCode, statusText);
    ErrorMsgContent error = new ErrorMsgContent(status);
    PKIBody body = new PKIBody(PKIBody.TYPE_ERROR, error);

    return new PKIMessage(respHeader.build(), body);
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
private static PKIMessage loadMessage(String name)
{
    String dataHome = System.getProperty(TEST_DATA_HOME);

    if (dataHome == null)
    {
        throw new IllegalStateException(TEST_DATA_HOME + " property not set");
    }

    try
    {
        return PKIMessage.getInstance(ASN1Primitive.fromByteArray(Streams.readAll(new FileInputStream(dataHome + "/cmp/" + name))));
    }
    catch (IOException e)
    {
        throw new RuntimeException(e.toString());
    }
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
ProtectedPKIMessage(PKIMessage pkiMessage)
{
    if (pkiMessage.getHeader().getProtectionAlg() == null)
    {
        throw new IllegalArgumentException("PKIMessage not protected");
    }

    this.pkiMessage = pkiMessage;
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
protected PKIMessage generatePkiMessage(InputStream is) throws IOException {
    ASN1InputStream asn1Stream = new ASN1InputStream(is);

    try {
        return PKIMessage.getInstance(asn1Stream.readObject());
    } finally {
        try {
            asn1Stream.close();
        } catch (Exception ex) {
            LOG.error("could not close ASN1 stream: {}", asn1Stream);
        }
    }
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
/**
 * handle the PKI body with the choice {@code cr}.
 *
 */
private PKIBody processCr(PKIMessage request, CmpRequestorInfo requestor, ASN1OctetString tid,
        PKIHeader reqHeader, CertReqMessages cr, CmpControl cmpControl, String msgId,
        AuditEvent event) {
    CertRepMessage repMessage = processCertReqMessages(request, requestor, tid, reqHeader,
            cr, false, cmpControl, msgId, event);
    return new PKIBody(PKIBody.TYPE_CERT_REP, repMessage);
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
private PKIBody processKur(PKIMessage request, CmpRequestorInfo requestor, ASN1OctetString tid,
        PKIHeader reqHeader, CertReqMessages kur, CmpControl cmpControl, String msgId,
        AuditEvent event) {
    CertRepMessage repMessage = processCertReqMessages(request, requestor, tid, reqHeader,
            kur, true, cmpControl, msgId, event);
    return new PKIBody(PKIBody.TYPE_KEY_UPDATE_REP, repMessage);
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
/**
 * handle the PKI body with the choice {@code cr}.
 *
 */
private PKIBody processCcp(PKIMessage request, CmpRequestorInfo requestor, ASN1OctetString tid,
        PKIHeader reqHeader, CertReqMessages cr, CmpControl cmpControl, String msgId,
        AuditEvent event) {
    CertRepMessage repMessage = processCertReqMessages(request, requestor, tid, reqHeader,
            cr, false, cmpControl, msgId, event);
    return new PKIBody(PKIBody.TYPE_CROSS_CERT_REP, repMessage);
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
public void testSampleCr()
    throws Exception
{
    PKIMessage msg = loadMessage("sample_cr.der");
    ProtectedPKIMessage procMsg = new ProtectedPKIMessage(new GeneralPKIMessage(msg));

    assertTrue(procMsg.verify(new PKMACBuilder(new JcePKMACValuesCalculator().setProvider(BC)), "TopSecret1234".toCharArray()));
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
public PKIMessage toASN1Structure()
{
    return pkiMessage;
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
PKIMessage processPkiMessage(PKIMessage pkiMessage, X509Certificate tlsClientCert,
AuditEvent event);
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
/**
 * handle the PKI body with the choice {@code p10cr}<br/>
 * Since it is not possible to add attribute to the PKCS#10 request (CSR), the certificate
 * profile must be specified in the attribute regInfo-utf8Pairs (1.3.6.1.5.5.7.5.2.1) within
 * PKIHeader.generalInfo
 *
 */
private PKIBody processP10cr(PKIMessage request, CmpRequestorInfo requestor,
        ASN1OctetString tid, PKIHeader reqHeader, CertificationRequest p10cr,
        CmpControl cmpControl, String msgId, AuditEvent event) {
    // verify the POP first
    CertResponse certResp;
    ASN1Integer certReqId = new ASN1Integer(-1);

    boolean certGenerated = false;
    X509Ca ca = getCa();

    if (!securityFactory.verifyPopo(p10cr, getCmpControl().popoAlgoValidator())) {
        LOG.warn("could not validate POP for the pkcs#10 requst");
        certResp = buildErrorCertResponse(certReqId, PKIFailureInfo.badPOP, "invalid POP");
    } else {
        CertificationRequestInfo certTemp = p10cr.getCertificationRequestInfo();
        Extensions extensions = CaUtil.getExtensions(certTemp);

        X500Name subject = certTemp.getSubject();
        SubjectPublicKeyInfo publicKeyInfo = certTemp.getSubjectPublicKeyInfo();

        CmpUtf8Pairs keyvalues = CmpUtil.extract(reqHeader.getGeneralInfo());
        String certprofileName = null;
        Date notBefore = null;
        Date notAfter = null;

        if (keyvalues != null) {
            certprofileName = keyvalues.value(CmpUtf8Pairs.KEY_CERT_PROFILE);

            String str = keyvalues.value(CmpUtf8Pairs.KEY_NOT_BEFORE);
            if (str != null) {
                notBefore = DateUtil.parseUtcTimeyyyyMMddhhmmss(str);
            }

            str = keyvalues.value(CmpUtf8Pairs.KEY_NOT_AFTER);
            if (str != null) {
                notAfter = DateUtil.parseUtcTimeyyyyMMddhhmmss(str);
            }
        }

        if (certprofileName == null) {
            certResp = buildErrorCertResponse(certReqId, PKIFailureInfo.badCertTemplate,
                    "badCertTemplate", null);
        } else {
            certprofileName = certprofileName.toUpperCase();
            if (!requestor.isCertProfilePermitted(certprofileName)) {
                String msg = "certprofile " + certprofileName + " is not allowed";
                certResp = buildErrorCertResponse(certReqId,
                        PKIFailureInfo.notAuthorized, msg);
            } else {
                CertTemplateData certTemplateData = new CertTemplateData(subject, publicKeyInfo,
                        notBefore, notAfter, extensions, certprofileName);

                certResp = generateCertificates(Arrays.asList(certTemplateData),
                        Arrays.asList(certReqId), requestor, tid, false, request,
                        cmpControl, msgId, event).get(0);
                certGenerated = true;
            }
        }
    }

    CMPCertificate[] caPubs = null;
    if (certGenerated && cmpControl.sendCaCert()) {
        caPubs = new CMPCertificate[]{ca.caInfo().certInCmpFormat()};
    }
    CertRepMessage repMessage = new CertRepMessage(caPubs, new CertResponse[]{certResp});

    return new PKIBody(PKIBody.TYPE_CERT_REP, repMessage);
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
private PKIBody cmpUnRevokeRemoveCertificates(PKIMessage request, PKIHeaderBuilder respHeader,
        CmpControl cmpControl, PKIHeader reqHeader, PKIBody reqBody, CmpRequestorInfo requestor,
        String msgId, AuditEvent event) {
    Integer requiredPermission = null;
    boolean allRevdetailsOfSameType = true;

    RevReqContent rr = RevReqContent.getInstance(reqBody.getContent());
    RevDetails[] revContent = rr.toRevDetailsArray();

    int len = revContent.length;
    for (int i = 0; i < len; i++) {
        RevDetails revDetails = revContent[i];
        Extensions crlDetails = revDetails.getCrlEntryDetails();
        int reasonCode = CrlReason.UNSPECIFIED.code();
        if (crlDetails != null) {
            ASN1ObjectIdentifier extId = Extension.reasonCode;
            ASN1Encodable extValue = crlDetails.getExtensionParsedValue(extId);
            if (extValue != null) {
                reasonCode = ASN1Enumerated.getInstance(extValue).getValue().intValue();
            }
        }

        if (reasonCode == XiSecurityConstants.CMP_CRL_REASON_REMOVE) {
            if (requiredPermission == null) {
                event.addEventType(CaAuditConstants.TYPE_CMP_rr_remove);
                requiredPermission = PermissionConstants.REMOVE_CERT;
            } else if (requiredPermission != PermissionConstants.REMOVE_CERT) {
                allRevdetailsOfSameType = false;
                break;
            }
        } else if (reasonCode == CrlReason.REMOVE_FROM_CRL.code()) {
            if (requiredPermission == null) {
                event.addEventType(CaAuditConstants.TYPE_CMP_rr_unrevoke);
                requiredPermission = PermissionConstants.UNREVOKE_CERT;
            } else if (requiredPermission != PermissionConstants.UNREVOKE_CERT) {
                allRevdetailsOfSameType = false;
                break;
            }
        } else {
            if (requiredPermission == null) {
                event.addEventType(CaAuditConstants.TYPE_CMP_rr_revoke);
                requiredPermission = PermissionConstants.REVOKE_CERT;
            } else if (requiredPermission != PermissionConstants.REVOKE_CERT) {
                allRevdetailsOfSameType = false;
                break;
            }
        }
    } // end for

    if (!allRevdetailsOfSameType) {
        ErrorMsgContent emc = new ErrorMsgContent(
                new PKIStatusInfo(PKIStatus.rejection,
                new PKIFreeText("not all revDetails are of the same type"),
                new PKIFailureInfo(PKIFailureInfo.badRequest)));

        return new PKIBody(PKIBody.TYPE_ERROR, emc);
    } else {
        try {
            checkPermission(requestor, requiredPermission);
        } catch (InsuffientPermissionException ex) {
            event.setStatus(AuditStatus.FAILED);
            event.addEventData(CaAuditConstants.NAME_message, "NOT_PERMITTED");
            return buildErrorMsgPkiBody(PKIStatus.rejection, PKIFailureInfo.notAuthorized,
                    null);
        }
        return unRevokeRemoveCertificates(request, rr, requiredPermission, cmpControl, msgId);
    }
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
/**
 * Wrap a PKIMessage ASN.1 structure.
 *
 * @param pkiMessage base PKI message.
 */
public GeneralPKIMessage(PKIMessage pkiMessage)
{
    this.pkiMessage = pkiMessage;
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
/**
 * Return the underlying ASN.1 structure contained in this object.
 *
 * @return a PKIMessage structure.
 */
public PKIMessage toASN1Structure()
{
    return pkiMessage;
}
 

import org.bouncycastle.asn1.cmp.PKIMessage; //导入依赖的package包/类
/**
 * Processes the request and returns the response.
 * @param request
 *          Original request. Will only be used for the storage. Could be{@code null}.
 * @param requestor
 *          Requestor. Must not be {@code null}.
 * @param transactionId
 *          Transaction id. Must not be {@code null}.
 * @param pkiMessage
 *          PKI message. Must not be {@code null}.
 * @param msgId
 *          Message id. Must not be {@code null}.
 * @param event
 *          Audit event. Must not be {@code null}.
 * @return the response
 */
protected abstract PKIMessage processPkiMessage0(PKIMessage request, RequestorInfo requestor,
        ASN1OctetString transactionId, GeneralPKIMessage pkiMessage, String msgId,
        AuditEvent event);