public static String Firmar(Documento doc, String p12, String password)
        {
            XadesService        xadesService = new XadesService( );
            SignatureParameters parametros   = new SignatureParameters( );

            // Política de firma de factura-e 3.1
            parametros.SignaturePolicyInfo = new SignaturePolicyInfo( );
            parametros.SignaturePolicyInfo.PolicyIdentifier = "https://tribunet.hacienda.go.cr/docs/esquemas/2016/v4/Resolucion%20Comprobantes%20Electronicos%20%20DGT-R-48-2016.pdf";
            parametros.SignaturePolicyInfo.PolicyHash       = "V8lVVNGDCPen6VELRD1Ja8HARFk=";
            parametros.SignaturePackaging  = SignaturePackaging.ENVELOPED;
            parametros.DataFormat          = new DataFormat( );
            parametros.DataFormat.MimeType = "text/xml";
            parametros.SignerRole          = new SignerRole( );
            parametros.SignerRole.ClaimedRoles.Add("emisor");
            parametros.Signer = new Signer(new X509Certificate2(p12, password));


            Stream stream = new MemoryStream( );

            doc.OptenerXML_Nofirmado( ).Save(stream);
            // Rewind the stream ready to read from it elsewhere
            stream.Position = 0;

            var docFirmado = xadesService.Sign(stream, parametros);

            byte[] AsBytes = docFirmado.GetDocumentBytes( );
            return(Convert.ToBase64String(AsBytes).Replace("\n", ""));
        }
예제 #2
0
        public void RunInternallyDetachedSignature()
        {
            FirmaXadesNet.XadesService xadesService = new XadesService();
            SignatureParameters        parametros   = new SignatureParameters();

            string ficheroXml = Path.Combine(rootDirectory, @"xsdBOE-A-2011-13169_ex_XAdES_Internally_detached.xml");

            XmlDocument documento = new XmlDocument();

            documento.Load(ficheroXml);

            parametros.SignatureDestination = new SignatureXPathExpression();
            parametros.SignatureDestination.Namespaces.Add("enidoc", "http://administracionelectronica.gob.es/ENI/XSD/v1.0/documento-e");
            parametros.SignatureDestination.Namespaces.Add("enidocmeta", "http://administracionelectronica.gob.es/ENI/XSD/v1.0/documento-e/metadatos");
            parametros.SignatureDestination.Namespaces.Add("enids", "http://administracionelectronica.gob.es/ENI/XSD/v1.0/firma");
            parametros.SignatureDestination.Namespaces.Add("enifile", "http://administracionelectronica.gob.es/ENI/XSD/v1.0/documento-e/contenido");
            parametros.SignatureDestination.XPathExpression = "enidoc:documento/enids:firmas/enids:firma/enids:ContenidoFirma/enids:FirmaConCertificado";
            parametros.SignaturePackaging = SignaturePackaging.INTERNALLY_DETACHED;
            parametros.ElementIdToSign    = "CONTENT-12ef114d-ac6c-4da3-8caf-50379ed13698";
            parametros.InputMimeType      = "text/xml";

            FirmaXadesNet.Signature.SignatureDocument documentoFirma;

            using (parametros.Signer = new Signer(_signCertificate))
            {
                using (FileStream fs = new FileStream(ficheroXml, FileMode.Open))
                {
                    documentoFirma = xadesService.Sign(fs, parametros);
                }
            }

            ValidateDocument(documentoFirma.Document.OuterXml);
        }
예제 #3
0
        private void btnCargarFirma_Click(object sender, EventArgs e)
        {
            if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                using (FileStream fs = new FileStream(openFileDialog1.FileName, FileMode.Open))
                {
                    XadesService xadesService = new XadesService();

                    var firmas = xadesService.Load(fs);

                    FrmSeleccionarFirma frm = new FrmSeleccionarFirma(firmas);

                    if (frm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                    {
                        _signatureDocument = frm.FirmaSeleccionada;

                        ValidationResult result = xadesService.Validate(_signatureDocument);

                        if (!result.IsValid)
                        {
                            MessageBox.Show(result.Message, "FIRMA NO VÁLIDA");
                        }
                    }
                    else
                    {
                        MessageBox.Show("Debe seleccionar una firma.");
                    }
                }
            }
        }
예제 #4
0
        private void btnFirmarHuella_Click(object sender, EventArgs e)
        {
            if (!rbInternnallyDetached.Checked)
            {
                MessageBox.Show("Please select the type of signature internally detached.");
                return;
            }

            if (string.IsNullOrEmpty(txtFichero.Text))
            {
                MessageBox.Show("You must select a file to sign.");
                return;
            }

            XadesService xadesService = new XadesService();

            SignatureParameters parametros = ObtenerParametrosFirma();

            parametros.SignaturePackaging = SignaturePackaging.INTERNALLY_DETACHED;
            parametros.InputMimeType      = "hash/sha256";

            using (FileStream fs = new FileStream(txtFichero.Text, FileMode.Open))
            {
                using (parametros.Signer = new Signer(SelectCertificate()))
                {
                    _signatureDocument = xadesService.Sign(fs, parametros);
                }
            }

            MessageBox.Show("Signature completed, you can now Save the signature or expand it to Xades-T or Xades-XL.", "Test firma XADES",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
예제 #5
0
        private static SignatureDocument Firmar(XDocument docXML, String p12, String password)
        {
            XadesService        xadesService = new XadesService( );
            SignatureParameters parametros   = new SignatureParameters( );

            // Política de firma de factura-e 3.1
            parametros.SignaturePolicyInfo = new SignaturePolicyInfo( );
            parametros.SignaturePolicyInfo.PolicyIdentifier = "https://www.hacienda.go.cr/ATV/ComprobanteElectronico/docs/esquemas/2016/v4/Resolucion%20Comprobantes%20Electronicos%20%20DGT-R-48-2016.pdf";
            parametros.SignaturePolicyInfo.PolicyHash       = "V8lVVNGDCPen6VELRD1Ja8HARFk=";
            parametros.SignaturePackaging  = SignaturePackaging.ENVELOPED;
            parametros.DataFormat          = new DataFormat( );
            parametros.DataFormat.MimeType = "text/xml";
            parametros.SignerRole          = new SignerRole( );
            parametros.SignerRole.ClaimedRoles.Add("emisor");
            parametros.Signer = new Signer(new X509Certificate2(p12, password));


            Stream stream = new MemoryStream( );

            docXML.Save(stream);
            // Rewind the stream ready to read from it elsewhere
            stream.Position = 0;

            return(xadesService.Sign(stream, parametros));
        }
예제 #6
0
        private void btnFirmarHuella_Click(object sender, EventArgs e)
        {
            if (!rbInternnallyDetached.Checked)
            {
                MessageBox.Show("Por favor, seleccione el tipo de firma internally detached.");
                return;
            }

            if (string.IsNullOrEmpty(txtFichero.Text))
            {
                MessageBox.Show("Debe seleccionar un fichero para firmar.");
                return;
            }

            XadesService xadesService = new XadesService();

            SignatureParameters parametros = ObtenerParametrosFirma();

            parametros.SignaturePackaging     = SignaturePackaging.HASH_INTERNALLY_DETACHED;
            parametros.DataFormat             = new DataFormat();
            parametros.DataFormat.MimeType    = "hash/sha256";
            parametros.DataFormat.Description = "Hash value encoded in binary format";

            using (FileStream fs = new FileStream(txtFichero.Text, FileMode.Open))
            {
                using (parametros.Signer = new Signer(CertUtil.SelectCertificate()))
                {
                    _signatureDocument = xadesService.Sign(fs, parametros);
                }
            }

            MessageBox.Show("Firma completada, ahora puede Guardar la firma o ampliarla a Xades-T.", "Test firma XADES",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
예제 #7
0
        private void btnGenerar_Click(object sender, EventArgs e)
        {
            XadesService        xadesService = new XadesService();
            SignatureParameters parametros   = new SignatureParameters();

            string ficheroFactura = Application.StartupPath + "\\Facturae.xml";

            // Política de firma de factura-e 3.1
            parametros.SignaturePolicyInfo = new SignaturePolicyInfo();
            parametros.SignaturePolicyInfo.PolicyIdentifier = "http://www.facturae.es/politica_de_firma_formato_facturae/politica_de_firma_formato_facturae_v3_1.pdf";
            parametros.SignaturePolicyInfo.PolicyHash       = "Ohixl6upD6av8N7pEvDABhEL6hM=";
            parametros.SignaturePackaging = SignaturePackaging.ENVELOPED;
            parametros.InputMimeType      = "text/xml";
            parametros.SignerRole         = new SignerRole();
            parametros.SignerRole.ClaimedRoles.Add("emisor");

            using (parametros.Signer = new Signer(FirmaXadesNet.Utils.CertUtil.SelectCertificate()))
            {
                using (FileStream fs = new FileStream(ficheroFactura, FileMode.Open))
                {
                    var docFirmado = xadesService.Sign(fs, parametros);

                    if (saveFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                    {
                        docFirmado.Save(saveFileDialog1.FileName);
                        MessageBox.Show("Fichero guardado correctamente.");
                    }
                }
            }
        }
예제 #8
0
        public Respuesta Firmar(string xml, string nombreCertificado, string claveCertificado)
        {
            try
            {
                var xadesService = new XadesService();
                SignatureDocument signatureDocument;
                var parametros = ObtenerParametrosFirma();
                using (parametros.Signer = new Signer(ObtenerCertificado(nombreCertificado, claveCertificado)))
                {
                    signatureDocument = xadesService.Sign(ConvertirXmlAStream(xml), parametros);
                }

                return(new Respuesta
                {
                    FueOk = true,
                    Mensaje = "Firmado OK.",
                    Dato = signatureDocument.Document.OuterXml
                });
            }
            catch (Exception ex)
            {
                return(new Respuesta {
                    Mensaje = string.Format("Mensaje : {0}, Excepción Interna: {1}, Seguimiento de Pila : {2}", ex.Message, ex.InnerException, ex.StackTrace)
                });
            }
        }
예제 #9
0
        public void RunInvoiceSignature()
        {
            XadesService        xadesService = new XadesService();
            SignatureParameters parametros   = new SignatureParameters();

            string ficheroFactura = Path.Combine(rootDirectory, @"Facturae.xml");

            // Política de firma de factura-e 3.1
            parametros.SignaturePolicyInfo = new SignaturePolicyInfo
            {
                PolicyIdentifier = "http://www.facturae.es/politica_de_firma_formato_facturae/politica_de_firma_formato_facturae_v3_1.pdf",
                PolicyHash       = "Ohixl6upD6av8N7pEvDABhEL6hM="
            };
            parametros.SignaturePackaging = SignaturePackaging.ENVELOPED;
            parametros.InputMimeType      = "text/xml";
            parametros.SignerRole         = new SignerRole();
            parametros.SignerRole.ClaimedRoles.Add("emisor");

            using (parametros.Signer = new Signer(_signCertificate))
            {
                using (FileStream fs = new FileStream(ficheroFactura, FileMode.Open))
                {
                    var docFirmado = xadesService.Sign(fs, parametros);
                    ValidateDocument(docFirmado.Document.OuterXml);
                }
            }
        }
예제 #10
0
 public void FirmaXML_Xades(string pathXML, string thumbprintCertificado)
 {
     try
     {
         X509Certificate2 cert = GetCertificateByThumbprint(thumbprintCertificado);
         // 'Ejemplo de un valor Thumbprint: C2E8D9DA714C98ED14B88ECBC4C3E5F3BD64F125
         // 'Si no se quiere leer el certificado del repositorio, se puede cargar el certificado directamente
         // 'Dim cert As X509Certificate2 = New X509Certificate2("rutaArchivoCertificado", "clave")
         XadesService        xadesService = new XadesService();
         SignatureParameters parametros   = new SignatureParameters();
         parametros.SignaturePolicyInfo = new SignaturePolicyInfo();
         parametros.SignaturePolicyInfo.PolicyIdentifier = "https://tribunet.hacienda.go.cr/docs/esquemas/2016/v4.1/Resolucion_Comprobantes_Electronicos_DGT-R-48" +
                                                           "-2016.pdf";
         parametros.SignaturePolicyInfo.PolicyHash = "Ohixl6upD6av8N7pEvDABhEL6hM=";
         parametros.SignaturePackaging             = SignaturePackaging.ENVELOPED;
         parametros.DataFormat = new DataFormat();
         parametros.Signer     = new FirmaXadesNet.Crypto.Signer(cert);
         FileStream fs = new FileStream((pathXML + "_01_SF.xml"), FileMode.Open);
         FirmaXadesNet.Signature.SignatureDocument docFirmado = xadesService.Sign(fs, parametros);
         docFirmado.Save((pathXML + "_02_Firmado.xml"));
         // El documento se firma con el dll FirmaXadesNet
         // Esta libreria fue creada por Departamento de Nuevas Tecnolog�as - Direcci�n General de Urbanismo Ayuntamiento de Cartagena
         // 'Fuente original se puede descargar en administracionelectronica.gob.es/ctt/firmaxadesnet
         // 'La libreria se modific� levemente para que pueda funcionar para Costa Rica.
         // 'Cambios por Roy Rojas - [email protected] - 06/Febrero/2018
         fs.Close();
         docFirmado = null;
     }
     catch (Exception ex)
     {
         throw;
     }
 }
예제 #11
0
 public GetFacturaeSignedActivity(IKeyVaultService keyvaultService,
                                  XadesService xadesService,
                                  IConfiguration configuration)
 {
     this.keyvaultService = keyvaultService;
     this.xadesService    = xadesService;
     this.configuration   = configuration;
 }
예제 #12
0
        private void btnFirmar_Click(object sender, EventArgs e)
        {
            XadesService        xadesService = new XadesService();
            SignatureParameters parametros   = new SignatureParameters();

            byte[] hashValue = Convert.FromBase64String("sbsJSZJb4Qb2oea6uENdJCAgc+Q=");

            List <Reference> referencias = new List <Reference>()
            {
                new Reference("xsdBOE-A-2011-13169_ex_XAdES_Internally_detached.xml")
                {
                    DigestMethod = DigestMethod.SHA1.URI,
                    Id           = "Ref-1",
                    DigestValue  = hashValue
                }
            };

            XmlElement  manifestXmlElement = ManifestUtil.CreateManifest("Manifest-1", referencias);
            XmlDocument xmlDoc             = new XmlDocument();

            xmlDoc.AppendChild(xmlDoc.ImportNode(manifestXmlElement, true));

            parametros.SignaturePackaging  = SignaturePackaging.ENVELOPING;
            parametros.DataFormat          = new DataFormat();
            parametros.DataFormat.MimeType = "text/xml";
            parametros.SignaturePolicyInfo = new SignaturePolicyInfo
            {
                PolicyIdentifier      = "rn:oid:2.16.724.1.3.1.1.2.1.8",
                PolicyDigestAlgorithm = DigestMethod.SHA1,
                PolicyHash            = "VYICYpNOjso9g1mBiXDVxNORpKk=",
                PolicyUri             = "http://administracionelectronica.gob.es/es/ctt/politicafirma/politica_firma_AGE_v1_8.pdf"
            };

            SignatureDocument documentoFirma;

            using (parametros.Signer = new Signer(FirmaXadesNet.Utils.CertUtil.SelectCertificate()))
            {
                using (MemoryStream ms = new MemoryStream())
                {
                    xmlDoc.Save(ms);
                    ms.Seek(0, SeekOrigin.Begin);
                    documentoFirma = xadesService.Sign(ms, parametros);
                }
            }

            if (saveFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                using (FileStream fs = new FileStream(saveFileDialog1.FileName, FileMode.Create))
                {
                    documentoFirma.Save(fs);
                }

                MessageBox.Show("Fichero guardado correctamente.");
            }
        }
예제 #13
0
        /// <summary>
        /// Function that make the signature of the document
        /// </summary>
        /// <param name="sp">Document to sign</param>
        /// <param name="path">Path were the document is storage</param>
        /// <returns>Return a signed document</returns>
        private static SignatureDocument XadesSigned(SignatureParameters sp, string path)
        {
            XadesService xadesService = new XadesService();

            using (FileStream fs = new FileStream(path, FileMode.Open))
            {
                var document = xadesService.Sign(fs, sp);
                MoveSignatureNode(document);
                return(document);
            }
        }
예제 #14
0
        public void XadesEpesFirma(string pathXML,
                                   string PathCertificado,
                                   string PINCertificado,
                                   string UrlFirma)
        {
            var xadesService = new XadesService();

            X509Certificate2 Certificat = new X509Certificate2(
                ConvertirCertificadoEnBytes(PathCertificado),
                PINCertificado);

            try
            {
                var parametros = new SignatureParameters
                {
                    SignaturePolicyInfo = new SignaturePolicyInfo
                    {
                        PolicyIdentifier = UrlFirma,
                        PolicyHash       = "Ohixl6upD6av8N7pEvDABhEL6hM="
                    },
                    SignaturePackaging = SignaturePackaging.ENVELOPED,
                    DataFormat         = new DataFormat(),
                };
                parametros.DataFormat.MimeType = "text/xml";

                StreamReader objReader    = File.OpenText(pathXML + "_01_SF.xml");
                XmlDocument  documentoXml = new XmlDocument();
                documentoXml.LoadXml(objReader.ReadToEnd().ToString());
                objReader.Close();

                using (parametros.Signer = new Signer(Certificat))
                {
                    using (MemoryStream fs = new MemoryStream())
                    {
                        documentoXml.PreserveWhitespace = true;
                        documentoXml.Save(fs);
                        fs.Flush();
                        fs.Position = 0;
                        var docFirmado = xadesService.Sign(fs, parametros);
                        documentoXml = docFirmado.Document;
                        docFirmado.Save((pathXML + "_02_Firmado.xml"));
                    }
                }

                iError = "Ok";
            }
            catch (Exception ex)
            {
                iError = "Error en metodo XadesEpesFirma." + Environment.NewLine + ex.Message;
            }

            //documentoXml.Save(@"C:\Users\Public\Documents\" + EngineDocumentoXml.NombreDocumentoXml(documentoXml));
            //return documentoXml;
        }
예제 #15
0
        //Firma del documento
        private static SignatureDocument FirmaXades(SignatureParameters sp, string ruta)
        {
            XadesService xadesService = new XadesService();

            using (FileStream fs = new FileStream(ruta, FileMode.Open))
            {
                var documento = xadesService.Sign(fs, sp);
                MoverNodoFirma(documento);
                return(documento);
            }
        }
예제 #16
0
        private void btnContraFirma_Click(object sender, EventArgs e)
        {
            SignatureParameters parametros   = ObtenerParametrosFirma();
            XadesService        xadesService = new XadesService();

            using (parametros.Signer = new Signer(CertUtil.SelectCertificate()))
            {
                _signatureDocument = xadesService.CounterSign(_signatureDocument, parametros);
            }

            MessageBox.Show("Firma completada correctamente.", "Test firma XADES",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
예제 #17
0
        private void btnCoFirmar_Click(object sender, EventArgs e)
        {
            SignatureParameters parametros   = ObtenerParametrosFirma();
            XadesService        xadesService = new XadesService();

            using (parametros.Signer = new Signer(SelectCertificate()))
            {
                _signatureDocument = xadesService.CoSign(_signatureDocument, parametros);
            }

            MessageBox.Show("Signature completed successfully.", "Test firma XADES",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
예제 #18
0
        private void btnFirmar_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(txtFichero.Text))
            {
                MessageBox.Show("Debe seleccionar un fichero para firmar.");
                return;
            }

            XadesService        xadesService = new XadesService();
            SignatureParameters parametros   = ObtenerParametrosFirma();

            if (rbInternnallyDetached.Checked)
            {
                parametros.SignaturePolicyInfo = ObtenerPolitica();
                parametros.SignaturePackaging  = SignaturePackaging.INTERNALLY_DETACHED;
                parametros.DataFormat          = new DataFormat();
                parametros.DataFormat.MimeType = MimeTypeInfo.GetMimeType(txtFichero.Text);
            }
            else if (rbExternallyDetached.Checked)
            {
                parametros.SignaturePackaging = SignaturePackaging.EXTERNALLY_DETACHED;
                parametros.ExternalContentUri = txtFichero.Text;
            }
            else if (rbEnveloped.Checked)
            {
                parametros.SignaturePackaging = SignaturePackaging.ENVELOPED;
            }
            else if (rbEnveloping.Checked)
            {
                parametros.SignaturePackaging = SignaturePackaging.ENVELOPING;
            }

            using (parametros.Signer = new Signer(CertUtil.SelectCertificate()))
            {
                if (parametros.SignaturePackaging != SignaturePackaging.EXTERNALLY_DETACHED)
                {
                    using (FileStream fs = new FileStream(txtFichero.Text, FileMode.Open))
                    {
                        _signatureDocument = xadesService.Sign(fs, parametros);
                    }
                }
                else
                {
                    _signatureDocument = xadesService.Sign(null, parametros);
                }
            }

            MessageBox.Show("Firma completada, ahora puede Guardar la firma o ampliarla a Xades-T.", "Test firma XADES",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
예제 #19
0
        private void btnFirmar_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(txtFichero.Text))
            {
                MessageBox.Show("You must select a file to sign.");
                return;
            }

            XadesService        xadesService = new XadesService();
            SignatureParameters parametros   = ObtenerParametrosFirma();

            if (rbInternnallyDetached.Checked)
            {
                parametros.SignaturePolicyInfo = ObtenerPolitica();
                parametros.SignaturePackaging  = SignaturePackaging.INTERNALLY_DETACHED;
                parametros.InputMimeType       = MimeTypeInfo.GetMimeType(txtFichero.Text);
            }
            else if (rbExternallyDetached.Checked)
            {
                parametros.SignaturePackaging = SignaturePackaging.EXTERNALLY_DETACHED;
                parametros.ExternalContentUri = txtFichero.Text;
            }
            else if (rbEnveloped.Checked)
            {
                parametros.SignaturePackaging = SignaturePackaging.ENVELOPED;
            }
            else if (rbEnveloping.Checked)
            {
                parametros.SignaturePackaging = SignaturePackaging.ENVELOPING;
            }

            using (parametros.Signer = new Signer(SelectCertificate()))
            {
                if (parametros.SignaturePackaging != SignaturePackaging.EXTERNALLY_DETACHED)
                {
                    using (FileStream fs = new FileStream(txtFichero.Text, FileMode.Open))
                    {
                        _signatureDocument = xadesService.Sign(fs, parametros);
                    }
                }
                else
                {
                    _signatureDocument = xadesService.Sign(null, parametros);
                }
            }

            MessageBox.Show("Signature completed, you can now Save the signature or extend it to Xades-T or Xades-XL.", "Test firma XADES",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
예제 #20
0
        public void FirmaXML_Xades(string pathXML,
                                   string Certificado,
                                   bool esThumbprint,
                                   string Clave,
                                   string FirmaUrl)
        {
            try
            {
                XadesService        xadesService = new XadesService();
                X509Certificate2    cert         = new X509Certificate2(Certificado, Clave);
                SignatureParameters parametros   = new SignatureParameters();

                parametros.SignaturePolicyInfo = new SignaturePolicyInfo();
                parametros.SignaturePolicyInfo.PolicyIdentifier = FirmaUrl;
                //La propiedad PolicyHash es la misma para todos, es un cálculo en base
                //al archivo pdf indicado en PolicyIdentifier
                parametros.SignaturePolicyInfo.PolicyHash = "Ohixl6upD6av8N7pEvDABhEL6hM=";
                parametros.SignaturePackaging             = SignaturePackaging.ENVELOPED;
                parametros.DataFormat          = new DataFormat();
                parametros.DataFormat.MimeType = "text/xml";

                // StreamReader objReader = File.OpenText($"{pathXML}_01_SF.xml");
                StreamReader objReader    = File.OpenText($"{pathXML}_XML_SinFirma.xml");
                XmlDocument  DocumentoXml = new XmlDocument();
                DocumentoXml.LoadXml(objReader.ReadToEnd().ToString());
                objReader.Close();

                parametros.Signer = new Signer(cert);
                MemoryStream ms = new MemoryStream();

                DocumentoXml.PreserveWhitespace = true;
                DocumentoXml.Save(ms);
                ms.Flush();
                ms.Position = 0;

                var DocFirmado = xadesService.Sign(ms, parametros);
                //DocFirmado.Save($"{pathXML}_02_Firmado.xml");
                DocFirmado.Save($"{pathXML}_XML_Firmado.xml");

                iError = "Ok";
            }
            catch (System.Exception ex)
            {
                iError = ex.Message;
            }
        }
예제 #21
0
        private void btnFirmar_Click(object sender, EventArgs e)
        {
            XadesService        xadesService = new XadesService();
            SignatureParameters parametros   = new SignatureParameters();

            string ficheroXml = Application.StartupPath + "\\xsdBOE-A-2011-13169_ex_XAdES_Internally_detached.xml";

            XmlDocument documento = new XmlDocument();

            documento.Load(ficheroXml);

            parametros.SignatureDestination = new SignatureXPathExpression();
            parametros.SignatureDestination.Namespaces.Add("enidoc", "http://administracionelectronica.gob.es/ENI/XSD/v1.0/documento-e");
            parametros.SignatureDestination.Namespaces.Add("enidocmeta", "http://administracionelectronica.gob.es/ENI/XSD/v1.0/documento-e/metadatos");
            parametros.SignatureDestination.Namespaces.Add("enids", "http://administracionelectronica.gob.es/ENI/XSD/v1.0/firma");
            parametros.SignatureDestination.Namespaces.Add("enifile", "http://administracionelectronica.gob.es/ENI/XSD/v1.0/documento-e/contenido");
            parametros.SignatureDestination.XPathExpression = "enidoc:documento/enids:firmas/enids:firma/enids:ContenidoFirma/enids:FirmaConCertificado";
            parametros.SignaturePackaging  = SignaturePackaging.INTERNALLY_DETACHED;
            parametros.ElementIdToSign     = "CONTENT-12ef114d-ac6c-4da3-8caf-50379ed13698";
            parametros.DataFormat          = new DataFormat();
            parametros.DataFormat.MimeType = "text/xml";

            SignatureDocument documentoFirma;

            using (parametros.Signer = new Signer(FirmaXadesNet.Utils.CertUtil.SelectCertificate()))
            {
                using (FileStream fs = new FileStream(ficheroXml, FileMode.Open))
                {
                    documentoFirma = xadesService.Sign(fs, parametros);
                }
            }

            if (saveFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                using (FileStream fs = new FileStream(saveFileDialog1.FileName, FileMode.Create))
                {
                    documentoFirma.Save(fs);
                }

                MessageBox.Show("Fichero guardado correctamente.");
            }
        }
        private XmlDocument XmlMerge(XmlDocument xmlDoc, X509Certificate2 certificate)
        {
            XadesService        xadesService = new XadesService();
            SignatureParameters parametros   = new SignatureParameters();


            parametros.SignaturePolicyInfo = new SignaturePolicyInfo();
            parametros.SignaturePolicyInfo.PolicyIdentifier = "https://tribunet.hacienda.go.cr/docs/esquemas/2016/v4.1/Resolucion_Comprobantes_Electronicos_DGT-R-48-2016.pdf";
            parametros.SignaturePolicyInfo.PolicyHash       = "Ohixl6upD6av8N7pEvDABhEL6hM=";
            parametros.SignaturePackaging = SignaturePackaging.ENVELOPED;
            parametros.InputMimeType      = "text/xml";
            parametros.SignerRole         = new SignerRole();
            parametros.SignerRole.ClaimedRoles.Add("emisor");

            using (parametros.Signer = new Signer(certificate))
            {
                var docFirmado = xadesService.Sign(xmlDoc, parametros);
                return(docFirmado.Document);
            }
        }
예제 #23
0
        public string FirmarDocumento(string rutaGuardado)
        {
            var certificado   = new X509Certificate2(_configuracion.LlaveCriptograficaRuta, _configuracion.LlaveCriptograficaClave, X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.Exportable);
            var servicioFirma = new XadesService();
            var parametros    = ObtenerParametros();

            using (parametros.Signer = new Signer(certificado))
            {
                using (var fileStream = new FileStream(rutaGuardado, FileMode.Open))
                {
                    var docFirmado = servicioFirma.Sign(fileStream, parametros);
                    fileStream.Close();
                    docFirmado.Save(rutaGuardado);
                }
            }
            using (var lector = new StreamReader(rutaGuardado))
            {
                var xmlFirmado = lector.ReadToEnd();
                return(xmlFirmado);
            }
        }
        protected byte[] FirmarDocumento(byte[] bytesXml, DateTime fecha, SignatureXPathExpression xpathExpression)
        {
            var xadesService = new XadesService();

            var parametros = new SignatureParameters();

            parametros.SignatureMethod = SignatureMethod.RSAwithSHA256;
            parametros.DigestMethod    = DigestMethod.SHA256;
            parametros.SigningDate     = fecha;

            parametros.SignerRole = new SignerRole();
            var signerRole = (RolFirmante == RolFirmante.EMISOR ? "supplier" : "third party");

            parametros.SignerRole.ClaimedRoles.Add(signerRole);

            parametros.SignatureDestination = xpathExpression;

            parametros.SignaturePolicyInfo = new SignaturePolicyInfo();
            parametros.SignaturePolicyInfo.PolicyIdentifier      = "https://facturaelectronica.dian.gov.co/politicadefirma/v2/politicadefirmav2.pdf";
            parametros.SignaturePolicyInfo.PolicyHash            = "dMoMvtcG5aIzgYo0tIsSQeVJBDnUnfSOfBpxXrmor0Y=";
            parametros.SignaturePolicyInfo.PolicyDigestAlgorithm = DigestMethod.SHA256;

            parametros.SignaturePackaging = SignaturePackaging.ENVELOPED;
            parametros.DataFormat         = new DataFormat {
                MimeType = "text/xml"
            };

            using (parametros.Signer = new Signer(new X509Certificate2(RutaCertificado, ClaveCertificado)))
            {
                using (var stream = new MemoryStream(bytesXml))
                {
                    var signatureDocument = xadesService.Sign(stream, parametros);

                    var output = new MemoryStream();
                    signatureDocument.Save(output);

                    return(output.ToArray());
                }
            }
        }
예제 #25
0
        public static string XadesSign(string xml, X509Certificate2 x509Certificate)
        {
            XadesService xadesService = new XadesService();

            SignatureParameters parametros = new SignatureParameters
            {
                SignaturePolicyInfo = new SignaturePolicyInfo(),
                SignaturePackaging  = SignaturePackaging.ENVELOPED,
                InputMimeType       = "text/xml"
            };


            using (parametros.Signer = new Signer(x509Certificate))
            {
                using (MemoryStream fs = new MemoryStream(Encoding.UTF8.GetBytes(xml)))
                {
                    var docFirmado = xadesService.Sign(fs, parametros);

                    return(docFirmado.Document.ToXml());
                }
            }
        }
예제 #26
0
        private void btnFirmaMavisa_Click(object sender, EventArgs e)
        {
            // Demostración de firma masiva

            if (folderBrowserDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                DirectoryInfo   dirInfo = new DirectoryInfo(folderBrowserDialog1.SelectedPath);
                List <FileInfo> files   = new List <FileInfo>(dirInfo.EnumerateFiles("*.pdf"));

                if (files.Count == 0)
                {
                    MessageBox.Show("No se han encontrado documentos");
                    return;
                }

                using (Signer signer = new Signer(SelectCertificate()))
                {
                    SignatureParameters sp = new SignatureParameters
                    {
                        Signer              = signer,
                        SignaturePackaging  = SignaturePackaging.INTERNALLY_DETACHED,
                        InputMimeType       = "application/pdf",
                        SignatureMethod     = ObtenerAlgoritmo(),
                        SignaturePolicyInfo = ObtenerPolitica()
                    };

                    XadesService xadesService = new XadesService();

                    foreach (var file in files)
                    {
                        SignatureDocument sigDocument = xadesService.Sign(file.OpenRead(), sp);

                        sigDocument.Save(string.Format(@"{0}\{1}.{2}", folderBrowserDialog1.SelectedPath, Path.GetFileNameWithoutExtension(file.Name), "xsig"));
                    }
                }

                MessageBox.Show("Process completed.");
            }
        }
예제 #27
0
        public XmlDocument  XadesEpesFirma(XmlDocument documentoXml, string pathCertificado, string pinCertificado)
        {
            var xadesService = new XadesService();
            X509Certificate2 MontCertificat = new X509Certificate2(ConvertirCertificadoEnBytes(pathCertificado), pinCertificado);

            try
            {
                var parametros = new SignatureParameters
                {
                    SignaturePolicyInfo = new SignaturePolicyInfo
                    {
                        PolicyIdentifier = Valor.IdentificadorPolitica(),
                        PolicyHash       = Valor.HashPolitica()
                    },
                    SignaturePackaging = SignaturePackaging.ENVELOPED,
                    InputMimeType      = EngineData.text_xml,
                };

                using (parametros.Signer = new Signer(MontCertificat))
                {
                    using (MemoryStream fs = new MemoryStream())
                    {
                        documentoXml.PreserveWhitespace = true;
                        documentoXml.Save(fs);
                        fs.Flush();
                        fs.Position = 0;
                        var docFirmado = xadesService.Sign(fs, parametros);
                        documentoXml = docFirmado.Document;
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception("Error en metodo XadesEpesFirma", ex);
            }
            documentoXml.Save(@"C:\Users\Public\Documents\" + EngineDocumentoXml.NombreDocumentoXml(documentoXml));
            return(documentoXml);
        }
예제 #28
0
        public XmlDocument FirmaXML_Xades(string pathXML, string thumbprintCertificado)
        {
            try
            {
                X509Certificate2 cert = GetCertificateByThumbprint(thumbprintCertificado);
                // 'Ejemplo de un valor Thumbprint: C2E8D9DA714C98ED14B88ECBC4C3E5F3BD64F125
                // 'Si no se quiere leer el certificado del repositorio, se puede cargar el certificado directamente
                //string ruta = "C://Users/Walter Alonso/Documents/HACIENDA WALTER ALPIZAR/060348081125.p12";
                //X509Certificate2 cert = new X509Certificate2(ruta, "1904");

                XadesService        xadesService = new XadesService();
                SignatureParameters parametros   = new SignatureParameters();

                parametros.SignaturePolicyInfo = new SignaturePolicyInfo();
                parametros.SignaturePolicyInfo.PolicyIdentifier = "https://tribunet.hacienda.go.cr/docs/esquemas/2016/v4.1/Resolucion_Comprobantes_Electronicos_DGT-R-48-2016.pdf";
                //La propiedad PolicyHash es la misma para todos, es un cálculo en base al archivo pdf indicado en PolicyIdentifier
                parametros.SignaturePolicyInfo.PolicyHash = "Ohixl6upD6av8N7pEvDABhEL6hM=";
                parametros.SignaturePackaging             = SignaturePackaging.ENVELOPED;
                parametros.DataFormat = new DataFormat();
                parametros.Signer     = new FirmaXadesNet.Crypto.Signer(cert);
                string     xml = pathXML + "_01_SF.xml";
                FileStream fs  = new FileStream((xml), FileMode.Open);
                FirmaXadesNet.Signature.SignatureDocument docFirmado = xadesService.Sign(fs, parametros);
                docFirmado.Save((pathXML + "_02_Firmado.xml"));



                fs.Dispose();
                fs = null;
                return(docFirmado.Document);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
예제 #29
0
        private byte[] _firmar(byte[] _bytesXml, TipoDocumento _tipo, DateTime _fecha)
        {
            var parameters = new SignatureParameters();

            parameters.SignatureMethod = SignatureMethod.RSAwithSHA1;
            parameters.DigestMethod    = DigestMethod.SHA1;
            parameters.SigningDate     = _fecha;
            parameters.SignerRole      = new SignerRole();
            var signerRole = (RolFirmante == RolFirmante.FACTURANTE ? "supplier" : "third party");

            parameters.SignerRole.ClaimedRoles.Add(signerRole);

            parameters.SignatureDestination = new SignatureXPathExpression();
            parameters.SignatureDestination.Namespaces.Add("fe", "http://www.dian.gov.co/contratos/facturaelectronica/v1");
            parameters.SignatureDestination.Namespaces.Add("cac", "urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2");
            parameters.SignatureDestination.Namespaces.Add("cbc", "urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2");
            parameters.SignatureDestination.Namespaces.Add("clm54217", "urn:un:unece:uncefact:codelist:specification:54217:2001");
            parameters.SignatureDestination.Namespaces.Add("clm66411", "urn:un:unece:uncefact:codelist:specification:66411:2001");
            parameters.SignatureDestination.Namespaces.Add("clmIANAMIMEMediaType", "urn:un:unece:uncefact:codelist:specification:IANAMIMEMediaType:2003");
            parameters.SignatureDestination.Namespaces.Add("ext", "urn:oasis:names:specification:ubl:schema:xsd:CommonExtensionComponents-2");
            parameters.SignatureDestination.Namespaces.Add("qdt", "urn:oasis:names:specification:ubl:schema:xsd:QualifiedDatatypes-2");
            parameters.SignatureDestination.Namespaces.Add("sts", "http://www.dian.gov.co/contratos/facturaelectronica/v1/Structures");
            parameters.SignatureDestination.Namespaces.Add("udt", "urn:un:unece:uncefact:data:specification:UnqualifiedDataTypesSchemaModule:2");
            parameters.SignatureDestination.Namespaces.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance");

            if (_tipo == TipoDocumento.FACTURA)
            {
                parameters.SignatureDestination.XPathExpression = "/fe:Invoice/ext:UBLExtensions/ext:UBLExtension[2]/ext:ExtensionContent";
            }
            else if (_tipo == TipoDocumento.NOTA_DEBITO)
            {
                parameters.SignatureDestination.XPathExpression = "/fe:DebitNote/ext:UBLExtensions/ext:UBLExtension[2]/ext:ExtensionContent";
            }
            else if (_tipo == TipoDocumento.NOTA_CREDITO)
            {
                parameters.SignatureDestination.XPathExpression = "/fe:CreditNote/ext:UBLExtensions/ext:UBLExtension[2]/ext:ExtensionContent";
            }

            parameters.SignaturePolicyInfo = new SignaturePolicyInfo();
            parameters.SignaturePolicyInfo.PolicyIdentifier  = "https://facturaelectronica.dian.gov.co/politicadefirma/v2/politicadefirmav2.pdf";
            parameters.SignaturePolicyInfo.PolicyDescription = "Política\u00a0de\u00a0firma\u00a0para\u00a0facturas\u00a0electrónicas\u00a0de\u00a0la\u00a0República\u00a0de Colombia";
            parameters.SignaturePolicyInfo.PolicyHash        = "sbcECQ7v+y/m3OcBCJyvmkBhtFs=";
            parameters.SignaturePackaging = SignaturePackaging.ENVELOPED;
            parameters.InputMimeType      = "text/xml";

            var certificate = new X509Certificate2(RutaCertificado, ClaveCertificado);

            parameters.Signer = new Signer(certificate);
            parameters.CertificateIssuerName = EmisorCertificado;

            using (var input = new MemoryStream(_bytesXml))
            {
                var xades             = new XadesService();
                var signatureDocument = xades.Sign(input, parameters);

                var output = new MemoryStream();
                signatureDocument.Save(output);

                return(output.ToArray());
            }
        }
예제 #30
0
        public byte[] firmarArchivo(byte[] archivo, string claveCertificado, long codigoEmisor, byte[] certificado, string token, string rucEmisor)
        {
            if (certificado == null)
            {
                XtraMessageBox.Show("No se ha definido firma digital. Por favor contáctese con el administrador del sistema.");
                return(null);
            }


            RespuestaCertificado respuestaCertificado1 = new RespuestaCertificado();

            byte[]              archivofirmado = null;
            XadesService        xadesService   = new XadesService();
            SignatureParameters parametros     = new SignatureParameters();

            parametros.DigestMethod       = DigestMethod.SHA1;
            parametros.SignatureMethod    = SignatureMethod.RSAwithSHA1;
            parametros.SigningDate        = new DateTime?(DateTime.Now);
            parametros.SignaturePackaging = SignaturePackaging.ENVELOPED;
            X509Certificate2 MontCertificat = new X509Certificate2(certificado, claveCertificado);

            /*Validar ruc del emisor*/
            if (!rucEmisor.Equals(System.Text.Encoding.UTF8.GetString(MontCertificat.Extensions[11].RawData).ToString().Replace("", "").Replace("\r", "")))
            {
                XtraMessageBox.Show("La firma no concuerda con el ruc del emisor: " + rucEmisor);
                return(null);
            }
            /*Validar fecha de caducidad*/
            DateTime fechaDeHoy = new DateTime();
            DateTime fechaFirma = Convert.ToDateTime(MontCertificat.GetExpirationDateString());

            if (fechaDeHoy.CompareTo(fechaFirma) > 0)
            {
                XtraMessageBox.Show("Firma electrónica está caducada");
                return(null);
            }

            if ((fechaFirma - fechaDeHoy).TotalDays <= 30)
            {
                XtraMessageBox.Show("Quedan " + (fechaFirma - fechaDeHoy).TotalDays + " para que la firma electrónica caduque");
            }


            parametros.Signer = new FirmaXadesNet.Crypto.Signer(MontCertificat);
            Stream streamDocumento = new MemoryStream(archivo);
            var    docFirmado      = xadesService.Sign(streamDocumento, parametros);

            //docFirmado.Save(@"C:\Users\robay\AppData\Local\Temp\firmado3.xml");
            return(System.Text.Encoding.UTF8.GetBytes(docFirmado.Document.OuterXml));



            //byte[] str = null;
            //Provider provider = keyStore.getProvider();
            //X509Certificate certificate = (X509Certificate)keyStore.getCertificate(respuestaCertificado2.getAliasKey());
            //certificate.checkValidity(new GregorianCalendar().getTime());
            //string extensionIdentifier = UtilesElectronico.getExtensionIdentifier(certificate, X509Utils.obtenerOidAutoridad(certificate, respuestaCertificado2.getAutoridadCertificante()));
            //FirmasGenericasXAdES firmasGenericasXadEs = new FirmasGenericasXAdES();
            //if (rucEmisor.Equals(extensionIdentifier) && key != null)
            //{
            //    archivofirmado = firmasGenericasXadEs.ejecutarFirmaXades(archivo, Path.GetTempPath() + "firmados", str, provider, certificate, key);
            //    if (!new ValidacionBasica().validarArchivo(archivofirmado))
            //    {
            //        int num2 = (int)XtraMessageBox.Show("Se ha producido un error al momento de crear la firma del comprobante electrónico, ya que la firma digital no es válida");
            //    }
            //}
            //else if (extensionIdentifier == null)
            //{
            //    int num3 = (int)XtraMessageBox.Show("El certificado digital proporcionado no posee los datos de RUC OID: 1.3.6.1.4.1.37XXX.3.11,\nrazón por la cual usted no podrá firmar digitalmente documentos para remitir al SRI,\nfavor actualize su certificado digital con la Autoridad Certificadora");
            //}
            //else if (key == null)
            //{
            //    int num4 = (int)XtraMessageBox.Show("No se pudo acceder a la clave privada del certificado");
            //}
            //else
            //{
            //    int num5 = (int)XtraMessageBox.Show("El Ruc presente en el certificado digital, no coincide con el Ruc registrado en el aplicativo");
            //}
            return(archivofirmado);
        }