Example usage for org.bouncycastle.asn1.x509 PolicyInformation getInstance

List of usage examples for org.bouncycastle.asn1.x509 PolicyInformation getInstance

Introduction

In this page you can find the example usage for org.bouncycastle.asn1.x509 PolicyInformation getInstance.

Prototype

public static PolicyInformation getInstance(Object obj) 

Source Link

Usage

From source file:be.fedict.trust.constraints.CertificatePoliciesCertificateConstraint.java

License:Open Source License

@Override
public void check(X509Certificate certificate) throws TrustLinkerResultException, Exception {
    byte[] extensionValue = certificate.getExtensionValue(Extension.certificatePolicies.getId());
    if (null == extensionValue) {
        throw new TrustLinkerResultException(TrustLinkerResultReason.CONSTRAINT_VIOLATION,
                "missing certificate policies X509 extension");
    }/*from   w w  w.  j a v  a 2s.c  o m*/
    DEROctetString oct = (DEROctetString) (new ASN1InputStream(new ByteArrayInputStream(extensionValue))
            .readObject());
    ASN1Sequence certPolicies = (ASN1Sequence) new ASN1InputStream(oct.getOctets()).readObject();
    Enumeration<?> certPoliciesEnum = certPolicies.getObjects();
    while (certPoliciesEnum.hasMoreElements()) {
        PolicyInformation policyInfo = PolicyInformation.getInstance(certPoliciesEnum.nextElement());
        ASN1ObjectIdentifier policyOid = policyInfo.getPolicyIdentifier();
        String policyId = policyOid.getId();
        LOG.debug("present policy OID: " + policyId);
        if (this.certificatePolicies.contains(policyId)) {
            LOG.debug("matching certificate policy OID: " + policyId);
            return;
        }
    }
    throw new TrustLinkerResultException(TrustLinkerResultReason.CONSTRAINT_VIOLATION,
            "required policy OID not present");
}

From source file:com.jlocksmith.util.ExtensionUtil.java

License:Open Source License

/**
 * Get Certificate Policies String Value
 * /*from   w  w w.ja  v a 2 s .c o m*/
 * @param bytes
 * @return
 * @throws IOException
 */
private String getCertificatePoliciesStringValue(byte[] bytes) throws IOException {
    ASN1Sequence pSeq = (ASN1Sequence) toDERObject(bytes);
    StringBuffer sb = new StringBuffer();

    for (int i = 0, len = pSeq.size(); i < len; i++) {

        PolicyInformation pi = PolicyInformation.getInstance(pSeq.getObjectAt(i));

        sb.append(MessageFormat.format(localeUtil.getString("PolicyIdentifier"),
                new Object[] { pi.getPolicyIdentifier().getId() }));
        sb.append('\n');

        ASN1Sequence pQuals;

        if ((pQuals = pi.getPolicyQualifiers()) != null) {
            for (int j = 0, plen = pQuals.size(); j < plen; j++) {

                ASN1Sequence pqi = (ASN1Sequence) pQuals.getObjectAt(j);
                String pqId = ((DERObjectIdentifier) pqi.getObjectAt(0)).getId();

                sb.append('\t');
                sb.append(MessageFormat.format(getResource(pqId, "UnrecognisedPolicyQualifier"),
                        new Object[] { pqId }));
                sb.append('\n');

                if (pQuals.size() > 0) {

                    DEREncodable d = pqi.getObjectAt(1);

                    if (pqId.equals("1.3.6.1.5.5.7.2.1")) {
                        // cPSuri
                        sb.append("\t\t");
                        sb.append(MessageFormat.format(localeUtil.getString("CpsUri"),
                                new Object[] { ((DERString) d).getString() }));
                        sb.append('\n');
                    } else if (pqId.equals("1.3.6.1.5.5.7.2.2")) {
                        ASN1Sequence un = (ASN1Sequence) d;

                        for (int k = 0, dlen = un.size(); k < dlen; k++) {
                            DEREncodable de = un.getObjectAt(k);

                            if (de instanceof DERString) {
                                // explicitText
                                sb.append("\t\t");
                                sb.append(localeUtil.getString("ExplicitText"));
                                sb.append("\n\t\t\t");
                                sb.append(getObjectString(de));
                                sb.append('\n');
                            } else if (de instanceof ASN1Sequence) {
                                ASN1Sequence nr = (ASN1Sequence) de;

                                String orgstr = getObjectString(nr.getObjectAt(0));
                                ASN1Sequence nrs = (ASN1Sequence) nr.getObjectAt(1);

                                StringBuffer nrstr = new StringBuffer();
                                for (int m = 0, nlen = nrs.size(); m < nlen; m++) {
                                    nrstr.append(getObjectString(nrs.getObjectAt(m)));
                                    if (m != nlen - 1) {
                                        nrstr.append(", ");
                                    }
                                }
                                sb.append("\t\t");
                                sb.append(localeUtil.getString("NoticeRef"));
                                sb.append("\n\t\t\t");
                                sb.append(MessageFormat.format(localeUtil.getString("NoticeRefOrganization"),
                                        new Object[] { orgstr }));
                                sb.append("\n\t\t\t");
                                sb.append(MessageFormat.format(localeUtil.getString("NoticeRefNumber"),
                                        new Object[] { nrstr }));
                                sb.append('\n');
                            }
                        }
                    } else {
                        sb.append("\t\t");
                        sb.append(getObjectString(d));
                        sb.append('\n');
                    }
                }
            }
        }

        if (i != len) {
            sb.append('\n');
        }
    }

    return sb.toString();
}

From source file:ec.rubrica.util.BouncyCastleUtils.java

License:Open Source License

public static boolean certificateHasPolicy(X509Certificate cert, String sOid) {
    try {//from   w  w w  .ja  va2s . co  m
        logger.fine("Read cert policies: " + cert.getSerialNumber().toString());

        ByteArrayInputStream bIn = new ByteArrayInputStream(cert.getEncoded());
        ASN1InputStream aIn = new ASN1InputStream(bIn);
        ASN1Sequence seq = (ASN1Sequence) aIn.readObject();
        X509CertificateStructure obj = new X509CertificateStructure(seq);
        TBSCertificateStructure tbsCert = obj.getTBSCertificate();
        if (tbsCert.getVersion() == 3) {
            X509Extensions ext = tbsCert.getExtensions();
            if (ext != null) {
                Enumeration en = ext.oids();
                while (en.hasMoreElements()) {
                    DERObjectIdentifier oid = (DERObjectIdentifier) en.nextElement();
                    X509Extension extVal = ext.getExtension(oid);
                    ASN1OctetString oct = extVal.getValue();
                    ASN1InputStream extIn = new ASN1InputStream(new ByteArrayInputStream(oct.getOctets()));

                    if (oid.equals(X509Extension.certificatePolicies)) {
                        ASN1Sequence cp = (ASN1Sequence) extIn.readObject();
                        for (int i = 0; i != cp.size(); i++) {
                            PolicyInformation pol = PolicyInformation.getInstance(cp.getObjectAt(i));
                            DERObjectIdentifier dOid = pol.getPolicyIdentifier();
                            String soid2 = dOid.getId();

                            logger.fine("Policy: " + soid2);
                            if (soid2.startsWith(sOid))
                                return true;
                        }
                    }
                }
            }

        }
    } catch (Exception ex) {
        logger.severe("Error reading cert policies: " + ex);
    }
    return false;
}

From source file:eu.emi.security.authn.x509.helpers.pkipath.bc.FixedBCPKIXCertPathReviewer.java

License:Open Source License

private void checkPolicy() {
    ////from   w  w  w .  j a  v  a2s.  co  m
    // 6.1.1 Inputs
    //

    // c) Initial Policy Set

    Set userInitialPolicySet = pkixParams.getInitialPolicies();

    // e) f) g) are part of pkixParams

    //
    // 6.1.2 Initialization
    //

    // a) valid policy tree

    List[] policyNodes = new ArrayList[n + 1];
    for (int j = 0; j < policyNodes.length; j++) {
        policyNodes[j] = new ArrayList();
    }

    Set policySet = new HashSet();

    policySet.add(ANY_POLICY);

    PKIXPolicyNode validPolicyTree = new PKIXPolicyNode(new ArrayList(), 0, policySet, null, new HashSet(),
            ANY_POLICY, false);

    policyNodes[0].add(validPolicyTree);

    // d) explicit policy

    int explicitPolicy;
    if (pkixParams.isExplicitPolicyRequired()) {
        explicitPolicy = 0;
    } else {
        explicitPolicy = n + 1;
    }

    // e) inhibit any policy

    int inhibitAnyPolicy;
    if (pkixParams.isAnyPolicyInhibited()) {
        inhibitAnyPolicy = 0;
    } else {
        inhibitAnyPolicy = n + 1;
    }

    // f) policy mapping

    int policyMapping;
    if (pkixParams.isPolicyMappingInhibited()) {
        policyMapping = 0;
    } else {
        policyMapping = n + 1;
    }

    Set acceptablePolicies = null;

    //
    // 6.1.3 Basic Certificate processing
    //

    X509Certificate cert = null;
    int index;
    int i;

    try {
        for (index = certs.size() - 1; index >= 0; index--) {
            // i as defined in the algorithm description
            i = n - index;

            // set certificate to be checked in this round
            cert = (X509Certificate) certs.get(index);

            // d) process policy information

            ASN1Sequence certPolicies;
            try {
                certPolicies = (ASN1Sequence) getExtensionValue(cert, CERTIFICATE_POLICIES);
            } catch (AnnotatedException ae) {
                ErrorBundle msg = new ErrorBundle(RESOURCE_NAME, "CertPathReviewer.policyExtError");
                throw new CertPathReviewerException(msg, ae, certPath, index);
            }
            if (certPolicies != null && validPolicyTree != null) {

                // d) 1)

                Enumeration e = certPolicies.getObjects();
                Set pols = new HashSet();

                while (e.hasMoreElements()) {
                    PolicyInformation pInfo = PolicyInformation.getInstance(e.nextElement());
                    ASN1ObjectIdentifier pOid = pInfo.getPolicyIdentifier();

                    pols.add(pOid.getId());

                    if (!ANY_POLICY.equals(pOid.getId())) {
                        Set pq;
                        try {
                            pq = getQualifierSet(pInfo.getPolicyQualifiers());
                        } catch (CertPathValidatorException cpve) {
                            ErrorBundle msg = new ErrorBundle(RESOURCE_NAME,
                                    "CertPathReviewer.policyQualifierError");
                            throw new CertPathReviewerException(msg, cpve, certPath, index);
                        }

                        boolean match = processCertD1i(i, policyNodes, pOid, pq);

                        if (!match) {
                            processCertD1ii(i, policyNodes, pOid, pq);
                        }
                    }
                }

                if (acceptablePolicies == null || acceptablePolicies.contains(ANY_POLICY)) {
                    acceptablePolicies = pols;
                } else {
                    Iterator it = acceptablePolicies.iterator();
                    Set t1 = new HashSet();

                    while (it.hasNext()) {
                        Object o = it.next();

                        if (pols.contains(o)) {
                            t1.add(o);
                        }
                    }

                    acceptablePolicies = t1;
                }

                // d) 2)

                if ((inhibitAnyPolicy > 0) || ((i < n) && isSelfIssued(cert))) {
                    e = certPolicies.getObjects();

                    while (e.hasMoreElements()) {
                        PolicyInformation pInfo = PolicyInformation.getInstance(e.nextElement());

                        if (ANY_POLICY.equals(pInfo.getPolicyIdentifier().getId())) {
                            Set _apq;
                            try {
                                _apq = getQualifierSet(pInfo.getPolicyQualifiers());
                            } catch (CertPathValidatorException cpve) {
                                ErrorBundle msg = new ErrorBundle(RESOURCE_NAME,
                                        "CertPathReviewer.policyQualifierError");
                                throw new CertPathReviewerException(msg, cpve, certPath, index);
                            }
                            List _nodes = policyNodes[i - 1];

                            for (int k = 0; k < _nodes.size(); k++) {
                                PKIXPolicyNode _node = (PKIXPolicyNode) _nodes.get(k);

                                Iterator _policySetIter = _node.getExpectedPolicies().iterator();
                                while (_policySetIter.hasNext()) {
                                    Object _tmp = _policySetIter.next();

                                    String _policy;
                                    if (_tmp instanceof String) {
                                        _policy = (String) _tmp;
                                    } else if (_tmp instanceof ASN1ObjectIdentifier) {
                                        _policy = ((ASN1ObjectIdentifier) _tmp).getId();
                                    } else {
                                        continue;
                                    }

                                    boolean _found = false;
                                    Iterator _childrenIter = _node.getChildren();

                                    while (_childrenIter.hasNext()) {
                                        PKIXPolicyNode _child = (PKIXPolicyNode) _childrenIter.next();

                                        if (_policy.equals(_child.getValidPolicy())) {
                                            _found = true;
                                        }
                                    }

                                    if (!_found) {
                                        Set _newChildExpectedPolicies = new HashSet();
                                        _newChildExpectedPolicies.add(_policy);

                                        PKIXPolicyNode _newChild = new PKIXPolicyNode(new ArrayList(), i,
                                                _newChildExpectedPolicies, _node, _apq, _policy, false);
                                        _node.addChild(_newChild);
                                        policyNodes[i].add(_newChild);
                                    }
                                }
                            }
                            break;
                        }
                    }
                }

                //
                // (d) (3)
                //
                for (int j = (i - 1); j >= 0; j--) {
                    List nodes = policyNodes[j];

                    for (int k = 0; k < nodes.size(); k++) {
                        PKIXPolicyNode node = (PKIXPolicyNode) nodes.get(k);
                        if (!node.hasChildren()) {
                            validPolicyTree = removePolicyNode(validPolicyTree, policyNodes, node);
                            if (validPolicyTree == null) {
                                break;
                            }
                        }
                    }
                }

                //
                // d (4)
                //
                Set criticalExtensionOids = cert.getCriticalExtensionOIDs();

                if (criticalExtensionOids != null) {
                    boolean critical = criticalExtensionOids.contains(CERTIFICATE_POLICIES);

                    List nodes = policyNodes[i];
                    for (int j = 0; j < nodes.size(); j++) {
                        PKIXPolicyNode node = (PKIXPolicyNode) nodes.get(j);
                        node.setCritical(critical);
                    }
                }

            }

            // e)

            if (certPolicies == null) {
                validPolicyTree = null;
            }

            // f)

            if (explicitPolicy <= 0 && validPolicyTree == null) {
                ErrorBundle msg = new ErrorBundle(RESOURCE_NAME, "CertPathReviewer.noValidPolicyTree");
                throw new CertPathReviewerException(msg);
            }

            //
            // 6.1.4 preparation for next Certificate
            //

            if (i != n) {

                // a)

                ASN1Primitive pm;
                try {
                    pm = getExtensionValue(cert, POLICY_MAPPINGS);
                } catch (AnnotatedException ae) {
                    ErrorBundle msg = new ErrorBundle(RESOURCE_NAME, "CertPathReviewer.policyMapExtError");
                    throw new CertPathReviewerException(msg, ae, certPath, index);
                }

                if (pm != null) {
                    ASN1Sequence mappings = (ASN1Sequence) pm;
                    for (int j = 0; j < mappings.size(); j++) {
                        ASN1Sequence mapping = (ASN1Sequence) mappings.getObjectAt(j);
                        ASN1ObjectIdentifier ip_id = (ASN1ObjectIdentifier) mapping.getObjectAt(0);
                        ASN1ObjectIdentifier sp_id = (ASN1ObjectIdentifier) mapping.getObjectAt(1);
                        if (ANY_POLICY.equals(ip_id.getId())) {
                            ErrorBundle msg = new ErrorBundle(RESOURCE_NAME,
                                    "CertPathReviewer.invalidPolicyMapping");
                            throw new CertPathReviewerException(msg, certPath, index);
                        }
                        if (ANY_POLICY.equals(sp_id.getId())) {
                            ErrorBundle msg = new ErrorBundle(RESOURCE_NAME,
                                    "CertPathReviewer.invalidPolicyMapping");
                            throw new CertPathReviewerException(msg, certPath, index);
                        }
                    }
                }

                // b)

                if (pm != null) {
                    ASN1Sequence mappings = (ASN1Sequence) pm;
                    Map m_idp = new HashMap();
                    Set s_idp = new HashSet();

                    for (int j = 0; j < mappings.size(); j++) {
                        ASN1Sequence mapping = (ASN1Sequence) mappings.getObjectAt(j);
                        String id_p = ((ASN1ObjectIdentifier) mapping.getObjectAt(0)).getId();
                        String sd_p = ((ASN1ObjectIdentifier) mapping.getObjectAt(1)).getId();
                        Set tmp;

                        if (!m_idp.containsKey(id_p)) {
                            tmp = new HashSet();
                            tmp.add(sd_p);
                            m_idp.put(id_p, tmp);
                            s_idp.add(id_p);
                        } else {
                            tmp = (Set) m_idp.get(id_p);
                            tmp.add(sd_p);
                        }
                    }

                    Iterator it_idp = s_idp.iterator();
                    while (it_idp.hasNext()) {
                        String id_p = (String) it_idp.next();

                        //
                        // (1)
                        //
                        if (policyMapping > 0) {
                            try {
                                prepareNextCertB1(i, policyNodes, id_p, m_idp, cert);
                            } catch (AnnotatedException ae) {
                                // error processing certificate policies extension
                                ErrorBundle msg = new ErrorBundle(RESOURCE_NAME,
                                        "CertPathReviewer.policyExtError");
                                throw new CertPathReviewerException(msg, ae, certPath, index);
                            } catch (CertPathValidatorException cpve) {
                                // error building qualifier set
                                ErrorBundle msg = new ErrorBundle(RESOURCE_NAME,
                                        "CertPathReviewer.policyQualifierError");
                                throw new CertPathReviewerException(msg, cpve, certPath, index);
                            }

                            //
                            // (2)
                            // 
                        } else if (policyMapping <= 0) {
                            validPolicyTree = prepareNextCertB2(i, policyNodes, id_p, validPolicyTree);
                        }

                    }
                }

                //
                // h)
                //

                if (!isSelfIssued(cert)) {

                    // (1)
                    if (explicitPolicy != 0) {
                        explicitPolicy--;
                    }

                    // (2)
                    if (policyMapping != 0) {
                        policyMapping--;
                    }

                    // (3)
                    if (inhibitAnyPolicy != 0) {
                        inhibitAnyPolicy--;
                    }

                }

                //
                // i)
                //

                try {
                    ASN1Sequence pc = (ASN1Sequence) getExtensionValue(cert, POLICY_CONSTRAINTS);
                    if (pc != null) {
                        Enumeration policyConstraints = pc.getObjects();

                        while (policyConstraints.hasMoreElements()) {
                            ASN1TaggedObject constraint = (ASN1TaggedObject) policyConstraints.nextElement();
                            int tmpInt;

                            switch (constraint.getTagNo()) {
                            case 0:
                                tmpInt = ASN1Integer.getInstance(constraint, false).getValue().intValue();
                                if (tmpInt < explicitPolicy) {
                                    explicitPolicy = tmpInt;
                                }
                                break;
                            case 1:
                                tmpInt = ASN1Integer.getInstance(constraint, false).getValue().intValue();
                                if (tmpInt < policyMapping) {
                                    policyMapping = tmpInt;
                                }
                                break;
                            }
                        }
                    }
                } catch (AnnotatedException ae) {
                    ErrorBundle msg = new ErrorBundle(RESOURCE_NAME, "CertPathReviewer.policyConstExtError");
                    throw new CertPathReviewerException(msg, certPath, index);
                }

                //
                // j)
                //

                try {
                    ASN1Integer iap = (ASN1Integer) getExtensionValue(cert, INHIBIT_ANY_POLICY);

                    if (iap != null) {
                        int _inhibitAnyPolicy = iap.getValue().intValue();

                        if (_inhibitAnyPolicy < inhibitAnyPolicy) {
                            inhibitAnyPolicy = _inhibitAnyPolicy;
                        }
                    }
                } catch (AnnotatedException ae) {
                    ErrorBundle msg = new ErrorBundle(RESOURCE_NAME, "CertPathReviewer.policyInhibitExtError");
                    throw new CertPathReviewerException(msg, certPath, index);
                }
            }

        }

        //
        // 6.1.5 Wrap up
        //

        //
        // a)
        //

        if (!isSelfIssued(cert) && explicitPolicy > 0) {
            explicitPolicy--;
        }

        //
        // b)
        //

        try {
            ASN1Sequence pc = (ASN1Sequence) getExtensionValue(cert, POLICY_CONSTRAINTS);
            if (pc != null) {
                Enumeration policyConstraints = pc.getObjects();

                while (policyConstraints.hasMoreElements()) {
                    ASN1TaggedObject constraint = (ASN1TaggedObject) policyConstraints.nextElement();
                    switch (constraint.getTagNo()) {
                    case 0:
                        int tmpInt = ASN1Integer.getInstance(constraint, false).getValue().intValue();
                        if (tmpInt == 0) {
                            explicitPolicy = 0;
                        }
                        break;
                    }
                }
            }
        } catch (AnnotatedException e) {
            ErrorBundle msg = new ErrorBundle(RESOURCE_NAME, "CertPathReviewer.policyConstExtError");
            throw new CertPathReviewerException(msg, certPath, index);
        }

        //
        // (g)
        //
        PKIXPolicyNode intersection;

        //
        // (g) (i)
        //
        if (validPolicyTree == null) {
            if (pkixParams.isExplicitPolicyRequired()) {
                ErrorBundle msg = new ErrorBundle(RESOURCE_NAME, "CertPathReviewer.explicitPolicy");
                throw new CertPathReviewerException(msg, certPath, index);
            }
            intersection = null;
        } else if (isAnyPolicy(userInitialPolicySet)) // (g) (ii)
        {
            if (pkixParams.isExplicitPolicyRequired()) {
                if (acceptablePolicies.isEmpty()) {
                    ErrorBundle msg = new ErrorBundle(RESOURCE_NAME, "CertPathReviewer.explicitPolicy");
                    throw new CertPathReviewerException(msg, certPath, index);
                } else {
                    Set _validPolicyNodeSet = new HashSet();

                    for (int j = 0; j < policyNodes.length; j++) {
                        List _nodeDepth = policyNodes[j];

                        for (int k = 0; k < _nodeDepth.size(); k++) {
                            PKIXPolicyNode _node = (PKIXPolicyNode) _nodeDepth.get(k);

                            if (ANY_POLICY.equals(_node.getValidPolicy())) {
                                Iterator _iter = _node.getChildren();
                                while (_iter.hasNext()) {
                                    _validPolicyNodeSet.add(_iter.next());
                                }
                            }
                        }
                    }

                    Iterator _vpnsIter = _validPolicyNodeSet.iterator();
                    while (_vpnsIter.hasNext()) {
                        PKIXPolicyNode _node = (PKIXPolicyNode) _vpnsIter.next();
                        String _validPolicy = _node.getValidPolicy();

                        if (!acceptablePolicies.contains(_validPolicy)) {
                            //validPolicyTree = removePolicyNode(validPolicyTree, policyNodes, _node);
                        }
                    }
                    if (validPolicyTree != null) {
                        for (int j = (n - 1); j >= 0; j--) {
                            List nodes = policyNodes[j];

                            for (int k = 0; k < nodes.size(); k++) {
                                PKIXPolicyNode node = (PKIXPolicyNode) nodes.get(k);
                                if (!node.hasChildren()) {
                                    validPolicyTree = removePolicyNode(validPolicyTree, policyNodes, node);
                                }
                            }
                        }
                    }
                }
            }

            intersection = validPolicyTree;
        } else {
            //
            // (g) (iii)
            //
            // This implementation is not exactly same as the one described in RFC3280.
            // However, as far as the validation result is concerned, both produce 
            // adequate result. The only difference is whether AnyPolicy is remain 
            // in the policy tree or not. 
            //
            // (g) (iii) 1
            //
            Set _validPolicyNodeSet = new HashSet();

            for (int j = 0; j < policyNodes.length; j++) {
                List _nodeDepth = policyNodes[j];

                for (int k = 0; k < _nodeDepth.size(); k++) {
                    PKIXPolicyNode _node = (PKIXPolicyNode) _nodeDepth.get(k);

                    if (ANY_POLICY.equals(_node.getValidPolicy())) {
                        Iterator _iter = _node.getChildren();
                        while (_iter.hasNext()) {
                            PKIXPolicyNode _c_node = (PKIXPolicyNode) _iter.next();
                            if (!ANY_POLICY.equals(_c_node.getValidPolicy())) {
                                _validPolicyNodeSet.add(_c_node);
                            }
                        }
                    }
                }
            }

            //
            // (g) (iii) 2
            //
            Iterator _vpnsIter = _validPolicyNodeSet.iterator();
            while (_vpnsIter.hasNext()) {
                PKIXPolicyNode _node = (PKIXPolicyNode) _vpnsIter.next();
                String _validPolicy = _node.getValidPolicy();

                if (!userInitialPolicySet.contains(_validPolicy)) {
                    validPolicyTree = removePolicyNode(validPolicyTree, policyNodes, _node);
                }
            }

            //
            // (g) (iii) 4
            //
            if (validPolicyTree != null) {
                for (int j = (n - 1); j >= 0; j--) {
                    List nodes = policyNodes[j];

                    for (int k = 0; k < nodes.size(); k++) {
                        PKIXPolicyNode node = (PKIXPolicyNode) nodes.get(k);
                        if (!node.hasChildren()) {
                            validPolicyTree = removePolicyNode(validPolicyTree, policyNodes, node);
                        }
                    }
                }
            }

            intersection = validPolicyTree;
        }

        if ((explicitPolicy <= 0) && (intersection == null)) {
            ErrorBundle msg = new ErrorBundle(RESOURCE_NAME, "CertPathReviewer.invalidPolicy");
            throw new CertPathReviewerException(msg);
        }

        validPolicyTree = intersection;
    } catch (CertPathReviewerException cpre) {
        addError(cpre.getErrorMessage(), cpre.getIndex());
        validPolicyTree = null;
    }
}

From source file:eu.europa.ec.markt.dss.DSSUtils.java

License:Open Source License

public static List<String> getPolicyIdentifiers(final X509Certificate cert) {

    final byte[] certificatePolicies = cert.getExtensionValue(X509Extension.certificatePolicies.getId());
    if (certificatePolicies == null) {

        return Collections.emptyList();
    }/*from www. ja v a  2s .c om*/
    ASN1InputStream input = null;
    ASN1Sequence seq = null;
    try {

        input = new ASN1InputStream(certificatePolicies);
        final DEROctetString s = (DEROctetString) input.readObject();
        final byte[] content = s.getOctets();
        input.close();
        input = new ASN1InputStream(content);
        seq = (ASN1Sequence) input.readObject();
    } catch (IOException e) {

        throw new DSSException("Error when computing certificate's extensions.", e);
    } finally {

        closeQuietly(input);
    }
    final List<String> policyIdentifiers = new ArrayList<String>();
    for (int ii = 0; ii < seq.size(); ii++) {

        final PolicyInformation policyInfo = PolicyInformation.getInstance(seq.getObjectAt(ii));
        // System.out.println("\t----> PolicyIdentifier: " + policyInfo.getPolicyIdentifier().getId());
        policyIdentifiers.add(policyInfo.getPolicyIdentifier().getId());

    }
    return policyIdentifiers;
}

From source file:eu.europa.ec.markt.dss.validation.tsl.PolicyIdCondition.java

License:Open Source License

@SuppressWarnings("deprecation")
@Override//from   w  w  w. j a va  2  s.  c o m
public boolean check(CertificateAndContext cert) {
    byte[] certificatePolicies = cert.getCertificate()
            .getExtensionValue(X509Extensions.CertificatePolicies.getId());
    if (certificatePolicies != null) {
        try {
            ASN1InputStream input = new ASN1InputStream(certificatePolicies);
            DEROctetString s = (DEROctetString) input.readObject();
            byte[] content = s.getOctets();
            input = new ASN1InputStream(content);
            DERSequence seq = (DERSequence) input.readObject();
            for (int i = 0; i < seq.size(); i++) {
                PolicyInformation policyInfo = PolicyInformation.getInstance(seq.getObjectAt(i));
                if (policyInfo.getPolicyIdentifier().getId().equals(policyOid)) {
                    return true;
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    return false;
}

From source file:eu.europa.esig.dss.DSSASN1Utils.java

License:Open Source License

public static List<String> getPolicyIdentifiers(final CertificateToken certToken) {
    List<String> policyIdentifiers = new ArrayList<String>();
    final byte[] certificatePolicies = certToken.getCertificate()
            .getExtensionValue(Extension.certificatePolicies.getId());
    if (certificatePolicies != null) {
        ASN1Sequence seq = getAsn1SequenceFromDerOctetString(certificatePolicies);
        for (int ii = 0; ii < seq.size(); ii++) {
            final PolicyInformation policyInfo = PolicyInformation.getInstance(seq.getObjectAt(ii));
            policyIdentifiers.add(policyInfo.getPolicyIdentifier().getId());
        }//from www. ja  va  2s.co  m
    }
    return policyIdentifiers;
}

From source file:net.ripe.rpki.commons.crypto.x509cert.X509ResourceCertificateParser.java

License:BSD License

private void validateCertificatePolicy() {
    if (!result.rejectIfNull(certificate.getCriticalExtensionOIDs(), CRITICAL_EXT_PRESENT)) {
        return;/*  w ww. j av  a2 s .  co  m*/
    }

    result.rejectIfFalse(
            certificate.getCriticalExtensionOIDs().contains(X509Extension.certificatePolicies.getId()),
            POLICY_EXT_CRITICAL);

    try {
        byte[] extensionValue = certificate.getExtensionValue(X509Extension.certificatePolicies.getId());
        if (!result.rejectIfNull(extensionValue, POLICY_EXT_VALUE)) {
            return;
        }
        ASN1Sequence policies = ASN1Sequence.getInstance(X509ExtensionUtil.fromExtensionValue(extensionValue));
        if (!result.rejectIfFalse(policies.size() == 1, SINGLE_CERT_POLICY)) {
            return;
        }
        PolicyInformation policy = PolicyInformation.getInstance(policies.getObjectAt(0));

        if (!result.rejectIfNull(policy.getPolicyIdentifier(), POLICY_ID_PRESENT)) {
            return;
        }
        result.rejectIfFalse(POLICY_OID.equals(policy.getPolicyIdentifier()), POLICY_ID_VERSION);
    } catch (IOException e) {
        result.rejectIfFalse(false, POLICY_VALIDATION);
    }
}

From source file:net.sf.portecle.crypto.X509Ext.java

License:Open Source License

/**
 * Get extension value for Certificate Policies as a string.
 * /*ww w.  j a  va 2  s. c  o m*/
 * @see <a href="http://tools.ietf.org/html/rfc3280">RFC 3280</a>
 * @param bValue The octet string value
 * @return Extension value as a string
 * @throws IOException If an I/O problem occurs
 */
private String getCertificatePoliciesStringValue(byte[] bValue) throws IOException {
    ASN1Sequence pSeq = (ASN1Sequence) ASN1Primitive.fromByteArray(bValue);
    StringBuilder sb = new StringBuilder();

    for (int i = 0, len = pSeq.size(); i < len; i++) {
        PolicyInformation pi = PolicyInformation.getInstance(pSeq.getObjectAt(i));
        String piId = pi.getPolicyIdentifier().getId();

        sb.append("<ul><li>");
        sb.append(RB.getString("PolicyIdentifier"));
        sb.append(": ");
        sb.append(MessageFormat.format(getRes(piId, "UnrecognisedPolicyIdentifier"), piId));

        ASN1Sequence pQuals;
        if ((pQuals = pi.getPolicyQualifiers()) != null) {
            sb.append("<ul>");

            for (int j = 0, plen = pQuals.size(); j < plen; j++) {
                ASN1Sequence pqi = (ASN1Sequence) pQuals.getObjectAt(j);
                ASN1Encodable pqId = pqi.getObjectAt(0);
                String spqId = pqId.toString();

                sb.append("<li>");
                sb.append(MessageFormat.format(getRes(spqId, "UnrecognisedPolicyQualifier"), spqId));
                sb.append(": ");

                ASN1Encodable d = pqi.getObjectAt(1);
                sb.append("<ul>");
                if (pqId.equals(PolicyQualifierId.id_qt_cps)) {
                    // cPSuri
                    String sUri = ((ASN1String) d).getString();

                    sb.append("<li>");
                    sb.append(RB.getString("CpsUri"));
                    sb.append(": ");
                    sb.append(getLink(sUri, escapeHtml(sUri), LinkClass.BROWSER));
                    sb.append("</li>");
                } else if (pqId.equals(PolicyQualifierId.id_qt_unotice)) {
                    // userNotice
                    ASN1Sequence un = (ASN1Sequence) d;

                    for (int k = 0, dlen = un.size(); k < dlen; k++) {
                        ASN1Encodable de = un.getObjectAt(k);

                        // TODO: is it possible to use something
                        // smarter than instanceof here?

                        if (de instanceof ASN1String) {
                            // explicitText
                            sb.append("<li>");
                            sb.append(RB.getString("ExplicitText"));
                            sb.append(": ");
                            sb.append(stringify(de));
                            sb.append("</li>");
                        } else if (de instanceof ASN1Sequence) {
                            // noticeRef
                            ASN1Sequence nr = (ASN1Sequence) de;
                            String orgstr = stringify(nr.getObjectAt(0));
                            ASN1Sequence nrs = (ASN1Sequence) nr.getObjectAt(1);
                            StringBuilder nrstr = new StringBuilder();
                            for (int m = 0, nlen = nrs.size(); m < nlen; m++) {
                                nrstr.append(stringify(nrs.getObjectAt(m)));
                                if (m != nlen - 1) {
                                    nrstr.append(", ");
                                }
                            }
                            sb.append("<li>");
                            sb.append(RB.getString("NoticeRef"));
                            sb.append(": ");
                            sb.append(RB.getString("NoticeRefOrganization"));
                            sb.append(": ");
                            sb.append(orgstr);
                            sb.append(", ");
                            sb.append(RB.getString("NoticeRefNumber"));
                            sb.append(": ");
                            sb.append(nrstr);
                            sb.append("</li>");
                        }
                        // else TODO
                    }
                } else {
                    sb.append(stringify(d));
                }
                sb.append("</ul></li>");
            }
            sb.append("</ul></li>");
        }

        sb.append("</ul>");
        if (i != len) {
            sb.append("<br>");
        }
    }

    return sb.toString();
}

From source file:org.cesecore.util.CertTools.java

License:Open Source License

/**
 * Get a certificate policy ID from a certificate policies extension
 * /*from  w w  w  .  j  a  v  a  2s . com*/
 * @param cert certificate containing the extension
 * @param pos position of the policy id, if several exist, the first is as pos 0
 * @return String with the certificate policy OID, or null if an id at the given position does not exist
 * @throws IOException if extension can not be parsed
 */
public static String getCertificatePolicyId(Certificate cert, int pos) throws IOException {
    String ret = null;
    if (cert instanceof X509Certificate) {
        X509Certificate x509cert = (X509Certificate) cert;
        byte[] extvalue = x509cert.getExtensionValue(Extension.certificatePolicies.getId());
        if (extvalue == null) {
            return null;
        }
        ASN1InputStream extAsn1InputStream = new ASN1InputStream(new ByteArrayInputStream(extvalue));
        try {
            DEROctetString oct = (DEROctetString) (extAsn1InputStream.readObject());
            ASN1InputStream octAsn1InputStream = new ASN1InputStream(new ByteArrayInputStream(oct.getOctets()));
            try {
                ASN1Sequence seq = (ASN1Sequence) octAsn1InputStream.readObject();
                // Check the size so we don't ArrayIndexOutOfBounds
                if (seq.size() < pos + 1) {
                    return null;
                }
                PolicyInformation pol = PolicyInformation.getInstance((ASN1Sequence) seq.getObjectAt(pos));
                ret = pol.getPolicyIdentifier().getId();
            } finally {
                octAsn1InputStream.close();
            }
        } finally {
            extAsn1InputStream.close();
        }
    }
    return ret;
}