Beispiel #1
0
        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());
        }
Beispiel #2
0
        /// <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));
        }
Beispiel #3
0
        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)));
        }
Beispiel #5
0
        /// <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()));
        }
Beispiel #6
0
        private byte[] DoC14N(XmlDocument doc)
        {
            XmlDsigC14NTransform c14n = new XmlDsigC14NTransform(false);

            c14n.LoadInput(doc);
            return(DoC14N(c14n));
        }
Beispiel #7
0
        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));
    }
Beispiel #11
0
        public void Constructor_Bool(bool includeComments, string expectedAlgorithm)
        {
            XmlDsigC14NTransform transform = new XmlDsigC14NTransform(includeComments);

            Assert.Equal(expectedAlgorithm, transform.Algorithm);
            CheckProperties(transform);
        }
Beispiel #12
0
        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())));
            }
        }
Beispiel #13
0
        public void LoadInputWithUnsupportedType()
        {
            XmlDsigC14NTransform transform = new XmlDsigC14NTransform();

            byte[] bad = { 0xBA, 0xD };
            AssertExtensions.Throws <ArgumentException>("obj", () => transform.LoadInput(bad));
        }
Beispiel #14
0
        public void UnsupportedOutput()
        {
            XmlDsigC14NTransform transform = new XmlDsigC14NTransform();
            XmlDocument          doc       = new XmlDocument();

            AssertExtensions.Throws <ArgumentException>("type", () => transform.GetOutput(doc.GetType()));
        }
Beispiel #15
0
    // 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);
    }
Beispiel #16
0
        private static byte[] CalculateC14nByteRange(XmlDocument doc)
        {
            XmlDsigC14NTransform c14nTransform = new XmlDsigC14NTransform();

            c14nTransform.LoadInput(doc);
            return(((System.IO.MemoryStream)c14nTransform.GetOutput()).ToArray());
        }
Beispiel #17
0
        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);
        }
Beispiel #20
0
        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);
    }
Beispiel #22
0
        /// <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);
        }
Beispiel #23
0
        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);
        }
Beispiel #26
0
        public void Constructor_Empty()
        {
            XmlDsigC14NTransform transform = new XmlDsigC14NTransform();

            Assert.Equal("http://www.w3.org/TR/2001/REC-xml-c14n-20010315", transform.Algorithm);
            CheckProperties(transform);
        }
Beispiel #27
0
        /// <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);
        }
Beispiel #28
0
        /// <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;
            }
        }
Beispiel #29
0
        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("&#xD;", "");
                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));
            }
        }
Beispiel #30
0
        /// <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 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);
    }
	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);
		}
	}