/// <summary> /// Genera la firma CADES /// </summary> /// <param name="data">Datos a firmar</param> /// <param name="privateKey">Clave privada usada para la firma</param> /// <param name="certificado">Certificado del firmante</param> /// <param name="algo">Algoritmo de firma</param> /// <param name="format">Formato de firma</param> /// <returns>Firma en formato binario</returns> public static byte[] getCades(byte[] data, RsaKeyParameters privateKey, byte[] certificado, string algo, string format) { GenCAdESEPESSignedData prueba = new GenCAdESEPESSignedData(); Dictionary<string, string> p1 = new Dictionary<string, string>(); p1.Add("format", format); p1.Add("mode", "implicit"); p1.Add("policyIdentifier", null); p1.Add("policyIdentifierHash", null); p1.Add("policyIdentifierHashAlgorithm", null); p1.Add("policyQualifier", null); p1.Add("signingCertificateV2", "false"); AdESPolicy politica = new AdESPolicy(p1); X509Certificate2 cert = new X509Certificate2(); cert.SetRawCertData(certificado); cert.SetKey(privateKey); X509Certificate2[] certs = new X509Certificate2[1]; certs[0] = cert; AOCAdESSigner cadesSigner = new AOCAdESSigner(); byte[] datos = cadesSigner.sign(data, algo, certs, p1); return datos; }
/** Firma datos en formato CAdES.<br/> * @param data Datos que deseamos firmar. * @param algorithm Algoritmo a usar para la firma. * <p>Se aceptan los siguientes algoritmos en el parámetro <code>algorithm</code>:</p> * <ul> * <li> <i>SHA1withRSA</i></li> * <li> <i>MD5withRSA</i> (no recomendado por vulnerable)</li> * <li> <i>MD2withRSA</i> (no recomendado por vulnerable)</li> * <li> <i>SHA256withRSA</i></li> * <li> <i>SHA384withRSA</i></li> * <li> <i>SHA512withRSA</i></li> * </ul> * @param keyEntry Entrada que apunta a la clave privada a usar para firmar * @param xParams Parámetros adicionales para la firma. * <p>Se aceptan los siguientes valores en el parámetro <code>xParams</code>:</p> * <dl> * <dt><b><i>includeOnlySignningCertificate</i></b></dt> * <dd> * Si se establece a {@code true} se incluye en la firma únicamente el certificado del firmante (y no la cadena de certificación completa). * Si no se establece o se establece a o {@code false} se incluirá toda la cadena de certificación. * </dd> * <dt><b><i>mode</i></b></dt> * <dd> * Modo de firma a usar. El valor <code>explicit</code> indica que no se incluyen los datos firmados, sino una * referencia a estos, mientras que el valor <code>implicit</code> indica que sí se incluirán dentro de * la propia firma los datos firmados * </dd> * <dt><b><i>policyIdentifier</i></b></dt> * <dd> * Identificador de la política de firma. Debe ser un OID (o una URN de tipo OID) que identifique * únivocamente la política en formato ASN.1 procesable. * </dd> * <dt><b><i>policyIdentifierHash</i></b></dt> * <dd> * Huella digital del documento de política de firma (normalmente del mismo fichero en formato ASN.1 procesable). * Si no se indica una huella digital y el parámetro <code>policyIdentifier</code> no es una URL accesible * universalmente se usará <code>0</code>, mientras que si no se indica una huella digital pero el parámetro * <code>policyIdentifier</code> es una URL accesible universalmente, se descargara el fichero apuntado por la URL para calcular la huella * digital <i>al vuelo</i>. * </dd> * <dt><b><i>policyIdentifierHashAlgorithm</i></b></dt> * <dd> * Algoritmo usado para el cálculo de la huella digital indicada en el parámetro <code>policyIdentifierHash</code>. * Es obligario indicarlo cuando se proporciona una huella digital distinta de <code>0</code>. * </dd> * <dt><b><i>policyQualifier</i></b></dt> * <dd> * URL que apunta al documento descriptivo de la política de firma (normalmente un documento PDF con una descripción textual). * </dd> * <dt><b><i>precalculatedHashAlgorithm</i></b></dt> * <dd> * Algoritmo de huella digital (a usar para la firma) cuando esta se proporciona precalculada. Cuando se usan modos de firma * <i>explícitos</i>, en los que los datos no se incluyen en la firma, es posible trabajar sin proporcionarlos, indicando * únicamente su huella digital en el parámetro <code>data</code> y el algoritmo usado para su cálculo.<br> * <b> * Siempre que se de valor a este parámetro se supondrá que los datos proporcionados en el parámetro * <code>data</code> son la huella digital de los datos a firmar, y no los datos a firmar en si. * </b> * </dd> * <dt><b><i>signingCertificateV2</i></b></dt> * <dd> * Debe establecerse a <code>true</code> si se desea usar la versión 2 del atributo * <i>Signing Certificate</i> de CAdES. Si no se establece un valor para este parámetro * se utilizaráa la versión 1 con las firmas realizadas con algoritmos SHA1 y * la versión 2 con las firmas realizadas con cualquier otro algoritmo. * </dd> * </dl> * @return Firma en formato CAdES * @throws AOException Cuando ocurre cualquier problema durante el proceso */ public byte[] sign(byte[] data, String algorithm, X509Certificate2[] keyEntry, Dictionary <string, string> xParams) { //Aunque está implementado, omitimos el checkeo de BC. Razon: mirar dentro de la clase BCChecker(). //new BCChecker().checkBouncyCastle(); Dictionary <string, string> extraParams = xParams != null ? xParams : new Dictionary <string, string>(); string precalculatedDigest = null; extraParams.TryGetValue("precalculatedHashAlgorithm", out precalculatedDigest); byte[] messageDigest = null; if (precalculatedDigest != null) { messageDigest = data; } bool signingCertificateV2 = false; if (AOSignConstants.isSHA2SignatureAlgorithm(algorithm)) { signingCertificateV2 = true; } else if (extraParams.ContainsKey("signingCertificateV2")) { string signing = null; extraParams.TryGetValue("signingCertificateV2", out signing); if (signing != null) { signingCertificateV2 = Boolean.Parse(signing); } } else { signingCertificateV2 = !"SHA1".Equals(AOSignConstants.GetDigestAlgorithmName(algorithm)); } string mode = AOSignConstants.DEFAULT_SIGN_MODE; extraParams.TryGetValue("mode", out mode); //string includeOnlySignningCertificate = null; //extraParams.TryGetValue("includeOnlySignningCertificate", out includeOnlySignningCertificate); //if(includeOnlySignningCertificate!= null){ // bool include = Boolean.Parse(includeOnlySignningCertificate); // if(include){ // } //} P7ContentSignerParameters csp = new P7ContentSignerParameters( data, algorithm, keyEntry ); try { bool omitContent = false; if (mode.Equals(AOSignConstants.SIGN_MODE_EXPLICIT) || precalculatedDigest != null) { omitContent = true; } String contentTypeOid = AOSignConstants.DEFAULT_CONTENT_OID_DATA; String contentDescription = AOSignConstants.DEFAULT_CONTENT_DESCRIPTION; // DE MOMENTO NO VAMOS A CALCULAR EL MIMETYPE. MANTENDREMOS SIEMPRE POR DEFECTO LOS MISMOS //if (data != null) { // try { // MimeHelper mimeHelper = new MimeHelper(data); // contentDescription = mimeHelper.getDescription(); // contentTypeOid = MimeHelper.transformMimeTypeToOid(mimeHelper.getMimeType()); // } catch (Exception e) { // Console.WriteLine("No se han podido cargar las librerias para identificar el tipo de dato firmado: " + e); // } //} bool padesMode = false; string sPadesMode = null; extraParams.TryGetValue("padesMode", out sPadesMode); if (sPadesMode != null) { padesMode = Boolean.Parse(sPadesMode); } return(GenCAdESEPESSignedData.generateSignedData( csp, omitContent, new AdESPolicy(extraParams), signingCertificateV2, keyEntry[0], //cogemos el elemento 0, que es el que contiene el certificado raiz messageDigest, padesMode, contentTypeOid, contentDescription )); } catch (Exception e) { throw new Exception("Error generando la firma CAdES: " + e, e); } }