private string Canonicalize(XmlDocument doc, IList <XmlNode> nsl = null) { var transform = new XmlDsigC14NTransform { Algorithm = CanonicalizationAlgorithm }; var sb = new StringBuilder(); if (nsl != null && nsl.Count > 0) { foreach (XmlNode attrNode in nsl) { if (!doc.DocumentElement.HasAttribute(attrNode.Name)) { doc.DocumentElement.SetAttribute(attrNode.Name, attrNode.Value); } } } transform.LoadInput(doc); using (var stream = (Stream)transform.GetOutput(typeof(Stream))) { using (var reader = new StreamReader(stream)) { sb.Append(reader.ReadToEnd()); } } return(sb.ToString()); }
/// <summary> /// Verifies the Signature and Licence Info in the Certificate /// </summary> /// <param name="path">Path to the certificate file</param> /// <returns>true if 'sign' matches the signature computed using the specified hash algorithm and key on 'Signature' and 'Digest' matches the computed hash for license; otherwise, false.</returns> static bool VerifyCertSignature(string path) { XmlDocument doc = new XmlDocument(); doc.Load(path); XmlDsigC14NTransform transform = new XmlDsigC14NTransform(); transform.LoadInput(new MemoryStream(Encoding.UTF8.GetBytes(doc.GetElementsByTagName("SignedInfo")[0].OuterXml))); byte[] siHash = transform.GetDigestedOutput(SHA1.Create()); byte[] Signature = Convert.FromBase64String(doc.GetElementsByTagName("SignatureValue")[0].InnerText); byte[] Modulus = Convert.FromBase64String(doc.GetElementsByTagName("Modulus")[0].InnerText); byte[] Exponent = Convert.FromBase64String(doc.GetElementsByTagName("Exponent")[0].InnerText); string Digest = doc.GetElementsByTagName("DigestValue")[0].InnerText; RSAParameters parameter = new RSAParameters(); parameter.Modulus = Modulus; parameter.Exponent = Exponent; RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); rsa.ImportParameters(parameter); RSAPKCS1SignatureDeformatter rsaDeformatter = new RSAPKCS1SignatureDeformatter(rsa); rsaDeformatter.SetHashAlgorithm("SHA1"); bool sign = rsaDeformatter.VerifySignature(siHash, Signature); XmlLicenseTransform License = new XmlLicenseTransform(); License.Context = (XmlElement)doc.GetElementsByTagName("Signature")[0]; License.LoadInput(doc); transform = new XmlDsigC14NTransform(); transform.LoadInput(License.GetOutput()); string dvHash = Convert.ToBase64String(transform.GetDigestedOutput(SHA1.Create())); return(sign && dvHash.Equals(Digest)); }
public static Transform fromURI(string uri) { Transform t = null; switch (uri) { case "http://www.w3.org/TR/2001/REC-xml-c14n-20010315": t = new XmlDsigC14NTransform(); break; case "http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments": t = new XmlDsigC14NWithCommentsTransform(); break; case "http://www.w3.org/2000/09/xmldsig#enveloped-signature": t = new XmlDsigEnvelopedSignatureTransform(); break; case "http://www.w3.org/TR/1999/REC-xpath-19991116": t = new XmlDsigXPathTransform(); break; case "http://www.w3.org/TR/1999/REC-xslt-19991116": t = new XmlDsigXsltTransform(); break; case "http://www.w3.org/2001/10/xml-exc-c14n#": t = new XmlDsigExcC14NTransform(); break; } return(t); }
public static Stream GetCanonicalStreamFromXML(XmlDocument xmlDoc) //C14N { XmlDsigC14NTransform transformData = new XmlDsigC14NTransform(); transformData.LoadInput(xmlDoc); return((Stream)transformData.GetOutput(typeof(Stream))); }
/// <summary> /// Devuelve el XML de entrada canonicalizado. /// </summary> /// <param name="xmlContent">XML a canonicalizar.</param> /// <param name="xpath">Expresión XPath que devuelve el nodeList a canonicalizar.</param> /// <param name="namespaces">Espacios de nombres.</param> /// <returns>XML de entrada canonicalizado.</returns> public string GetCanonicalString(string xmlContent, string xpath, Dictionary <string, string> namespaces = null) { XmlDocument xmlDoc = new XmlDocument { PreserveWhitespace = true }; xmlDoc.LoadXml(xmlContent); XmlNamespaceManager nm = new XmlNamespaceManager(xmlDoc.NameTable); var nms = namespaces ?? Namespaces.Items; foreach (KeyValuePair <string, string> n in nms) { nm.AddNamespace(n.Key, n.Value); } XmlNodeList xmlSignedProperties = xmlDoc.SelectNodes(xpath, nm); XmlDsigC14NTransform xmlTransform = new XmlDsigC14NTransform(); xmlTransform.LoadInput(xmlSignedProperties); MemoryStream ms = (MemoryStream)xmlTransform.GetOutput(typeof(MemoryStream)); return(Encoding.UTF8.GetString(ms.ToArray())); }
private byte[] DoC14N(XmlDocument doc) { XmlDsigC14NTransform c14n = new XmlDsigC14NTransform(false); c14n.LoadInput(doc); return(DoC14N(c14n)); }
public void XMLSemanticCorrectnessTest() { var hash = new List <byte[]>(); var inputs = new string[] { "<test><sample value=\"1\" putthisanywhere=\"abcdef\" /></test>", "<test><sample putthisanywhere=\"abcdef\" value=\"1\" /></test>", "<test><sample value=\"1\" broken=\"true\" /></test>" }; foreach (var input in inputs) { using (var stream = new MemoryStream()) { using (var writer = new StreamWriter(stream)) { writer.Write(input); writer.Flush(); stream.Position = 0; var xfrm = new XmlDsigC14NTransform(false); xfrm.LoadInput(stream); hash.Add(xfrm.GetDigestedOutput(new SHA1Managed())); } } } CollectionAssert.AreEqual(hash[0], hash[1]); CollectionAssert.AreNotEqual(hash[0], hash[2]); CollectionAssert.AreNotEqual(hash[1], hash[2]); }
public static XmlDocument AssinarEvento(string xml, string refUri, X509Certificate2 x509Cert) { XmlDocument doc = new XmlDocument(); doc.LoadXml(xml); SignedXml signedXml = new SignedXml(doc); Reference reference = new Reference(); signedXml.SigningKey = x509Cert.PrivateKey; reference.Uri = refUri; XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform(); XmlDsigC14NTransform c14 = new XmlDsigC14NTransform(); KeyInfo keyInfo = new KeyInfo(); reference.AddTransform(env); reference.AddTransform(c14); signedXml.AddReference(reference); keyInfo.AddClause(new KeyInfoX509Data(x509Cert)); signedXml.KeyInfo = keyInfo; signedXml.ComputeSignature(); XmlElement xmlDigitalSignature = signedXml.GetXml(); XmlNode firstChild = doc.ChildNodes.Item(1); //revisar código para caso de várias notas dentro do lote XmlNode evento = firstChild.ChildNodes.Item(1); evento.AppendChild(doc.ImportNode(xmlDigitalSignature, true)); return(doc); }
/// <summary> /// Carga el documento XML especificado y establece para firmar el elemento especificado en elementId /// </summary> /// <param name="xmlDocument"></param> /// <param name="elementId"></param> /// <param name="mimeType"></param> private void SetContentInternallyDetached(SignatureDocument sigDocument, XmlDocument xmlDocument, string elementId, string mimeType) { sigDocument.Document = xmlDocument; _refContent = new Reference(); _refContent.Uri = "#" + elementId; _refContent.Id = "Reference-" + Guid.NewGuid().ToString(); _mimeType = mimeType; if (mimeType == "text/xml") { XmlDsigC14NTransform transform = new XmlDsigC14NTransform(); _refContent.AddTransform(transform); _encoding = "UTF-8"; } else { XmlDsigBase64Transform transform = new XmlDsigBase64Transform(); _refContent.AddTransform(transform); _encoding = transform.Algorithm; } sigDocument.XadesSignature = new XadesSignedXml(sigDocument.Document); sigDocument.XadesSignature.AddReference(_refContent); }
public static void SignEnveloped(XmlDocument xmlDoc, RSACryptoServiceProvider key, string signatureNamespacePrefix) { SignedXml signedXml = new SignedXml(xmlDoc); signedXml.SigningKey = key; Reference reference = new Reference(""); reference.AddTransform(new XmlDsigEnvelopedSignatureTransform()); signedXml.AddReference(reference); signedXml.ComputeSignature(); XmlElement xmlSignature = signedXml.GetXml(); if (!string.IsNullOrEmpty(signatureNamespacePrefix)) { //Here we set the namespace prefix on the signature element and all child elements to "ds", invalidating the signature. AssignNameSpacePrefixToElementTree(xmlSignature, "ds"); //So let's recompute the SignatureValue based on our new SignatureInfo... //For XPath XmlNamespaceManager namespaceManager = new XmlNamespaceManager(xmlDoc.NameTable); namespaceManager.AddNamespace("ds", "http://www.w3.org/2000/09/xmldsig#"); //this prefix is arbitrary and used only for XPath XmlElement xmlSignedInfo = xmlSignature.SelectSingleNode("ds:SignedInfo", namespaceManager) as XmlElement; //Canonicalize the SignedInfo element XmlDsigC14NTransform transform = new XmlDsigC14NTransform(); XmlDocument signedInfoDoc = new XmlDocument(); signedInfoDoc.LoadXml(xmlSignedInfo.OuterXml); transform.LoadInput(signedInfoDoc); //Compute the new SignatureValue string signatureValue = Convert.ToBase64String(key.SignData(transform.GetOutput() as MemoryStream, new SHA1CryptoServiceProvider())); //Set it in the xml XmlElement xmlSignatureValue = xmlSignature.SelectSingleNode("ds:SignatureValue", namespaceManager) as XmlElement; xmlSignatureValue.InnerText = signatureValue; } xmlDoc.DocumentElement.AppendChild(xmlDoc.ImportNode(xmlSignature, true)); }
public void Constructor_Bool(bool includeComments, string expectedAlgorithm) { XmlDsigC14NTransform transform = new XmlDsigC14NTransform(includeComments); Assert.Equal(expectedAlgorithm, transform.Algorithm); CheckProperties(transform); }
private byte[] CanonicalizeAndDigest(IEnumerable nodes) { var transform = new XmlDsigC14NTransform { Algorithm = CanonicalizationAlgorithm }; var sb = new StringBuilder(); foreach (XmlNode node in nodes) { var tmpDoc = new XmlDocument(); tmpDoc.AppendChild(tmpDoc.ImportNode(node, true)); transform.LoadInput(tmpDoc); using (var stream = (Stream)transform.GetOutput(typeof(Stream))) { using (var reader = new StreamReader(stream)) { sb.Append(reader.ReadToEnd()); } } } using (var hash = SHA256.Create()) { return(hash.ComputeHash(Encoding.UTF8.GetBytes(sb.ToString()))); } }
public void LoadInputWithUnsupportedType() { XmlDsigC14NTransform transform = new XmlDsigC14NTransform(); byte[] bad = { 0xBA, 0xD }; AssertExtensions.Throws <ArgumentException>("obj", () => transform.LoadInput(bad)); }
public void UnsupportedOutput() { XmlDsigC14NTransform transform = new XmlDsigC14NTransform(); XmlDocument doc = new XmlDocument(); AssertExtensions.Throws <ArgumentException>("type", () => transform.GetOutput(doc.GetType())); }
// Resolve the specified base and relative Uri's . private static Uri ResolveUris(Uri baseUri, string relativeUri) { //<Snippet7> XmlUrlResolver xmlResolver = new XmlUrlResolver(); xmlResolver.Credentials = System.Net.CredentialCache.DefaultCredentials; XmlDsigC14NTransform xmlTransform = new XmlDsigC14NTransform(); xmlTransform.Resolver = xmlResolver; //</Snippet7> Uri absoluteUri = xmlResolver.ResolveUri(baseUri, relativeUri); if (absoluteUri != null) { Console.WriteLine( "\nResolved the base Uri and relative Uri to the following:"); Console.WriteLine(absoluteUri.ToString()); } else { Console.WriteLine( "Unable to resolve the base Uri and relative Uri"); } return(absoluteUri); }
private static byte[] CalculateC14nByteRange(XmlDocument doc) { XmlDsigC14NTransform c14nTransform = new XmlDsigC14NTransform(); c14nTransform.LoadInput(doc); return(((System.IO.MemoryStream)c14nTransform.GetOutput()).ToArray()); }
public static void Ass() { string path = @"C:\Users\Tina\Documents\Visual Studio 2015\Projects\Document\XMLFile2.xml"; XmlDocument xDoc = new XmlDocument(); xDoc.PreserveWhitespace = true; using (FileStream fs = new FileStream(path, FileMode.Open)) { xDoc.Load(fs); } // XmlElement elem = (XmlElement)xDoc.DocumentElement.FirstChild; //XmlNamespaceManager ns = new XmlNamespaceManager(xDoc.NameTable); //ns.AddNamespace("env", xDoc.DocumentElement.NamespaceURI); //XmlNode Body = xDoc.SelectSingleNode("//env:Child1", ns); //ns.AddNamespace("tax", Body.FirstChild.NamespaceURI); // Create an XML document of just the body section //XmlDocument xmlBody = new XmlDocument(); //xmlBody.PreserveWhitespace = true; //xmlBody.LoadXml(Body.OuterXml); // Remove any existing IRMark //XmlNode nodeIr = xmlBody.SelectSingleNode("//tax:Child2", ns); //if (nodeIr != null) //{ // nodeIr.ParentNode.RemoveChild(nodeIr); //} //Normalise the document using C14N(Canonicalisation) XmlDsigC14NTransform c14n = new XmlDsigC14NTransform(); c14n.LoadInput(xDoc); Stream S = (Stream)c14n.GetOutput(); }
/// <summary> /// Inserta un contenido XML para generar una firma enveloping. /// </summary> /// <param name="xmlDocument"></param> private void SetContentEveloping(SignatureDocument sigDocument, XmlDocument xmlDocument) { _refContent = new Reference(); sigDocument.XadesSignature = new XadesSignedXml(); XmlDocument doc = (XmlDocument)xmlDocument.Clone(); doc.PreserveWhitespace = true; if (doc.ChildNodes[0].NodeType == XmlNodeType.XmlDeclaration) { doc.RemoveChild(doc.ChildNodes[0]); } //Add an object string dataObjectId = "DataObject-" + Guid.NewGuid().ToString(); System.Security.Cryptography.Xml.DataObject dataObject = new System.Security.Cryptography.Xml.DataObject(); dataObject.Data = doc.ChildNodes; dataObject.Id = dataObjectId; sigDocument.XadesSignature.AddObject(dataObject); _refContent.Id = "Reference-" + Guid.NewGuid().ToString(); _refContent.Uri = "#" + dataObjectId; _refContent.Type = XadesSignedXml.XmlDsigObjectType; XmlDsigC14NTransform transform = new XmlDsigC14NTransform(); _refContent.AddTransform(transform); sigDocument.XadesSignature.AddReference(_refContent); }
internal static XmlDocument AssinarConsultaRecibo(string xml, string refUri, X509Certificate2 x509Cert) { XmlDocument doc = new XmlDocument(); doc.LoadXml(xml); SignedXml signedXml = new SignedXml(doc); Reference reference = new Reference(); signedXml.SigningKey = x509Cert.PrivateKey; reference.Uri = refUri; XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform(); XmlDsigC14NTransform c14 = new XmlDsigC14NTransform(); KeyInfo keyInfo = new KeyInfo(); reference.AddTransform(env); reference.AddTransform(c14); signedXml.AddReference(reference); keyInfo.AddClause(new KeyInfoX509Data(x509Cert)); signedXml.KeyInfo = keyInfo; signedXml.ComputeSignature(); XmlElement xmlDigitalSignature = signedXml.GetXml(); XmlNode firstChild = doc.ChildNodes.Item(1); firstChild.AppendChild(doc.ImportNode(xmlDigitalSignature, true)); return(doc); }
public static void Acc() { string path = @"C:\Users\Tina\Documents\Visual Studio 2015\Projects\Document\XMLFile2.xml"; XmlDocument xDoc = new XmlDocument(); xDoc.PreserveWhitespace = true; using (FileStream fs = new FileStream(path, FileMode.Open)) { xDoc.Load(fs); } // canon node list // XmlNodeList nodeList = xDoc.SelectNodes("//Child1"); XmlNodeList nodeList = xDoc.SelectNodes("//Child1/descendant-or-self::node()|//Child1//@*"); XmlDsigC14NTransform transform = new XmlDsigC14NTransform(); transform.LoadInput(nodeList); MemoryStream ms = (MemoryStream)transform.GetOutput(typeof(Stream)); string cc = xDoc.InnerXml; File.WriteAllBytes(@"C:\Users\Tina\Documents\Visual Studio 2015\Projects\Document\child1.xml", ms.ToArray()); // canon XMLDocument transform = new XmlDsigC14NTransform(); transform.LoadInput(xDoc); ms = (MemoryStream)transform.GetOutput(typeof(Stream)); // File.WriteAllBytes(@"C:\Users\Tina\Documents\Visual Studio 2015\Projects\Document\doc.xml", ms.ToArray()); StreamReader reader = new StreamReader(ms); string text = reader.ReadToEnd(); // Document to Stream ms = new MemoryStream(); XmlWriter xw = XmlWriter.Create(ms); xDoc.WriteTo(xw); xw.Flush(); ms.Position = 0; transform = new XmlDsigC14NTransform(); transform.LoadInput(ms); ms = (MemoryStream)transform.GetOutput(typeof(Stream)); File.WriteAllBytes(@"C:\Users\Tina\Documents\Visual Studio 2015\Projects\Document\ms.xml", ms.ToArray()); // node to stream //ms = new MemoryStream(); //xw = XmlWriter.Create(ms); //nodeList[0].WriteTo(xw); //xw.Flush(); //ms.Position = 0; //transform = new XmlDsigC14NTransform(); //transform.LoadInput(ms); //ms = (MemoryStream)transform.GetOutput(typeof(Stream)); //File.WriteAllBytes(@"D:\Test\xml imza\ms2.xml", ms.ToArray()); }
public static void Main(String[] args) { //calculate caninicalized xml var t = new XmlDsigEnvelopedSignatureTransform(false); XmlDocument doc = new XmlDocument(); //doc.PreserveWhitespace = true; doc.Load(@"c:\temp\x.xml"); t.LoadInput(doc); FieldInfo field = t.GetType().GetField("_signaturePosition", BindingFlags.NonPublic | BindingFlags.Instance); field.SetValue(t, 1); var res = (XmlDocument)t.GetOutput(); var s = res.OuterXml; var c14 = new XmlDsigC14NTransform(); c14.LoadInput(res); var mem = (MemoryStream)c14.GetOutput(); var sha = new SHA256Managed(); var byte1 = c14.GetDigestedOutput(new SHA256Managed()); var digest1 = Convert.ToBase64String(byte1); var byte2 = sha.ComputeHash(mem.ToArray()); var digest2 = Convert.ToBase64String(byte2); var s1 = System.Text.Encoding.UTF8.GetString(mem.ToArray()); var byte3 = sha.ComputeHash(System.Text.Encoding.UTF8.GetBytes(s1)); var digest3 = Convert.ToBase64String(byte3); //return; //validate signature CryptoConfig.AddAlgorithm(typeof(RSAPKCS1SHA256SignatureDescription), "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"); XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(@"c:\temp\x.xml"); XmlNode node = xmlDoc.DocumentElement; X509Certificate2 cert = new X509Certificate2(File.ReadAllBytes(@"c:\temp\x.cer")); bool isValid = ValidateXml(xmlDoc, cert); //return; //calc hash var sha1 = new SHA256Managed(); var b1 = sha1.ComputeHash(System.Text.Encoding.UTF8.GetBytes(File.ReadAllText(@"c:\temp\x_no_sig.xml"))); var b64 = Convert.ToBase64String(b1); }
/// <summary> /// /// </summary> /// <param name="source_xml"></param> /// <returns></returns> public MemoryStream Dsig14NTransformToStream(Stream source_xml) { MemoryStream _result = new MemoryStream(); XmlDsigC14NTransform _14nTransform = new XmlDsigC14NTransform(true); { _14nTransform.Algorithm = SignedXml.XmlDsigExcC14NTransformUrl; Type[] _validInTypes = _14nTransform.InputTypes; for (int i = 0; i < _validInTypes.Length; i++) { if (_validInTypes[i] == typeof(System.IO.Stream)) { _14nTransform.LoadInput(source_xml); break; } } Type[] _validOutTypes = _14nTransform.OutputTypes; for (int i = 0; i < _validOutTypes.Length; i++) { if (_validOutTypes[i] == typeof(System.IO.Stream)) { Type streamType = typeof(System.IO.Stream); _result = (MemoryStream)_14nTransform.GetOutput(streamType); break; } } } return(_result); }
private void SetContentEveloping(SignatureDocument sigDocument, XmlDocument xmlDocument) { _refContent = new Reference(); sigDocument.XadesSignature = new XadesSignedXml(); XmlDocument xmlDocument2 = (XmlDocument)xmlDocument.Clone(); xmlDocument2.PreserveWhitespace = true; if (xmlDocument2.ChildNodes[0].NodeType == XmlNodeType.XmlDeclaration) { xmlDocument2.RemoveChild(xmlDocument2.ChildNodes[0]); } Guid guid = Guid.NewGuid(); string text = "DataObject-" + guid.ToString(); DataObject dataObject = new DataObject(); dataObject.Data = xmlDocument2.ChildNodes; dataObject.Id = text; sigDocument.XadesSignature.AddObject(dataObject); Reference refContent = _refContent; guid = Guid.NewGuid(); refContent.Id = "Reference-" + guid.ToString(); _refContent.Uri = "#" + text; _refContent.Type = "http://www.w3.org/2000/09/xmldsig#Object"; XmlDsigC14NTransform transform = new XmlDsigC14NTransform(); _refContent.AddTransform(transform); _mimeType = "text/xml"; _encoding = "UTF-8"; sigDocument.XadesSignature.AddReference(_refContent); }
public XmlDocument SaveWithSignature(AsymmetricAlgorithm key) { XmlDocument doc = Save(); SignedXml sign = new SignedXml(doc); Reference reference = new Reference(); reference.Uri = ""; Transform trns = new XmlDsigC14NTransform(); reference.AddTransform(trns); XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform(); reference.AddTransform(env); sign.AddReference(reference); sign.SigningKey = key; sign.Resolver = null; sign.ComputeSignature(); XmlElement xmlDigitalSignature = sign.GetXml(); doc.DocumentElement.AppendChild(doc.ImportNode(xmlDigitalSignature, true)); return(doc); }
public static XmlDocument AssinarNotaFiscal(string xml, string refUri, X509Certificate2 x509Cert, ref string digVal) { XmlDocument doc = new XmlDocument(); doc.LoadXml(xml); SignedXml signedXml = new SignedXml(doc); Reference reference = new Reference(); signedXml.SigningKey = x509Cert.PrivateKey; reference.Uri = refUri; XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform(); XmlDsigC14NTransform c14 = new XmlDsigC14NTransform(); KeyInfo keyInfo = new KeyInfo(); reference.AddTransform(env); reference.AddTransform(c14); signedXml.AddReference(reference); keyInfo.AddClause(new KeyInfoX509Data(x509Cert)); signedXml.KeyInfo = keyInfo; signedXml.ComputeSignature(); XmlElement xmlDigitalSignature = signedXml.GetXml(); XmlNode infNfe = doc.ChildNodes.Item(0); digVal = Convert.ToBase64String(reference.DigestValue); infNfe.AppendChild(doc.ImportNode(xmlDigitalSignature, true)); return(doc); }
public void Constructor_Empty() { XmlDsigC14NTransform transform = new XmlDsigC14NTransform(); Assert.Equal("http://www.w3.org/TR/2001/REC-xml-c14n-20010315", transform.Algorithm); CheckProperties(transform); }
/// <summary> /// Carga el documento XML especificado y establece para firmar el elemento especificado en elementId /// </summary> /// <param name="xmlDocument"></param> /// <param name="elementId"></param> /// <param name="mimeType"></param> public void SetContentInternallyDetached(XmlDocument xmlDocument, string elementId, string mimeType) { _document = (XmlDocument)xmlDocument.Clone(); _document.PreserveWhitespace = true; Reference reference = new Reference(); reference.Uri = "#" + elementId; reference.Id = "Reference-" + Guid.NewGuid().ToString(); _objectReference = reference.Id; _mimeType = mimeType; if (mimeType == "text/xml") { XmlDsigC14NTransform transform = new XmlDsigC14NTransform(); reference.AddTransform(transform); } else { XmlDsigBase64Transform transform = new XmlDsigBase64Transform(); reference.AddTransform(transform); } _xadesSignedXml = new XadesSignedXml(_document); _xadesSignedXml.AddReference(reference); }
/// <summary> /// Canonicaliza el DTE sin el CAF. Luego agrega el CAF del xml original sin modificarlo. /// </summary> /// <param name="sDte"></param> /// <param name="ts"></param> public void Canonicaliza(string sDte, DateTime ts) { try { sMsj = string.Empty; iErr = 0; //Eliminar CAF de TED para que no sea canonicalizado XmlNode _xmlNode = modeloTed.xDocXml.SelectSingleNode("//TED/DD/CAF"); _xmlNode.ParentNode.RemoveChild(_xmlNode); //Agrega TED a DTE/Documento XmlDocument xDte = new XmlDocument(); xDte.PreserveWhitespace = true; xDte.LoadXml(Comun.Utiles.RemoveAllXmlNamespace(sDte)); XmlDocumentFragment tedFragment = xDte.CreateDocumentFragment(); tedFragment.InnerXml = modeloTed.xDocXml.DocumentElement.SelectSingleNode("//TED").OuterXml; xDte.DocumentElement.FirstChild.AppendChild(tedFragment); //Agregar TmstFirma XmlDocumentFragment timeStamp = xDte.CreateDocumentFragment(); timeStamp.InnerXml = "<TmstFirma>" + ts.ToString("s") + "</TmstFirma>"; xDte.DocumentElement.FirstChild.AppendChild(timeStamp); //Canonicalizar. Comenta para set de pruebas XmlDsigC14NTransform t = new XmlDsigC14NTransform(); t.LoadInput(xDte); Stream s = (Stream)t.GetOutput(typeof(Stream)); _xDocXml.Load(s); string sDocXml = _xDocXml.OuterXml.Replace("><", ">\n<"); //agrega line breaks //string sDocXml = xDte.OuterXml.Replace("><", ">\n<"); //agrega line breaks //string sDocXml = xDte.OuterXml; _xDocXml.LoadXml(sDocXml); //Agregar CAF XmlDocumentFragment caf = _xDocXml.CreateDocumentFragment(); caf.InnerXml = _autorizacionXml.DocumentElement.SelectSingleNode("//AUTORIZACION/CAF").OuterXml; XmlNode it1 = _xDocXml.DocumentElement.SelectSingleNode("//DTE/Documento/TED/DD/IT1"); XmlNode parent = _xDocXml.DocumentElement.SelectSingleNode("//DTE/Documento/TED/DD"); parent.InsertAfter(caf, it1); //XmlNode caf = _autorizacionXml.DocumentElement.SelectSingleNode("//AUTORIZACION/CAF"); //XmlNode it1 = _xDocXml.DocumentElement.SelectSingleNode("//DTE/Documento/TED/DD/IT1"); //XmlNode parent = _xDocXml.DocumentElement.SelectSingleNode("//DTE/Documento/TED/DD"); //parent.InsertAfter(caf, it1); sDocXml = _xDocXml.OuterXml.Replace("</IT1>", "</IT1>\n"); //agrega line break //sDocXml = _xDocXml.OuterXml; _xDocXml.LoadXml(sDocXml); } catch (Exception cn) { iErr++; sMsj = cn.Message + " [DteModel.Canonicaliza]"; throw; } }
private static string GetIRMark(byte[] Xml) { string vbLf = "\n"; string vbCrLf = "\r\n"; // Convert Byte array to string string text = Encoding.UTF8.GetString(Xml); XmlDocument doc = new XmlDocument(); doc.PreserveWhitespace = true; doc.LoadXml(text); XmlNamespaceManager ns = new XmlNamespaceManager(doc.NameTable); ns.AddNamespace("env", doc.DocumentElement.NamespaceURI); XmlNode Body = doc.SelectSingleNode("//env:Body", ns); ns.AddNamespace("tax", Body.FirstChild.NamespaceURI); // Create an XML document of just the body section XmlDocument xmlBody = new XmlDocument(); xmlBody.PreserveWhitespace = true; xmlBody.LoadXml(Body.OuterXml); // Remove any existing IRMark XmlNode nodeIr = xmlBody.SelectSingleNode("//tax:IRmark", ns); if (nodeIr != null) { nodeIr.ParentNode.RemoveChild(nodeIr); } //Normalise the document using C14N(Canonicalisation) XmlDsigC14NTransform c14n = new XmlDsigC14NTransform(); c14n.LoadInput(xmlBody); using (Stream S = (Stream)c14n.GetOutput()) { byte[] Buffer = new byte[S.Length]; // Convert to string and normalise line endings S.Read(Buffer, 0, (int)S.Length); text = Encoding.UTF8.GetString(Buffer); text = text.Replace("
", ""); text = text.Replace(vbCrLf, vbLf); text = text.Replace(vbCrLf, vbLf); // Convert the final document back into a byte array byte[] b = Encoding.UTF8.GetBytes(text); // Create the SHA - 1 hash from the final document SHA1 SHA = SHA1.Create(); byte[] hash = SHA.ComputeHash(b); return(Convert.ToBase64String(hash)); } }
/// <summary> /// Obtém a assinatura de um objeto serializável /// </summary> /// <typeparam name="T"></typeparam> /// <param name="objeto"></param> /// <param name="id"></param> /// <param name="certificadoDigital">Informe o certificado digital</param> /// <param name="manterDadosEmCache">Validador para manter o certificado em cache</param> /// <returns>Retorna um objeto do tipo Classes.Assinatura.Signature, contendo a assinatura do objeto passado como parâmetro</returns> public static Signature ObterAssinatura <T>(T objeto, string id, X509Certificate2 certificadoDigital, bool manterDadosEmCache = false, string signatureMethod = "http://www.w3.org/2000/09/xmldsig#rsa-sha1", string digestMethod = "http://www.w3.org/2000/09/xmldsig#sha1") where T : class { var objetoLocal = objeto; if (id == null) { throw new Exception("Não é possível assinar um objeto evento sem sua respectiva Id!"); } try { var documento = new XmlDocument { PreserveWhitespace = true }; documento.LoadXml(FuncoesXml.ClasseParaXmlString(objetoLocal)); var docXml = new SignedXml(documento) { SigningKey = certificadoDigital.PrivateKey }; docXml.SignedInfo.SignatureMethod = signatureMethod; var reference = new Reference { Uri = "#" + id, DigestMethod = digestMethod }; // adicionando EnvelopedSignatureTransform a referencia var envelopedSigntature = new XmlDsigEnvelopedSignatureTransform(); reference.AddTransform(envelopedSigntature); var c14Transform = new XmlDsigC14NTransform(); reference.AddTransform(c14Transform); docXml.AddReference(reference); // carrega o certificado em KeyInfoX509Data para adicionar a KeyInfo var keyInfo = new KeyInfo(); keyInfo.AddClause(new KeyInfoX509Data(certificadoDigital)); docXml.KeyInfo = keyInfo; docXml.ComputeSignature(); //// recuperando a representação do XML assinado var xmlDigitalSignature = docXml.GetXml(); var assinatura = FuncoesXml.XmlStringParaClasse <Signature>(xmlDigitalSignature.OuterXml); return(assinatura); } finally { //Se não mantém os dados do certificado em cache e o certificado não foi passado por parâmetro(isto é, ele foi criado dentro deste método), //então libera o certificado, chamando o método reset. if (!manterDadosEmCache & certificadoDigital == null) { certificadoDigital.Reset(); } } }
public static XmlDocument Assinar(XmlDocument docXML, string pUri, X509Certificate2 pCertificado) { try { // Load the certificate from the certificate store. X509Certificate2 cert = pCertificado; // Create a new XML document. XmlDocument doc = new XmlDocument(); // Format the document to ignore white spaces. doc.PreserveWhitespace = false; // Load the passed XML file using it's name. doc = docXML; // Create a SignedXml object. SignedXml signedXml = new SignedXml(doc); // Add the key to the SignedXml document. signedXml.SigningKey = cert.PrivateKey; // Create a reference to be signed. Reference reference = new Reference(); // pega o uri que deve ser assinada XmlAttributeCollection _Uri = doc.GetElementsByTagName(pUri).Item(0).Attributes; foreach (XmlAttribute _atributo in _Uri) { if (_atributo.Name == "Id") { reference.Uri = "#" + _atributo.InnerText; } } // Add an enveloped transformation to the reference. XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform(); reference.AddTransform(env); XmlDsigC14NTransform c14 = new XmlDsigC14NTransform(); reference.AddTransform(c14); // Add the reference to the SignedXml object. signedXml.AddReference(reference); // Create a new KeyInfo object. KeyInfo keyInfo = new KeyInfo(); // Load the certificate into a KeyInfoX509Data object // and add it to the KeyInfo object. keyInfo.AddClause(new KeyInfoX509Data(cert)); // Add the KeyInfo object to the SignedXml object. signedXml.KeyInfo = keyInfo; // Compute the signature. signedXml.ComputeSignature(); // Get the XML representation of the signature and save // it to an XmlElement object. XmlElement xmlDigitalSignature = signedXml.GetXml(); // Append the element to the XML document. doc.DocumentElement.AppendChild(doc.ImportNode(xmlDigitalSignature, true)); if (doc.FirstChild is XmlDeclaration) { doc.RemoveChild(doc.FirstChild); } return doc; } catch (Exception ex) { throw new Exception("Erro ao efetuar assinatura digital, detalhes: " + ex.Message); } }