Example usage for org.bouncycastle.asn1.x509 TBSCertificateStructure getIssuer

List of usage examples for org.bouncycastle.asn1.x509 TBSCertificateStructure getIssuer

  1. HOME
  2. Java
  3. org.bouncycastle
  4. org.bouncycastle.asn1.x509.*
  5. TBSCertificateStructure
  6. getIssuer

Introduction

In this page you can find the example usage for org.bouncycastle.asn1.x509 TBSCertificateStructure getIssuer.

Prototype

public X500Name getIssuer()

Source Link

Usage

From source file:cljpdf.text.pdf.PdfPublicKeySecurityHandler.java

License:Mozilla Public License

private KeyTransRecipientInfo computeRecipientInfo(X509Certificate x509certificate, byte[] abyte0)
        throws GeneralSecurityException, IOException {
    ASN1InputStream asn1inputstream = new ASN1InputStream(
            new ByteArrayInputStream(x509certificate.getTBSCertificate()));
    TBSCertificateStructure tbscertificatestructure = TBSCertificateStructure
            .getInstance(asn1inputstream.readObject());
    AlgorithmIdentifier algorithmidentifier = tbscertificatestructure.getSubjectPublicKeyInfo()
            .getAlgorithmId();/* w  w w  . ja v  a 2 s . c o  m*/
    IssuerAndSerialNumber issuerandserialnumber = new IssuerAndSerialNumber(tbscertificatestructure.getIssuer(),
            tbscertificatestructure.getSerialNumber().getValue());
    Cipher cipher = Cipher.getInstance(algorithmidentifier.getObjectId().getId());
    cipher.init(1, x509certificate);
    DEROctetString deroctetstring = new DEROctetString(cipher.doFinal(abyte0));
    RecipientIdentifier recipId = new RecipientIdentifier(issuerandserialnumber);
    return new KeyTransRecipientInfo(recipId, algorithmidentifier, deroctetstring);
}

From source file:com.itextpdf.kernel.crypto.securityhandler.PubKeySecurityHandler.java

License:Open Source License

private KeyTransRecipientInfo computeRecipientInfo(X509Certificate x509certificate, byte[] abyte0)
        throws GeneralSecurityException, IOException {
    ASN1InputStream asn1inputstream = new ASN1InputStream(
            new ByteArrayInputStream(x509certificate.getTBSCertificate()));
    TBSCertificateStructure tbscertificatestructure = TBSCertificateStructure
            .getInstance(asn1inputstream.readObject());
    assert tbscertificatestructure != null;
    AlgorithmIdentifier algorithmidentifier = tbscertificatestructure.getSubjectPublicKeyInfo().getAlgorithm();
    IssuerAndSerialNumber issuerandserialnumber = new IssuerAndSerialNumber(tbscertificatestructure.getIssuer(),
            tbscertificatestructure.getSerialNumber().getValue());
    byte[] cipheredBytes = EncryptionUtils.cipherBytes(x509certificate, abyte0, algorithmidentifier);
    DEROctetString deroctetstring = new DEROctetString(cipheredBytes);
    RecipientIdentifier recipId = new RecipientIdentifier(issuerandserialnumber);
    return new KeyTransRecipientInfo(recipId, algorithmidentifier, deroctetstring);
}

From source file:com.itextpdf.text.pdf.PdfPublicKeySecurityHandler.java

License:Open Source License

private KeyTransRecipientInfo computeRecipientInfo(X509Certificate x509certificate, byte[] abyte0)
        throws GeneralSecurityException, IOException {
    ASN1InputStream asn1inputstream = new ASN1InputStream(
            new ByteArrayInputStream(x509certificate.getTBSCertificate()));
    TBSCertificateStructure tbscertificatestructure = TBSCertificateStructure
            .getInstance(asn1inputstream.readObject());
    AlgorithmIdentifier algorithmidentifier = tbscertificatestructure.getSubjectPublicKeyInfo().getAlgorithm();
    IssuerAndSerialNumber issuerandserialnumber = new IssuerAndSerialNumber(tbscertificatestructure.getIssuer(),
            tbscertificatestructure.getSerialNumber().getValue());
    Cipher cipher = Cipher.getInstance(algorithmidentifier.getAlgorithm().getId());
    try {//from   ww w  .j  av a2 s .c om
        cipher.init(1, x509certificate);
    } catch (InvalidKeyException e) {
        cipher.init(1, x509certificate.getPublicKey());
    }
    DEROctetString deroctetstring = new DEROctetString(cipher.doFinal(abyte0));
    RecipientIdentifier recipId = new RecipientIdentifier(issuerandserialnumber);
    return new KeyTransRecipientInfo(recipId, algorithmidentifier, deroctetstring);
}

From source file:com.yacme.ext.oxsit.cust_it.comp.security.cert.CertificateComplianceCA_IT.java

License:Open Source License

/**
* @param _TbsC /*ww  w.  j a va 2  s .  c  o  m*/
 * @return
*/
private boolean isIssuerIdOk(TBSCertificateStructure _TbsC) {
    //check if issuer element has both organizationName and countryName
    boolean isOk = false;
    //the CNIPA requirement are identical to
    //ETSI 102 280 and ETSI 101 862 requirements
    Vector<DERObjectIdentifier> oidv = _TbsC.getIssuer().getOIDs();
    if (oidv.contains(X509Name.O) && //organizationName
            oidv.contains(X509Name.C)) //countryName
        isOk = true;
    return isOk;
}

From source file:es.gob.afirma.envelopers.cades.CAdESEPESSignedAndEnvelopedData.java

License:Open Source License

/** M&eacute;todo que genera la firma de tipo SignedAndEnvelopedData.
 * @param parameters//from   w w  w.  ja v a  2 s .c  o  m
 *        Par&aacute;metros necesarios para la generaci&oacute;n de este
 *        tipo.
 * @param config
 *        Configuraci&oacute;n del algoritmo para firmar
 * @param policy
 *        Pol&iacute;tica del certificado.
 * @param certDest
 *        Certificado del destino al cual va dirigido la firma.
 * @param dataType
 *        Identifica el tipo del contenido a firmar.
 * @param keyEntry
 *        Entrada a la clave de firma
 * @return Firma de tipo SignedAndEnvelopedData.
 * @throws java.io.IOException
 *         Si ocurre alg&uacute;n problema leyendo o escribiendo los
 *         datos
 * @throws java.security.cert.CertificateEncodingException
 *         Si se produce alguna excepci&oacute;n con los certificados de
 *         firma.
 * @throws java.security.NoSuchAlgorithmException
 *         Si no se encuentra un algoritmo v&aacute;lido. */
byte[] genCADESEPESSignedAndEnvelopedData(final P7ContentSignerParameters parameters,
        final X509Certificate[] signerCertificateChain, final AOCipherConfig config, final AdESPolicy policy,
        final X509Certificate[] certDest, final String dataType, final PrivateKeyEntry keyEntry)
        throws IOException, CertificateEncodingException, NoSuchAlgorithmException {

    final SecretKey cipherKey = CAdESUtils.initEnvelopedData(config, certDest);

    // 1. VERSION
    // la version se mete en el constructor del signedAndEnvelopedData y es
    // 1

    // 2. DIGESTALGORITM
    // buscamos que timo de algoritmo es y lo codificamos con su OID

    final String signatureAlgorithm;
    final String digestAlgorithm;
    final ASN1EncodableVector digestAlgs = new ASN1EncodableVector();

    try {
        signatureAlgorithm = parameters.getSignatureAlgorithm();
        digestAlgorithm = AOSignConstants.getDigestAlgorithmName(signatureAlgorithm);

        final AlgorithmIdentifier digAlgId = SigUtils.makeAlgId(AOAlgorithmID.getOID(digestAlgorithm));
        digestAlgs.add(digAlgId);
    } catch (final Exception e) {
        throw new IOException("Error de codificacion: " + e, e); //$NON-NLS-1$
    }

    // LISTA DE CERTIFICADOS: obtenemos la lista de certificados
    ASN1Set certificates = null;

    certificates = CAdESUtils.fetchCertificatesList(signerCertificateChain);

    // 2. RECIPIENTINFOS
    final Info infos = CAdESUtils.getEnvelopeInfo(parameters.getContent(), config, certDest, cipherKey);

    // 4. SIGNERINFO
    // raiz de la secuencia de SignerInfo
    final ASN1EncodableVector signerInfos = new ASN1EncodableVector();

    final TBSCertificateStructure tbs2 = TBSCertificateStructure
            .getInstance(ASN1Primitive.fromByteArray(signerCertificateChain[0].getTBSCertificate()));

    final IssuerAndSerialNumber encSid = new IssuerAndSerialNumber(X500Name.getInstance(tbs2.getIssuer()),
            tbs2.getSerialNumber().getValue());

    final SignerIdentifier identifier = new SignerIdentifier(encSid);

    // AlgorithmIdentifier
    final AlgorithmIdentifier digAlgId = new AlgorithmIdentifier(
            new ASN1ObjectIdentifier(AOAlgorithmID.getOID(digestAlgorithm)), new DERNull());

    // // ATRIBUTOS
    final ASN1EncodableVector contextExpecific = CAdESUtils.generateSignerInfo(signerCertificateChain[0],
            digestAlgorithm, parameters.getContent(), policy, null);
    this.signedAttr2 = SigUtils.getAttributeSet(new AttributeTable(contextExpecific));
    final ASN1Set signedAttr = SigUtils.getAttributeSet(new AttributeTable(contextExpecific));

    // digEncryptionAlgorithm
    final AlgorithmIdentifier encAlgId;
    try {
        encAlgId = SigUtils.makeAlgId(AOAlgorithmID.getOID("RSA")); //$NON-NLS-1$
    } catch (final Exception e) {
        throw new IOException("Error de codificacion: " + e, e); //$NON-NLS-1$
    }

    final ASN1OctetString sign2;
    try {
        sign2 = firma(signatureAlgorithm, keyEntry);
    } catch (final AOException ex) {
        throw new IOException("Error en la firma electronica: " + ex, ex); //$NON-NLS-1$
    }

    signerInfos.add(new SignerInfo(identifier, digAlgId, signedAttr, encAlgId, sign2, null // unsignedAttr
    ));

    final ASN1Set certrevlist = null;

    // construimos el Signed And Enveloped Data y lo devolvemos
    return new ContentInfo(PKCSObjectIdentifiers.signedAndEnvelopedData,
            new SignedAndEnvelopedData(new DERSet(infos.getRecipientInfos()), new DERSet(digestAlgs),
                    infos.getEncInfo(), certificates, certrevlist, new DERSet(signerInfos)))
                            .getEncoded(ASN1Encoding.DER);
}

From source file:es.gob.afirma.envelopers.cades.CAdESEPESSignedAndEnvelopedData.java

License:Open Source License

/** M&eacute;todo que inserta remitentes en el "OriginatorInfo" de un sobre
 * de tipo AuthenticatedEnvelopedData./*from  ww  w .j a  v a  2s .  c o  m*/
 * @return La nueva firma AuthenticatedEnvelopedData con los remitentes que
 *         ten&iacute;a (si los tuviera) con la cadena de certificados
 *         nueva.
 * @throws IOException */
byte[] addOriginatorInfo(final InputStream data, final P7ContentSignerParameters parameters,
        final X509Certificate[] signerCertificateChain, final PrivateKeyEntry keyEntry, final AdESPolicy policy)
        throws IOException {
    // boolean isValid = false;
    byte[] retorno = null;

    // LEEMOS EL FICHERO QUE NOS INTRODUCEN
    final ASN1InputStream is = new ASN1InputStream(data);
    final ASN1Sequence dsq = (ASN1Sequence) is.readObject();
    is.close();
    final Enumeration<?> e = dsq.getObjects();
    // Elementos que contienen los elementos OID Data
    final DERObjectIdentifier doi = (DERObjectIdentifier) e.nextElement();
    if (doi.equals(PKCSObjectIdentifiers.signedAndEnvelopedData)) {
        // Contenido de Data
        final ASN1TaggedObject doj = (ASN1TaggedObject) e.nextElement();

        final SignedAndEnvelopedData signEnv = new SignedAndEnvelopedData((ASN1Sequence) doj.getObject());

        // Obtenemos los originatorInfo
        final ASN1EncodableVector signerInfos = new ASN1EncodableVector();
        final Enumeration<?> signers = signEnv.getSignerInfos().getObjects();
        while (signers.hasMoreElements()) {
            signerInfos.add((ASN1Sequence) signers.nextElement());
        }

        ASN1EncodableVector signCerts = new ASN1EncodableVector();

        // Si no hay certificados, se deja como esta.
        if (signerCertificateChain.length != 0) {

            // algoritmo
            final String signatureAlgorithm;
            final String digestAlgorithm;
            final ASN1EncodableVector digestAlgs = new ASN1EncodableVector();

            signatureAlgorithm = parameters.getSignatureAlgorithm();
            digestAlgorithm = AOSignConstants.getDigestAlgorithmName(signatureAlgorithm);

            AlgorithmIdentifier digAlgId = SigUtils.makeAlgId(AOAlgorithmID.getOID(digestAlgorithm));
            digestAlgs.add(digAlgId);

            final TBSCertificateStructure tbs2;
            try {
                tbs2 = TBSCertificateStructure.getInstance(
                        ASN1Primitive.fromByteArray(signerCertificateChain[0].getTBSCertificate()));
            } catch (final CertificateEncodingException ex) {
                throw new IOException("Error en la codificacion del certificado del firmante", ex); //$NON-NLS-1$
            }

            final IssuerAndSerialNumber encSid = new IssuerAndSerialNumber(
                    X500Name.getInstance(tbs2.getIssuer()), tbs2.getSerialNumber().getValue());

            final SignerIdentifier identifier = new SignerIdentifier(encSid);

            // AlgorithmIdentifier
            digAlgId = new AlgorithmIdentifier(new ASN1ObjectIdentifier(AOAlgorithmID.getOID(digestAlgorithm)),
                    new DERNull());

            // // ATRIBUTOS
            final ASN1EncodableVector contextExpecific;
            try {
                contextExpecific = CAdESUtils.generateSignerInfo(signerCertificateChain[0], digestAlgorithm,
                        parameters.getContent(), policy, null);
            } catch (final CertificateEncodingException ex) {
                throw new IOException("Error en la codificacion del certificado del firmante", ex); //$NON-NLS-1$
            } catch (final NoSuchAlgorithmException ex) {
                throw new IOException("Error generacion del SignerInfo", ex); //$NON-NLS-1$
            }

            this.signedAttr2 = SigUtils.getAttributeSet(new AttributeTable(contextExpecific));
            final ASN1Set signedAttr = SigUtils.getAttributeSet(new AttributeTable(contextExpecific));

            final ASN1Set unSignedAttr = null;

            // digEncryptionAlgorithm
            final SignerInfo nuevoSigner = CAdESUtils.signAndEnvelope(keyEntry, signatureAlgorithm, digAlgId,
                    identifier, signedAttr, unSignedAttr, "RSA", //$NON-NLS-1$
                    this.signedAttr2);

            // introducimos el nuevo Signer
            signerInfos.add(nuevoSigner);

            // LISTA DE CERTIFICADOS: obtenemos la lista de certificados
            try {
                signCerts = CAdESUtils.loadCertificatesList(signEnv, signerCertificateChain);
            } catch (final CertificateEncodingException ex) {
                throw new IOException("Error en la codificacion de los certificados del firmante", ex); //$NON-NLS-1$
            }
        } else {
            LOGGER.warning("No se ha podido obtener el certificado del nuevo firmante "); //$NON-NLS-1$
        }

        final ASN1Set certrevlist = null;

        // Se crea un nuevo AuthenticatedEnvelopedData a partir de los
        // datos anteriores con los nuevos originantes.
        retorno = new ContentInfo(PKCSObjectIdentifiers.signedAndEnvelopedData,
                new SignedAndEnvelopedData(signEnv.getRecipientInfos(), signEnv.getDigestAlgorithms(),
                        signEnv.getEncryptedContentInfo(), // encInfo,
                        new DERSet(signCerts), // certificates,
                        certrevlist, // certrevlist,
                        new DERSet(signerInfos))).getEncoded(ASN1Encoding.DER);
    }

    return retorno;
}

From source file:es.gob.afirma.envelopers.cades.CAdESUtils.java

License:Open Source License

/** Obtiene un <code>Info</code> que contiene los RecipientInfos y el EncryptedContentInfo.
 * @param data Datos a incluir en el sobre
 * @param config Configuraci&oacute;n de cifrado a aplicar
 * @param certDest Certificados de los destinatarios
 * @param cipherKey Clave de cifrado// ww w . j  a va2  s .  c  o  m
 * @return <code>Info</code> que contiene los RecipientInfos y el EncryptedContentInfo
 * @throws IOException en caso de error de entrada / salida
 * @throws CertificateEncodingException en caso de errores de codificaci&oacute;n en los certificados
 */
static Info getEnvelopeInfo(final byte[] data, final AOCipherConfig config, final X509Certificate[] certDest,
        final SecretKey cipherKey) throws IOException, CertificateEncodingException {

    // Reiniciamos las dos variables
    final Info infos = new Info();

    final ASN1EncodableVector recipientInfos = new ASN1EncodableVector();
    X509Certificate cert;
    TBSCertificateStructure tbs;
    IssuerAndSerialNumber isse;
    RecipientIdentifier rid;
    PublicKey pubKey;
    AlgorithmIdentifier keyEncAlg;
    SubjectPublicKeyInfo info;
    // Cifrado de la clave
    byte[] encryptedKey = null;
    // generamos el contenedor de cifrado

    RecipientInfo recipient = null;

    for (final X509Certificate element : certDest) {
        cert = element;
        tbs = TBSCertificateStructure.getInstance(ASN1Primitive.fromByteArray(cert.getTBSCertificate()));
        // Obtenemos el Isuer & serial number
        isse = new IssuerAndSerialNumber(X500Name.getInstance(tbs.getIssuer()),
                tbs.getSerialNumber().getValue());
        // Creamos el recipientInfo
        rid = new RecipientIdentifier(isse);
        // Obtenemos la clave publica
        pubKey = cert.getPublicKey();
        // obtenemos la informacion de la clave publica
        info = tbs.getSubjectPublicKeyInfo();
        // obtenemos el algoritmo de cifrado.
        keyEncAlg = info.getAlgorithm();

        try {
            // ciframos la clave
            encryptedKey = cipherKey(pubKey, cipherKey);
        } catch (final Exception e) {
            LOGGER.severe("Error durante el proceso cifrado de la clave: " + e); //$NON-NLS-1$
        }
        // creamos el recipiente con los datos del destinatario.
        final KeyTransRecipientInfo keyTransRecipientInfo = new KeyTransRecipientInfo(rid, keyEncAlg,
                new DEROctetString(encryptedKey));

        recipient = new RecipientInfo(keyTransRecipientInfo);
        // Lo a&ntilde;adimos al recipiente de destinatarios.
        recipientInfos.add(recipient);
    }

    // 3. ENCRIPTEDCONTENTINFO
    try {
        infos.setEncInfo(getEncryptedContentInfo(data, config, cipherKey));
    } catch (final Exception e) {
        LOGGER.severe("Error durante el proceso cifrado de la clave: " + e); //$NON-NLS-1$
    }

    infos.setRecipientInfos(recipientInfos);

    return infos;
}

From source file:es.gob.afirma.envelopers.cades.CAdESUtils.java

License:Open Source License

/** M&eacute;todo que genera la parte que contiene la informaci&oacute;n del
 * Usuario. Se generan los atributos que se necesitan para generar la firma.
 * @param cert Certificado del firmante/*from  w  w w.j a v  a  2  s . co m*/
 * @param datos Datos firmados
 * @param policy Pol&iacute;tica de firma
 * @param messageDigest
 * @return Los datos necesarios para generar la firma referente a los datos
 *         del usuario.
 * @throws java.security.NoSuchAlgorithmException
 * @throws java.io.IOException
 * @throws CertificateEncodingException */
static ASN1EncodableVector generateSignerInfo(final X509Certificate cert, final String digestAlgorithmName,
        final byte[] datos, final AdESPolicy policy, final byte[] messageDigest)
        throws NoSuchAlgorithmException, IOException, CertificateEncodingException {

    // ALGORITMO DE HUELLA DIGITAL
    final AlgorithmIdentifier digestAlgorithmOID = SigUtils
            .makeAlgId(AOAlgorithmID.getOID(digestAlgorithmName));

    // // ATRIBUTOS

    // authenticatedAttributes
    final ASN1EncodableVector contexExpecific = initContexExpecific(digestAlgorithmName, datos,
            PKCSObjectIdentifiers.data.getId(), messageDigest);

    // Serial Number
    // comentar lo de abajo para version del rfc 3852
    contexExpecific.add(new Attribute(RFC4519Style.serialNumber,
            new DERSet(new DERPrintableString(cert.getSerialNumber().toString()))));

    if (!"SHA1".equals(AOSignConstants.getDigestAlgorithmName(digestAlgorithmName))) { //$NON-NLS-1$

        //********************************************/
        //***** La Nueva operatividad esta comentada */
        //********************************************/
        // INICIO SINGING CERTIFICATE-V2

        /** IssuerSerial ::= SEQUENCE { issuer GeneralNames, serialNumber
         * CertificateSerialNumber */

        final TBSCertificateStructure tbs = TBSCertificateStructure
                .getInstance(ASN1Primitive.fromByteArray(cert.getTBSCertificate()));

        /** ESSCertIDv2 ::= SEQUENCE { hashAlgorithm AlgorithmIdentifier
         * DEFAULT {algorithm id-sha256}, certHash Hash, issuerSerial
         * IssuerSerial OPTIONAL }
         * Hash ::= OCTET STRING */

        final byte[] certHash = MessageDigest.getInstance(digestAlgorithmName).digest(cert.getEncoded());
        final ESSCertIDv2[] essCertIDv2 = { new ESSCertIDv2(digestAlgorithmOID, certHash,
                new IssuerSerial(new GeneralNames(new GeneralName(tbs.getIssuer())), tbs.getSerialNumber())) };

        /** PolicyInformation ::= SEQUENCE { policyIdentifier CertPolicyId,
         * policyQualifiers SEQUENCE SIZE (1..MAX) OF PolicyQualifierInfo
         * OPTIONAL }
         * CertPolicyId ::= OBJECT IDENTIFIER
         * PolicyQualifierInfo ::= SEQUENCE { policyQualifierId
         * PolicyQualifierId, qualifier ANY DEFINED BY policyQualifierId } */

        final SigningCertificateV2 scv2;
        if (policy.getPolicyIdentifier() != null) {

            /** SigningCertificateV2 ::= SEQUENCE { certs SEQUENCE OF
             * ESSCertIDv2, policies SEQUENCE OF PolicyInformation OPTIONAL
             * } */
            scv2 = new SigningCertificateV2(essCertIDv2, getPolicyInformation(policy)); // con
            // politica
        } else {
            scv2 = new SigningCertificateV2(essCertIDv2); // Sin politica
        }

        // Secuencia con singningCertificate
        contexExpecific.add(new Attribute(PKCSObjectIdentifiers.id_aa_signingCertificateV2, new DERSet(scv2)));

        // FIN SINGING CERTIFICATE-V2

    } else {

        // INICIO SINGNING CERTIFICATE

        /** IssuerSerial ::= SEQUENCE { issuer GeneralNames, serialNumber
         * CertificateSerialNumber } */

        final TBSCertificateStructure tbs = TBSCertificateStructure
                .getInstance(ASN1Primitive.fromByteArray(cert.getTBSCertificate()));

        final IssuerSerial isuerSerial = new IssuerSerial(new GeneralNames(new GeneralName(tbs.getIssuer())),
                tbs.getSerialNumber());

        /** ESSCertID ::= SEQUENCE { certHash Hash, issuerSerial IssuerSerial
         * OPTIONAL }
         * Hash ::= OCTET STRING -- SHA1 hash of entire certificate */
        final ESSCertID essCertID = new ESSCertID(
                MessageDigest.getInstance(digestAlgorithmName).digest(cert.getEncoded()), isuerSerial);

        /** PolicyInformation ::= SEQUENCE { policyIdentifier CertPolicyId,
         * policyQualifiers SEQUENCE SIZE (1..MAX) OF PolicyQualifierInfo
         * OPTIONAL }
         * CertPolicyId ::= OBJECT IDENTIFIER
         * PolicyQualifierInfo ::= SEQUENCE { policyQualifierId
         * PolicyQualifierId, qualifier ANY DEFINED BY policyQualifierId } */

        final SigningCertificate scv;
        if (policy.getPolicyIdentifier() != null) {

            /** SigningCertificateV2 ::= SEQUENCE { certs SEQUENCE OF
             * ESSCertIDv2, policies SEQUENCE OF PolicyInformation OPTIONAL
             * } */
            /*
             * HAY QUE HACER UN SEQUENCE, YA QUE EL CONSTRUCTOR DE BOUNCY
             * CASTLE NO TIENE DICHO CONSTRUCTOR.
             */
            final ASN1EncodableVector v = new ASN1EncodableVector();
            v.add(new DERSequence(essCertID));
            v.add(new DERSequence(getPolicyInformation(policy)));
            scv = SigningCertificate.getInstance(new DERSequence(v)); // con politica
        } else {
            scv = new SigningCertificate(essCertID); // Sin politica
        }

        /** id-aa-signingCertificate OBJECT IDENTIFIER ::= { iso(1)
         * member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs9(9) smime(16)
         * id-aa(2) 12 } */
        // Secuencia con singningCertificate
        contexExpecific.add(new Attribute(PKCSObjectIdentifiers.id_aa_signingCertificate, new DERSet(scv)));
    }

    // INICIO SIGPOLICYID ATTRIBUTE

    if (policy.getPolicyIdentifier() != null) {
        /*
         * SigPolicyId ::= OBJECT IDENTIFIER Politica de firma.
         */
        final ASN1ObjectIdentifier doiSigPolicyId = new ASN1ObjectIdentifier(
                policy.getPolicyIdentifier().toLowerCase().replace("urn:oid:", "")); //$NON-NLS-1$ //$NON-NLS-2$

        /*
         *   OtherHashAlgAndValue ::= SEQUENCE {
         *     hashAlgorithm    AlgorithmIdentifier,
         *     hashValue        OCTET STRING }
         *
         */

        // Algoritmo para el hash
        final AlgorithmIdentifier hashid;
        // si tenemos algoritmo de calculo de hash, lo ponemos
        if (policy.getPolicyIdentifierHashAlgorithm() != null) {
            hashid = SigUtils.makeAlgId(AOAlgorithmID
                    .getOID(AOSignConstants.getDigestAlgorithmName(policy.getPolicyIdentifierHashAlgorithm())));
        }
        // si no tenemos, ponemos el algoritmo de firma.
        else {
            hashid = digestAlgorithmOID;
        }
        // hash del documento, descifrado en b64
        final byte[] hashed;
        if (policy.getPolicyIdentifierHash() != null) {
            hashed = Base64.decode(policy.getPolicyIdentifierHash());
        } else {
            hashed = new byte[] { 0 };
        }

        final DigestInfo otherHashAlgAndValue = new DigestInfo(hashid, hashed);

        /*
         *   SigPolicyQualifierInfo ::= SEQUENCE {
         *       SigPolicyQualifierId  SigPolicyQualifierId,
         *       SigQualifier          ANY DEFINED BY policyQualifierId }
         */
        SigPolicyQualifierInfo spqInfo = null;
        if (policy.getPolicyQualifier() != null) {
            spqInfo = new SigPolicyQualifierInfo(policy.getPolicyQualifier().toString());
        }

        /*
         * SignaturePolicyId ::= SEQUENCE {
         *  sigPolicyId           SigPolicyId,
         *  sigPolicyHash         SigPolicyHash,
         *  sigPolicyQualifiers   SEQUENCE SIZE (1..MAX) OF
         *                          SigPolicyQualifierInfo OPTIONAL}
         *
         */
        final ASN1EncodableVector v = new ASN1EncodableVector();
        // sigPolicyId
        v.add(doiSigPolicyId);
        // sigPolicyHash
        v.add(otherHashAlgAndValue.toASN1Primitive()); // como sequence
        // sigPolicyQualifiers
        if (spqInfo != null) {
            v.add(spqInfo.toASN1Primitive());
        }

        final DERSequence ds = new DERSequence(v);

        // Secuencia con singningCertificate
        contexExpecific.add(
                new Attribute(PKCSObjectIdentifiers.id_aa_ets_sigPolicyId, new DERSet(ds.toASN1Primitive())));
        // FIN SIGPOLICYID ATTRIBUTE
    }

    return contexExpecific;
}

From source file:es.gob.afirma.envelopers.cms.CMSSignedAndEnvelopedData.java

License:Open Source License

/** M&eacute;todo que genera la firma de tipo SignedAndEnvelopedData.
 * @param parameters Par&aacute;metros necesarios para la generaci&oacute;n de este
 *                   tipo.//from   w ww.  java 2 s  .  c o m
 * @param signerCertificateChain Cadena de certificados del firmante.
 * @param config Configuraci&oacute;n del algoritmo para firmar
 * @param certDest Certificado del destino al cual va dirigido la firma.
 * @param dataType Identifica el tipo del contenido a firmar.
 * @param keyEntry Entrada hacia la clave privada para firma.
 * @param atrib Conjunto de atributos firmados.
 * @param uatrib Conjunto de atributos no firmados.
 * @param keySize Tama&ntilde;o de la clave AES.
 * @return La firma de tipo SignedAndEnvelopedData.
 * @throws java.io.IOException Si ocurre alg&uacute;n problema leyendo o escribiendo los
 *                             datos
 * @throws java.security.cert.CertificateEncodingException
 *         Si se produce alguna excepci&oacute;n con los certificados de
 *         firma.
 * @throws java.security.NoSuchAlgorithmException
 *         Si no se soporta alguno de los algoritmos de firma o huella
 *         digital
 * @throws BadPaddingException Cuando hay problemas con un relleno de datos.
 * @throws IllegalBlockSizeException Cuando hay problemas internos con los tama&ntilde;os de bloque de cifrado.
 * @throws InvalidAlgorithmParameterException Si no se soporta un par&aacute;metro necesario para un algoritmo.
 * @throws NoSuchPaddingException Cuando no se soporta un tipo de relleno necesario.
 * @throws InvalidKeyException Cuando hay problemas de adecuaci&oacute;n de la clave.
 * @throws SignatureException  Cuando ocurren problemas en la firma PKCS#1 */
byte[] genSignedAndEnvelopedData(final P7ContentSignerParameters parameters,
        final X509Certificate[] signerCertificateChain, final AOCipherConfig config,
        final X509Certificate[] certDest, final String dataType, final PrivateKeyEntry keyEntry,
        final Map<String, byte[]> atrib, final Map<String, byte[]> uatrib, final Integer keySize)
        throws IOException, CertificateEncodingException, NoSuchAlgorithmException, InvalidKeyException,
        NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException,
        BadPaddingException, SignatureException {

    final SecretKey cipherKey = Utils.initEnvelopedData(config, keySize);

    // 1. VERSION
    // la version se mete en el constructor del signedAndEnvelopedData y es
    // 1

    // 2. DIGESTALGORITM
    // buscamos que timo de algoritmo es y lo codificamos con su OID

    final String signatureAlgorithm = parameters.getSignatureAlgorithm();
    final String digestAlgorithm = AOSignConstants.getDigestAlgorithmName(signatureAlgorithm);
    final AlgorithmIdentifier digAlgId = SigUtils.makeAlgId(AOAlgorithmID.getOID(digestAlgorithm));

    final ASN1EncodableVector digestAlgs = new ASN1EncodableVector();
    digestAlgs.add(digAlgId);

    // LISTA DE CERTIFICADOS: obtenemos la lista de certificados
    final ASN1Set certificates = Utils.fetchCertificatesList(signerCertificateChain);

    // Ya que el contenido puede ser grande, lo recuperamos solo una vez
    final byte[] content2 = parameters.getContent();

    // 2. RECIPIENTINFOS
    final Info infos = Utils.initVariables(content2, config, certDest, cipherKey);

    // 4. SIGNERINFO
    // raiz de la secuencia de SignerInfo
    final ASN1EncodableVector signerInfos = new ASN1EncodableVector();

    final TBSCertificateStructure tbs2 = TBSCertificateStructure
            .getInstance(ASN1Primitive.fromByteArray(signerCertificateChain[0].getTBSCertificate()));

    final IssuerAndSerialNumber encSid = new IssuerAndSerialNumber(X500Name.getInstance(tbs2.getIssuer()),
            tbs2.getSerialNumber().getValue());

    final SignerIdentifier identifier = new SignerIdentifier(encSid);

    // // ATRIBUTOS
    final ASN1Set signedAttr = generateSignerInfo(signerCertificateChain[0], digestAlgorithm, content2,
            dataType, atrib);

    ASN1Set unSignedAttr = null;
    unSignedAttr = generateUnsignerInfo(uatrib);

    // digEncryptionAlgorithm
    final AlgorithmIdentifier encAlgId = SigUtils.makeAlgId(AOAlgorithmID.getOID("RSA")); //$NON-NLS-1$

    final ASN1OctetString sign2 = Utils.firma(signatureAlgorithm, keyEntry, this.signedAttr2);

    signerInfos.add(new SignerInfo(identifier, digAlgId, signedAttr, encAlgId, sign2, unSignedAttr));

    final ASN1Set certrevlist = null;

    // construimos el Signed And Enveloped Data y lo devolvemos
    return new ContentInfo(PKCSObjectIdentifiers.signedAndEnvelopedData,
            new SignedAndEnvelopedData(new DERSet(infos.getRecipientInfos()), new DERSet(digestAlgs),
                    infos.getEncInfo(), certificates, certrevlist, new DERSet(signerInfos)))
                            .getEncoded(ASN1Encoding.DER);
}

From source file:es.gob.afirma.envelopers.cms.CoSignerEnveloped.java

License:Open Source License

/** Constructor de la clase. Se crea una cofirma a partir de los datos del
 * firmante, el archivo que se firma y del archivo que contiene las firmas.
 * @param parameters par&aacute;metros necesarios que contienen tanto la firma del
 *                   archivo a firmar como los datos del firmante.
 * @param signerCertificateChain Cadena de certificados del firmante.
 * @param sign Archivo que contiene las firmas.
 * @param dataType Identifica el tipo del contenido a firmar.
 * @param keyEntry Clave privada del firmante.
 * @param atrib Atributos firmados opcion   ales.
 * @param uatrib Atributos no autenticados firmados opcionales.
 * @param messageDigest Huella digital a aplicar en la firma.
 * @return El archivo de firmas con la nueva firma.
 * @throws java.io.IOException Si ocurre alg&uacute;n problema leyendo o escribiendo los
 *                             datos//from   ww w.  j  ava  2  s  . c  om
 * @throws java.security.NoSuchAlgorithmException Si no se soporta alguno de los algoritmos de firma o huella
 *                                                digital
 * @throws java.security.cert.CertificateException Si se produce alguna excepci&oacute;n con los certificados de
 *                                                 firma. */
byte[] coSigner(final P7ContentSignerParameters parameters, final X509Certificate[] signerCertificateChain,
        final byte[] sign, final String dataType, final PrivateKeyEntry keyEntry,
        final Map<String, byte[]> atrib, final Map<String, byte[]> uatrib, final byte[] messageDigest)
        throws IOException, NoSuchAlgorithmException, CertificateException {

    final ASN1InputStream is = new ASN1InputStream(sign);

    // LEEMOS EL FICHERO QUE NOS INTRODUCEN
    final ASN1Sequence dsq = (ASN1Sequence) is.readObject();
    is.close();
    final Enumeration<?> e = dsq.getObjects();
    // Elementos que contienen los elementos OID signedAndEnvelopedData
    e.nextElement();
    // Contenido de signedAndEnvelopedData
    final ASN1TaggedObject doj = (ASN1TaggedObject) e.nextElement();
    final ASN1Sequence contentSignedData = (ASN1Sequence) doj.getObject();// contenido
    // del
    // signedAndEnvelopedData

    final SignedAndEnvelopedData sd = new SignedAndEnvelopedData(contentSignedData);

    // 4. CERTIFICADOS
    // obtenemos la lista de certificados
    ASN1Set certificates = null;

    final ASN1Set certificatesSigned = sd.getCertificates();
    final ASN1EncodableVector vCertsSig = new ASN1EncodableVector();
    final Enumeration<?> certs = certificatesSigned.getObjects();

    // COGEMOS LOS CERTIFICADOS EXISTENTES EN EL FICHERO
    while (certs.hasMoreElements()) {
        vCertsSig.add((ASN1Encodable) certs.nextElement());
    }

    if (signerCertificateChain.length != 0) {
        final List<ASN1Encodable> ce = new ArrayList<ASN1Encodable>();
        for (final X509Certificate element : signerCertificateChain) {
            ce.add(Certificate.getInstance(ASN1Primitive.fromByteArray(element.getEncoded())));
        }
        certificates = SigUtils.fillRestCerts(ce, vCertsSig);
    }

    // buscamos que timo de algoritmo es y lo codificamos con su OID
    final String signatureAlgorithm = parameters.getSignatureAlgorithm();
    final String digestAlgorithm = AOSignConstants.getDigestAlgorithmName(signatureAlgorithm);
    final AlgorithmIdentifier digAlgId = SigUtils.makeAlgId(AOAlgorithmID.getOID(digestAlgorithm));

    // Identificador del firmante ISSUER AND SERIAL-NUMBER
    final TBSCertificateStructure tbs = TBSCertificateStructure
            .getInstance(ASN1Primitive.fromByteArray(signerCertificateChain[0].getTBSCertificate()));
    final IssuerAndSerialNumber encSid = new IssuerAndSerialNumber(X500Name.getInstance(tbs.getIssuer()),
            tbs.getSerialNumber().getValue());
    final SignerIdentifier identifier = new SignerIdentifier(encSid);

    // // ATRIBUTOS

    // atributos firmados
    ASN1Set signedAttr = null;
    if (messageDigest == null) {
        signedAttr = generateSignerInfo(digestAlgorithm, parameters.getContent(), dataType, atrib);
    } else {
        signedAttr = generateSignerInfoFromHash(signerCertificateChain[0], messageDigest, dataType, atrib);
    }

    // atributos no firmados.
    final ASN1Set unSignedAttr = generateUnsignerInfo(uatrib);

    // // FIN ATRIBUTOS

    // digEncryptionAlgorithm
    final AlgorithmIdentifier encAlgId = SigUtils.makeAlgId(AOAlgorithmID.getOID("RSA")); //$NON-NLS-1$

    // 5. SIGNERINFO
    // raiz de la secuencia de SignerInfo
    // Obtenemos los signerInfos del signedAndEnvelopedData
    final ASN1Set signerInfosSd = sd.getSignerInfos();

    // introducimos los SignerInfos Existentes
    final ASN1EncodableVector signerInfos = new ASN1EncodableVector();
    // introducimos el nuevo SignerInfo del firmante actual.

    for (int i = 0; i < signerInfosSd.size(); i++) {
        final SignerInfo si = SignerInfo.getInstance(signerInfosSd.getObjectAt(i));
        signerInfos.add(si);
    }

    final ASN1OctetString sign2;
    try {
        sign2 = firma(signatureAlgorithm, keyEntry);
    } catch (final Exception ex) {
        throw new IOException("Error al generar la firma: " + ex, ex); //$NON-NLS-1$
    }

    // Creamos los signerInfos del signedAndEnvelopedData
    signerInfos.add(new SignerInfo(identifier, digAlgId, signedAttr, encAlgId, sign2, unSignedAttr));

    // construimos el Signed Data y lo devolvemos
    return new ContentInfo(PKCSObjectIdentifiers.signedAndEnvelopedData,
            new SignedAndEnvelopedData(sd.getRecipientInfos(), sd.getDigestAlgorithms(),
                    sd.getEncryptedContentInfo(), certificates, null, new DERSet(signerInfos)// unsignedAttr
            )).getEncoded(ASN1Encoding.DER);

}