public static bool IsEqual <T>(T param1, T param2)
where T : class
{
if (param1 == null && param2 == null)
{
return(true);
}
if (param1 == null || param2 == null)
{
return(false);
}
XmlSerializer serializer = new XmlSerializer(typeof(T));
using (MemoryStream stream1 = new MemoryStream(), stream2 = new MemoryStream())
{
serializer.Serialize(stream1, param1);
serializer.Serialize(stream2, param2);
stream1.Seek(0, SeekOrigin.Begin);
stream2.Seek(0, SeekOrigin.Begin);
Stream canonicalizedStream1 = null, canonicalizedStream2 = null;
try
{
XmlDsigC14NTransform xmlCanonicalizer = new XmlDsigC14NTransform();
xmlCanonicalizer.LoadInput(stream1);
canonicalizedStream1 = (Stream)xmlCanonicalizer.GetOutput(typeof(Stream));
xmlCanonicalizer.LoadInput(stream2);
canonicalizedStream2 = (Stream)xmlCanonicalizer.GetOutput(typeof(Stream));
canonicalizedStream1.Seek(0, SeekOrigin.Begin);
canonicalizedStream2.Seek(0, SeekOrigin.Begin);
return(Equals(new StreamReader(canonicalizedStream1).ReadToEnd(), new StreamReader(canonicalizedStream2).ReadToEnd()));
}
finally
{
if (canonicalizedStream1 != null)
{
canonicalizedStream1.Close();
}
if (canonicalizedStream2 != null)
{
canonicalizedStream2.Close();
}
}
}
}
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>
///
/// </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 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());
}
public static Stream GetCanonicalStreamFromXML(XmlDocument xmlDoc) //C14N
{
XmlDsigC14NTransform transformData = new XmlDsigC14NTransform();
transformData.LoadInput(xmlDoc);
return((Stream)transformData.GetOutput(typeof(Stream)));
}
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())));
}
}
private static byte[] CalculateC14nByteRange(XmlDocument doc)
{
XmlDsigC14NTransform c14nTransform = new XmlDsigC14NTransform();
c14nTransform.LoadInput(doc);
return(((System.IO.MemoryStream)c14nTransform.GetOutput()).ToArray());
}
/// <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()));
}
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 UnsupportedOutput()
{
XmlDsigC14NTransform transform = new XmlDsigC14NTransform();
XmlDocument doc = new XmlDocument();
AssertExtensions.Throws <ArgumentException>("type", () => transform.GetOutput(doc.GetType()));
}
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 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());
}
/// <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>
/// Devuelve el XML de entrada canonicalizado.
/// </summary>
/// <param name="xmlNodeList">Lista de nodos a canonicalizar.</param>
/// <returns>XML de entrada canonicalizado.</returns>
public string GetCanonicalString(XmlNodeList xmlNodeList)
{
XmlDsigC14NTransform xmlTransform = new XmlDsigC14NTransform();
xmlTransform.LoadInput(xmlNodeList);
MemoryStream ms = (MemoryStream)xmlTransform.GetOutput(typeof(MemoryStream));
return(Encoding.UTF8.GetString(ms.ToArray()));
}
public void LoadInputAsXmlDocument()
{
XmlDsigC14NTransform transform = new XmlDsigC14NTransform();
XmlDocument doc = GetDoc();
transform.LoadInput(doc);
Stream s = (Stream)transform.GetOutput();
string output = TestHelpers.StreamToString(s, Encoding.UTF8);
Assert.Equal(c14xml3, output);
}
internal static XmlDocument Canonize(XmlDocument doc)
{
XmlDsigC14NTransform t = new XmlDsigC14NTransform();
t.LoadInput(doc);
Stream s = (Stream)t.GetOutput(typeof(Stream));
StreamReader reader = new StreamReader(s);
doc.LoadXml(reader.ReadToEnd());
return(doc);
}
public void LoadInputAsXmlNodeList()
{
XmlDsigC14NTransform transform = new XmlDsigC14NTransform();
XmlDocument doc = GetDoc();
transform.LoadInput(doc.ChildNodes);
Stream s = (Stream)transform.GetOutput();
string output = TestHelpers.StreamToString(s, Encoding.UTF8);
Assert.Equal(@"<Test xmlns=""http://www.go-mono.com/""></Test>", output);
}
// MS has a bug that those namespace declaration nodes in
// the node-set are written to output. Related spec section is:
// http://www.w3.org/TR/2001/REC-xml-c14n-20010315#ProcessingModel
public void LoadInputAsXmlNodeList2()
{
XmlDsigC14NTransform transform = new XmlDsigC14NTransform();
XmlDocument doc = GetDoc();
transform.LoadInput(doc.SelectNodes("//*"));
Stream s = (Stream)transform.GetOutput();
string output = TestHelpers.StreamToString(s, Encoding.UTF8);
string expected = @"<Test xmlns=""http://www.go-mono.com/""><Toto></Toto></Test>";
Assert.Equal(expected, output);
}
private static byte[] CalculateC14nByteRange(XmlElement element, XmlDocument doc)
{
XmlElement cloneElement = (XmlElement)element.CloneNode(true);
NormalizeNamespaces(element.CreateNavigator(), cloneElement.CreateNavigator());
XmlDocument elememntDoc = new XmlDocument(doc.NameTable);
elememntDoc.LoadXml(cloneElement.OuterXml);
XmlDsigC14NTransform c14nTransform = new XmlDsigC14NTransform();
c14nTransform.LoadInput(elememntDoc);
return(((MemoryStream)c14nTransform.GetOutput()).ToArray());
}
public static byte[] CanonicalizeXml(XmlNode xmlNode)
{
XmlDocument manifestDoc = new XmlDocument();
manifestDoc.PreserveWhitespace = true;
manifestDoc.LoadXml(xmlNode.OuterXml);
XmlDsigC14NTransform c14n = new XmlDsigC14NTransform(false);
c14n.LoadInput(manifestDoc);
return(((MemoryStream)c14n.GetOutput()).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);
}
public void OrdinalSortForAttributes()
{
XmlDsigC14NTransform transform = new XmlDsigC14NTransform();
XmlDocument doc = new XmlDocument();
string xml = "<foo Aa=\"one\" Bb=\"two\" aa=\"three\" bb=\"four\"><bar></bar></foo>";
doc.LoadXml(xml);
transform.LoadInput(doc);
Stream s = (Stream)transform.GetOutput();
string output = TestHelpers.StreamToString(s, Encoding.UTF8);
Assert.Equal(xml, output);
}
public void LoadInputAsStream()
{
XmlDsigC14NTransform transform = new XmlDsigC14NTransform();
MemoryStream ms = new MemoryStream();
byte[] x = Encoding.ASCII.GetBytes(xml);
ms.Write(x, 0, x.Length);
ms.Position = 0;
transform.LoadInput(ms);
Stream s = (Stream)transform.GetOutput();
string output = TestHelpers.StreamToString(s, Encoding.UTF8);
Assert.Equal(c14xml2, output);
}
private static byte[] GetXmlHashByteStream(XmlDocument xmlDoc)
{
byte[] hash;
XmlDsigC14NTransform transformer = new XmlDsigC14NTransform();
transformer.LoadInput(xmlDoc);
using (Stream stream = (Stream)transformer.GetOutput(typeof(Stream)))
{
SHA1 sha1 = SHA1.Create();
hash = sha1.ComputeHash(stream);
stream.Close();
}
return(hash);
}
public void PrefixlessNamespaceOutput()
{
XmlDocument doc = new XmlDocument();
doc.AppendChild(doc.CreateElement("foo", "urn:foo"));
doc.DocumentElement.AppendChild(doc.CreateElement("bar", "urn:bar"));
Assert.Equal(string.Empty, doc.DocumentElement.GetAttribute("xmlns"));
XmlDsigC14NTransform t = new XmlDsigC14NTransform();
t.LoadInput(doc);
Stream s = t.GetOutput() as Stream;
Assert.Equal("<foo xmlns=\"urn:foo\"><bar xmlns=\"urn:bar\"></bar></foo>", new StreamReader(s, Encoding.UTF8).ReadToEnd());
Assert.Equal("urn:foo", doc.DocumentElement.GetAttribute("xmlns"));
}
public void SimpleNamespacePrefixes()
{
string input = "<a:Action xmlns:a='urn:foo'>http://tempuri.org/IFoo/Echo</a:Action>";
string expected = @"<a:Action xmlns:a=""urn:foo"">http://tempuri.org/IFoo/Echo</a:Action>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(input);
XmlDsigC14NTransform t = new XmlDsigC14NTransform();
t.LoadInput(doc);
Stream s = t.GetOutput() as Stream;
Assert.Equal(new StreamReader(s, Encoding.UTF8).ReadToEnd(), expected);
}
/// <summary>
/// Serializa el objeto como xml y lo devuelve
/// como archivo xml canonicalizado en una cadena.
/// </summary>
/// <param name="instance">Instancia de objeto a serializar.</param>
/// <param name="namespaces">Espacios de nombres.</param>
/// <param name="indent">Indica si se debe utilizar indentación.</param>
/// <param name="omitXmlDeclaration">Indica si se se omite la delcaración xml.</param>
/// <returns>string con el archivo xml.</returns>
public string GetCanonicalString(object instance, Dictionary <string, string> namespaces, bool indent = false, bool omitXmlDeclaration = true)
{
var xmlContent = Encoding.GetString(GetBytes(instance, namespaces, indent, omitXmlDeclaration));
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(xmlContent);
XmlDsigC14NTransform xmlTransform = new XmlDsigC14NTransform();
xmlTransform.LoadInput(xmlDoc);
MemoryStream ms = (MemoryStream)xmlTransform.GetOutput(typeof(MemoryStream));
return(Encoding.GetString(ms.ToArray()));
}
public static string GetCanonicalXml(string xml)
{
XmlDocument document = new XmlDocument();
document.PreserveWhitespace = true;
document.LoadXml(xml);
XmlDsigC14NTransform c14n = new XmlDsigC14NTransform();
c14n.LoadInput(document);
Stream s = (Stream)c14n.GetOutput(typeof(Stream));
return(new StreamReader(s, Encoding.UTF8).ReadToEnd());
}
private static Stream CanonicalizeNode(XmlNode node)
{
var reader = new XmlNodeReader(node);
Stream stream = new MemoryStream();
XmlWriter writer = new XmlTextWriter(stream, Encoding.UTF8);
writer.WriteNode(reader, false);
writer.Flush();
stream.Position = 0;
var transform = new XmlDsigC14NTransform();
transform.LoadInput(stream);
return((Stream)transform.GetOutput());
}
private static string GetDigest(XmlDocument doc)
{
XmlDsigC14NTransform t = new XmlDsigC14NTransform();
t.LoadInput(doc);
Stream s = (Stream)t.GetOutput(typeof(Stream));
byte[] hash;
using (SHA512 sha = new SHA512Managed())
{
hash = sha.ComputeHash(s);
}
return(Convert.ToBase64String(hash));
}
