Example usage for org.bouncycastle.asn1.x509 IssuingDistributionPoint onlyContainsAttributeCerts

List of usage examples for org.bouncycastle.asn1.x509 IssuingDistributionPoint onlyContainsAttributeCerts

Introduction

In this page you can find the example usage for org.bouncycastle.asn1.x509 IssuingDistributionPoint onlyContainsAttributeCerts.

Prototype

boolean onlyContainsAttributeCerts

To view the source code for org.bouncycastle.asn1.x509 IssuingDistributionPoint onlyContainsAttributeCerts.

Click Source Link

Usage

From source file:eu.europa.ec.markt.dss.validation102853.crl.CommonCRLSource.java

License:Open Source License

private void checkCriticalExtensions(final X509CRL x509CRL, final List<String> dpUrlStringList,
        final CRLValidity crlValidity) {

    final Set<String> criticalExtensionOIDs = x509CRL.getCriticalExtensionOIDs();
    if (criticalExtensionOIDs == null || criticalExtensionOIDs.size() == 0) {
        crlValidity.unknownCriticalExtension = false;
        return;//from   w w w .  j av a 2s  .c o  m
    }
    final String issuingDistributionPointOid = PKIXExtensions.IssuingDistributionPoint_Id.toString();
    for (final String criticalExtensionOID : criticalExtensionOIDs) {

        if (issuingDistributionPointOid.equals(criticalExtensionOID)) {

            final byte[] extensionValue = x509CRL.getExtensionValue(issuingDistributionPointOid);
            final ASN1OctetString asn1OctetStringExtensionValue = ASN1OctetString.getInstance(extensionValue);
            final IssuingDistributionPoint issuingDistributionPoint = IssuingDistributionPoint
                    .getInstance(asn1OctetStringExtensionValue.getOctets());
            final boolean onlyAttributeCerts = issuingDistributionPoint.onlyContainsAttributeCerts();
            final boolean onlyCaCerts = issuingDistributionPoint.onlyContainsCACerts();
            final boolean onlyUserCerts = issuingDistributionPoint.onlyContainsUserCerts();
            final boolean indirectCrl = issuingDistributionPoint.isIndirectCRL();
            final ReasonFlags reasonFlags = issuingDistributionPoint.getOnlySomeReasons();
            final DistributionPointName distributionPointName = issuingDistributionPoint.getDistributionPoint();

            boolean urlFound = false;
            if (FULL_NAME == distributionPointName.getType()) {

                final GeneralNames generalNames = (GeneralNames) distributionPointName.getName();
                if (generalNames != null) {

                    final GeneralName[] names = generalNames.getNames();
                    if (names != null && names.length > 0) {
                        for (final GeneralName generalName : names) {
                            if (uniformResourceIdentifier == generalName.getTagNo()) {

                                final String name = generalName.getName().toString();
                                if (DSSUtils.isNotEmpty(dpUrlStringList) && dpUrlStringList.contains(name)) {
                                    urlFound = true;
                                }
                            }
                        }
                    }
                }
            }
            if (!(onlyAttributeCerts && onlyCaCerts && onlyUserCerts && indirectCrl) && reasonFlags == null
                    && urlFound) {
                crlValidity.unknownCriticalExtension = false;
            }
            continue;
        }
        crlValidity.unknownCriticalExtension = true;
    }
}

From source file:eu.europa.esig.dss.x509.crl.CRLUtils.java

License:Open Source License

private static void checkCriticalExtensions(final X509CRL x509CRL, final CRLValidity crlValidity) {

    final Set<String> criticalExtensionOIDs = x509CRL.getCriticalExtensionOIDs();
    if ((criticalExtensionOIDs == null) || (criticalExtensionOIDs.size() == 0)) {
        crlValidity.setUnknownCriticalExtension(false);
    } else {//  w  ww  .  ja  va  2s. c om

        byte[] extensionValue = x509CRL.getExtensionValue(Extension.issuingDistributionPoint.getId());
        IssuingDistributionPoint issuingDistributionPoint = IssuingDistributionPoint
                .getInstance(ASN1OctetString.getInstance(extensionValue).getOctets());
        final boolean onlyAttributeCerts = issuingDistributionPoint.onlyContainsAttributeCerts();
        final boolean onlyCaCerts = issuingDistributionPoint.onlyContainsCACerts();
        final boolean onlyUserCerts = issuingDistributionPoint.onlyContainsUserCerts();
        final boolean indirectCrl = issuingDistributionPoint.isIndirectCRL();
        ReasonFlags onlySomeReasons = issuingDistributionPoint.getOnlySomeReasons();
        DistributionPointName distributionPoint = issuingDistributionPoint.getDistributionPoint();
        boolean urlFound = false;
        if (DistributionPointName.FULL_NAME == distributionPoint.getType()) {
            final GeneralNames generalNames = (GeneralNames) distributionPoint.getName();
            if ((generalNames != null) && (generalNames.getNames() != null)
                    && (generalNames.getNames().length > 0)) {
                for (GeneralName generalName : generalNames.getNames()) {
                    if (GeneralName.uniformResourceIdentifier == generalName.getTagNo()) {
                        urlFound = true;
                    }
                }
            }
        }

        if (!(onlyAttributeCerts && onlyCaCerts && onlyUserCerts && indirectCrl) && (onlySomeReasons == null)
                && urlFound) {
            crlValidity.setUnknownCriticalExtension(false);
        }
    }
}

From source file:mitm.common.security.crl.PKIXRevocationChecker.java

License:Open Source License

private boolean acceptCRL_6_3_3_b(X509Certificate targetCertificate, X509CRL crl) throws IOException {
    boolean match = false;

    if (X509CRLInspector.isDeltaCRL(crl)) {
        /* CRL is not complete because it's a delta CRL */
        return false;
    }/*ww w.  j  a v a  2s  .com*/

    if (!crl.getIssuerX500Principal().equals(targetCertificate.getIssuerX500Principal())) {
        logger.debug("CRL issuer and certificate issuer do not match.");

        return false;
    }

    IssuingDistributionPoint idp = X509CRLInspector.getIssuingDistributionPoint(crl);

    /* if there is no IssuingDistributionPoint there is always a match */
    if (idp == null) {
        return true;
    }

    DistributionPointName idpn = idp.getDistributionPoint();

    CRLDistPoint crlDistPoint = X509CertificateInspector.getCRLDistibutionPoints(targetCertificate);

    DistributionPoint[] dps = null;

    if (crlDistPoint != null) {
        dps = crlDistPoint.getDistributionPoints();
    }

    if (dps != null) {
        for (DistributionPoint dp : dps) {
            if (dp == null) {
                logger.debug("Distributionpoint is null.");
                continue;
            }

            if (dp.getCRLIssuer() != null) {
                /* we do not support indirect CRLs */
                logger.debug("CRL issuer should only be used for indirect CRLs.");

                continue;
            }

            DistributionPointName dpn = dp.getDistributionPoint();

            if (idp != null) {
                if (idpn != null && dpn != null) {
                    X500Principal issuer = targetCertificate.getIssuerX500Principal();

                    if (hasMatchingName(idpn, dpn, issuer)) {
                        match = true;
                        break;
                    }
                }
            }
        }
        if (!match) {
            logger.debug("The CRL did not contain matching DistributionPoint names.");
        }
    } else {
        match = (idpn == null);
    }

    BasicConstraints basicConstraints = X509CertificateInspector.getBasicConstraints(targetCertificate);

    if (idp != null) {
        /* if basicConstraints is null assume it's a user certificate */

        if (idp.onlyContainsCACerts()
                && ((basicConstraints != null && !basicConstraints.isCA()) | basicConstraints == null)) {
            logger.debug("Certificate is a user certificate but CRL only contains CA certificate.");
            match = false;
        }

        if (idp.onlyContainsUserCerts() && basicConstraints != null && basicConstraints.isCA()) {
            logger.debug("Certificate is a CA but CRL only contains user certificates.");
            match = false;
        }

        if (idp.onlyContainsAttributeCerts()) {
            logger.debug("Certificate only contains attribute certs.");
            match = false;
        }
    }

    return match;
}

From source file:net.sf.keystore_explorer.crypto.x509.X509Ext.java

License:Open Source License

private String getIssuingDistributionPointStringValue(byte[] value) throws IOException {
    // @formatter:off

    /*/*from w w w . jav  a  2 s  .co  m*/
     * IssuingDistributionPoint ::= ASN1Sequence {
     *     distributionPoint [0] DistributionPointName OPTIONAL,
     *     onlyContainsUserCerts [1] ASN1Boolean DEFAULT FALSE,
     *     onlyContainsCACerts [2] ASN1Boolean DEFAULT FALSE,
     *     onlySomeReasons [3] ReasonFlags OPTIONAL,
     *     indirectCRL [4] ASN1Boolean DEFAULT FALSE,
     *     onlyContainsAttributeCerts [5] ASN1Boolean DEFAULT FALSE }
     */

    // @formatter:on

    /*
     * Getting any DEFAULTS returns a false ASN1Boolean when no value
     * present which saves the bother of a null check
     */

    StringBuilder sb = new StringBuilder();

    IssuingDistributionPoint issuingDistributionPoint = IssuingDistributionPoint.getInstance(value);

    DistributionPointName distributionPointName = issuingDistributionPoint.getDistributionPoint();

    if (distributionPointName != null) { // Optional
        sb.append(getDistributionPointNameString(distributionPointName, ""));
    }

    boolean onlyContainsUserCerts = issuingDistributionPoint.onlyContainsUserCerts();
    sb.append(MessageFormat.format(res.getString("OnlyContainsUserCerts"), onlyContainsUserCerts));
    sb.append(NEWLINE);

    boolean onlyContainsCaCerts = issuingDistributionPoint.onlyContainsCACerts();
    sb.append(MessageFormat.format(res.getString("OnlyContainsCaCerts"), onlyContainsCaCerts));
    sb.append(NEWLINE);

    ReasonFlags onlySomeReasons = issuingDistributionPoint.getOnlySomeReasons();
    if (onlySomeReasons != null) {// Optional
        sb.append(res.getString("OnlySomeReasons"));
        sb.append(NEWLINE);

        String[] reasonFlags = getReasonFlagsStrings(onlySomeReasons);

        for (String reasonFlag : reasonFlags) {
            sb.append(INDENT);
            sb.append(reasonFlag);
            sb.append(NEWLINE);
        }
    }

    boolean indirectCrl = issuingDistributionPoint.isIndirectCRL();
    sb.append(MessageFormat.format(res.getString("IndirectCrl"), indirectCrl));
    sb.append(NEWLINE);

    boolean onlyContainsAttributeCerts = issuingDistributionPoint.onlyContainsAttributeCerts();
    sb.append(MessageFormat.format(res.getString("OnlyContainsAttributeCerts"), onlyContainsAttributeCerts));
    sb.append(NEWLINE);

    return sb.toString();
}

From source file:org.glite.security.util.FileCRLChecker.java

License:Apache License

/**
 * Checks the issuerDistributionPoint extension, whether it contains unsupported information.
 * /*from  w ww . j  a  va  2 s.c o m*/
 * @throws CertificateException thrown in case there is problems with the certificate handling.
 * @throws IOException thrown in case the extension parsing fails.
 */
private void checkIssuinDistributionPoint() throws CertificateException, IOException {
    byte extensionBytes[] = m_crl.getExtensionValue(X509Extensions.IssuingDistributionPoint.toString());

    ASN1Object object = ASN1Object.fromByteArray(extensionBytes);
    if (!(object instanceof DEROctetString)) {
        throw new CertificateException(
                "Invalid data in IssuingDistributionPoint extension, not DEROctetString");
    }
    DEROctetString string = (DEROctetString) object;

    object = ASN1Object.fromByteArray(string.getOctets());
    if (!(object instanceof ASN1Sequence)) {
        throw new CertificateException("Invalid data in IssuingDistributionPoint extension, not ASN1Sequence");
    }

    IssuingDistributionPoint issuingDistributionPoint = new IssuingDistributionPoint((ASN1Sequence) object);

    if (issuingDistributionPoint.onlyContainsAttributeCerts()) {
        throw new CertificateException("CRL only contains attribute certs, not useful for authentication.");
    }

    if (issuingDistributionPoint.getOnlySomeReasons() != null) {
        throw new CertificateException(
                "CRL only contains some reasons of revocations, can't trust the certificates without other complementing CRL(s), which is not supported.");
    }
}