Erstellen eines XML-Dokuments Hash in C #

Question

Was ist der beste Weg, um über Hashing ein XML-Dokuments in C # gehen? Ich möchte ein XML-Dokument Hash, so dass ich sagen kann, wenn sie manuell aus geändert wurde, wenn es erzeugt wurde. Ich verwende diese nicht für die Sicherheit -. Es ist in Ordnung, wenn jemand die XML ändert, und ändert die Hash Match

Zum Beispiel würde ich die untergeordneten Knoten des Root-Hash und speichert den Hash als ein Attribut der Wurzel:

<RootNode Hash="abc123">
    <!-- Content to hash here -->
</RootNode>

Answer 1

.NET hat Klassen dass die XML digitale Signatur spec . Die Signatur kann in dem ursprünglichen XML-Dokument hinzugefügt werden (das heißt eine „umhüllte Signatur“) oder gespeichert / übertragen getrennt.

Es kann ein bisschen übertrieben, da Sie die Sicherheit nicht brauchen, aber es hat den Vorteil, dass sie bereits umgesetzt, und ist ein Standard, hängt nicht von einer Sprache oder Plattform.

Answer 2

Sie können den Kryptographie-Namensraum verwenden:

System.Security.Cryptography.MACTripleDES hash = new System.Security.Cryptography.MACTripleDES(Encoding.Default.GetBytes("mykey"));
string hashString = Convert.ToBase64String(hash.ComputeHash(Encoding.Default.GetBytes(myXMLString)));

Sie müssen nur einen Schlüssel verwenden, um die Hashing Kryptograph zu erstellen und dann einen Hash mit dem String reqpresentation Ihre XML erstellen.

Answer 3

ein .NET Verweis auf System.Security Hinzufügen und Verwendung XmlDsigC14NTransform. Hier ist ein Beispiel ...

/* http://www.w3.org/TR/xml-c14n

    Of course is cannot detect these are the same...

       <color>black</color>    vs.   <color>rgb(0,0,0)</color>

    ...because that's dependent on app logic's interpretation of XML data.

    But otherwise it gets the following right...
    •Normalization of whitespace in start and end tags
    •Lexicographic ordering of namespace and attribute
    •Empty element conversion to start-end tag pair 
    •Retain all whitespace between tags

    And more.
 */
public static string XmlHash(XmlDocument myDoc)
{
    var t = new System.Security.Cryptography.Xml.XmlDsigC14NTransform();
    t.LoadInput(myDoc);
    var s = (Stream)t.GetOutput(typeof(Stream));
    var sha1 = SHA1.Create();

    var hash = sha1.ComputeHash(s);
    var base64String = Convert.ToBase64String(hash);
    s.Close();
    return base64String;
}

Answer 4

Ich musste kürzlich einen Hash „Prüfsumme“ für Teil-XML-Dokumente bei der Arbeit umzusetzen (wir verwenden XElement). Rudimentäre Leistungstests zeigten ~ 3x Laufzeit Speedup auf meinem Rechner, wenn für die Erstellung des Hex-String-Hash einer Lookup-Tabelle verwendet wird, im Vergleich zu ohne.

Hier ist meine Implementierung:

using System.Xml.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Linq;

/// <summary>
/// Provides a way to easily compute SHA256 hash strings for XML objects.
/// </summary>
public static class XMLHashUtils
{
    /// <summary>
    /// Precompute a hexadecimal lookup table for runtime performance gain, at the cost of memory and startup performance loss.
    /// SOURCE: https://stackoverflow.com/a/18574846
    /// </summary>
    static readonly string[] hexLookupTable = Enumerable.Range(0, 256).Select(integer => integer.ToString("x2")).ToArray();

    static readonly SHA256Managed sha256 = new SHA256Managed();

    /// <summary>
    /// Computes a SHA256 hash string from an XElement and its children.
    /// </summary>
    public static string Hash(XElement xml)
    {
        string xmlString = xml.ToString(SaveOptions.DisableFormatting); // Outputs XML as single line
        return Hash(xmlString);
    }

    /// <summary>
    /// Computes a SHA256 hash string from a string.
    /// </summary>
    static string Hash(string stringValue)
    {
        byte[] hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(stringValue));
        return BytesToHexString(hashBytes);
    }

    /// <summary>
    /// Converts a byte array to a hexadecimal string using a lookup table.
    /// </summary>
    static string BytesToHexString(byte[] bytes)
    {
        int length = bytes.Length;
        StringBuilder sb = new StringBuilder(length * 2); // Capacity fits hash string length
        for (var i = 0; i < length; i++)
        {
            sb.Append(hexLookupTable[bytes[i]]); // Using lookup table for faster runtime conversion
        }
        return sb.ToString();
    }
}

Und here ein paar Unit-Tests für sie (mit der NUnit-Framework):

using NUnit.Framework;
using System.Linq;
using System.Xml.Linq;

public class XMLHashUtilsTest
{
    /// <summary>
    /// Outputs XML: <root><child attribute="value" /></root>
    /// where <child /> node repeats according to childCount
    /// </summary>
    XElement CreateXML(int childCount)
    {
        return new XElement("root", Enumerable.Repeat(new XElement("child", new XAttribute("attribute", "value")), childCount));
    }

    [Test]
    public void HashIsDeterministic([Values(0,1,10)] int childCount)
    {
        var xml = CreateXML(childCount);
        Assert.AreEqual(XMLHashUtils.Hash(xml), XMLHashUtils.Hash(xml));
    }

    [Test]
    public void HashChanges_WhenChildrenAreDifferent([Values(0,1,10)] int childCount)
    {
        var xml1 = CreateXML(childCount);
        var xml2 = CreateXML(childCount + 1);
        Assert.AreNotEqual(XMLHashUtils.Hash(xml1), XMLHashUtils.Hash(xml2));
    }

    [Test]
    public void HashChanges_WhenRootNameIsDifferent([Values("A","B","C")]string nameSuffix)
    {
        var xml1 = CreateXML(1);
        var xml2 = CreateXML(1);
        xml2.Name = xml2.Name + nameSuffix;
        Assert.AreNotEqual(XMLHashUtils.Hash(xml1), XMLHashUtils.Hash(xml2));
    }

    [Test]
    public void HashChanges_WhenRootAttributesAreDifferent([Values("A","B","C")]string attributeName)
    {
        var xml1 = CreateXML(1);
        var xml2 = CreateXML(1);
        xml2.Add(new XAttribute(attributeName, "value"));
        Assert.AreNotEqual(XMLHashUtils.Hash(xml1), XMLHashUtils.Hash(xml2));
    }
}