Gewusst wie: Entschlüsseln von XML-Elementen mit asymmetrischen Schlüsseln

Aktualisiert: November 2007

Sie können die Klassen im System.Security.Cryptography.Xml-Namespace verwenden, um ein Element innerhalb eines XML-Dokuments zu verschlüsseln. Die XML-Verschlüsselung ist ein gängiges Verfahren zum Austauschen oder Speichern von verschlüsselten XML-Daten, mit dem der nötige Datenschutz gewährleistet wird. Weitere Informationen über den XML-Verschlüsselungsstandard finden Sie in der W3C-Spezifikation (World Wide Web Consortium) für die XML-Verschlüsselung unter http://www.w3.org/TR/xmldsig-core/ (nur auf Englisch verfügbar).

Sie verwenden die XML-Verschlüsselung u. a., um jedes XML-Element oder XML-Dokument durch ein <EncryptedData>-Element zu ersetzen, das die verschlüsselten XML-Daten enthält. Das <EncryptedData>-Element kann auch Unterelemente mit Informationen über die bei der Verschlüsselung verwendeten Schlüssel und Prozesse enthalten. Mit XML-Verschlüsselung kann ein Dokument nicht nur viele verschlüsselte Elemente enthalten, sondern ein Element kann auch mehrfach verschlüsselt sein. Das Codebeispiel in dieser Prozedur veranschaulicht das Erstellen eines <EncryptedData>-Elements zusammen mit weiteren Unterelementen, die Sie später bei der Entschlüsselung verwenden können.

In diesem Beispiel wird ein XML-Element mithilfe zweier Schlüssel verschlüsselt. Es wird ein öffentliches/privates RSA-Schlüsselpaar generiert und in einem sicheren Schlüsselcontainer gespeichert. Anschließend wird ein separater Sitzungsschlüssel mithilfe des AES-Algorithmus (Advanced Encryption Standard), des sogenannten Rijndael-Algorithmus, erstellt. Dieser AES-Sitzungsschlüssel wird dann zum Verschlüsseln des XML-Dokuments verwendet. Der öffentliche RSA-Schlüssel dient dem Verschlüsseln des AES-Sitzungsschlüssels. Schließlich werden in diesem Beispiel der verschlüsselte AES-Sitzungsschlüssel sowie die verschlüsselten XML-Daten im XML-Dokument innerhalb eines neuen <EncryptedData>-Elements gespeichert.

Zum Entschlüsseln des XML-Elements rufen Sie den privaten RSA-Schlüssel aus dem Schlüsselcontainer ab, verwenden ihn zum Entschlüsseln des Sitzungsschlüssels und entschlüsseln mit diesem Sitzungsschlüssel das Dokument. Weitere Informationen zum Entschlüsseln eines XML-Elements, das mit dieser Prozedur verschlüsselt wurde, finden Sie unter Gewusst wie: Entschlüsseln von XML-Elementen mit asymmetrischen Schlüsseln.

Das Beispiel eignet sich für Situationen, wenn mehrere Anwendungen verschlüsselte Daten gemeinsam nutzen müssen, oder wenn eine Anwendung verschlüsselte Daten immer dann speichern muss, wenn sie nicht ausgeführt wird.

So verschlüsseln Sie ein XML-Element mit einem asymmetrischen Schlüssel

1. Erstellen Sie ein CspParameters-Objekt, und geben Sie den Namen des Schlüsselcontainers an.

   Dim cspParams As New CspParameters()
   cspParams.KeyContainerName = "XML_ENC_RSA_KEY"
   

        CspParameters cspParams = new CspParameters();
           cspParams.KeyContainerName = "XML_ENC_RSA_KEY";
   

2. Generieren Sie mit der RSACryptoServiceProvider-Klasse einen symmetrischen Schlüssel. Der Schlüssel wird automatisch im benannten Schlüsselcontainer gespeichert, wenn Sie das CspParameters-Objekt an den Konstruktor der RSACryptoServiceProvider-Klasse übergeben. Dieser Schlüssel wird zum Verschlüsseln des AES-Sitzungsschlüssels verwendet und kann später zum Entschlüsseln abgerufen werden.

   Dim rsaKey As New RSACryptoServiceProvider(cspParams)
   

        RSACryptoServiceProvider rsaKey = new RSACryptoServiceProvider(cspParams);
   

3. Erstellen Sie ein XmlDocument-Objekt, indem Sie eine XML-Datei von einem Datenträger laden. Das XmlDocument-Objekt enthält das XML-Element für die Verschlüsselung.

   ' Create an XmlDocument object.
   Dim xmlDoc As New XmlDocument()
   
   ' Load an XML file into the XmlDocument object.
   Try
       xmlDoc.PreserveWhitespace = True
       xmlDoc.Load("test.xml")
   Catch e As Exception
       Console.WriteLine(e.Message)
   End Try
   

        // Create an XmlDocument object.
           XmlDocument xmlDoc = new XmlDocument();
   
           // Load an XML file into the XmlDocument object.
           try
           {
               xmlDoc.PreserveWhitespace = true;
               xmlDoc.Load("test.xml");
           }
           catch (Exception e)
           {
               Console.WriteLine(e.Message);
           }
   

4. Suchen Sie das angegebene Element im XmlDocument-Objekt, und erstellen Sie ein neues XmlElement-Objekt, um das Element darzustellen, das Sie verschlüsseln möchten. In diesem Beispiel wird das "creditcard"-Element verschlüsselt.

   Dim elementToEncrypt As XmlElement = Doc.GetElementsByTagName(ElementToEncryptName)(0)
   
   
   ' Throw an XmlException if the element was not found.
   If elementToEncrypt Is Nothing Then
       Throw New XmlException("The specified element was not found")
   End If
   

        XmlElement elementToEncrypt = Doc.GetElementsByTagName(ElementToEncrypt)[0] as XmlElement;
   
           // Throw an XmlException if the element was not found.
           if (elementToEncrypt == null)
           {
               throw new XmlException("The specified element was not found");
   
           }
   

5. Erstellen Sie mit der RijndaelManaged-Klasse einen neuen Sitzungsschlüssel. Dieser Schlüssel verschlüsselt das XML-Element und wird dann selbst verschlüsselt und im XML-Dokument platziert.

   ' Create a 256 bit Rijndael key.
   sessionKey = New RijndaelManaged()
   sessionKey.KeySize = 256
   

            // Create a 256 bit Rijndael key.
               sessionKey = new RijndaelManaged();
               sessionKey.KeySize = 256;
   

6. Erstellen Sie eine neue Instanz der EncryptedXml-Klasse, und verwenden Sie diese zusammen mit dem Sitzungsschlüssel zum Verschlüsseln des angegebenen Elements. Die EncryptData-Methode gibt das verschlüsselte Element als Array von verschlüsselten Bytes zurück.

   Dim eXml As New EncryptedXml()
   
   Dim encryptedElement As Byte() = eXml.EncryptData(elementToEncrypt, sessionKey, False)
   

            EncryptedXml eXml = new EncryptedXml();
   
               byte[] encryptedElement = eXml.EncryptData(elementToEncrypt, sessionKey, false);
   

7. Erstellen Sie ein EncryptedData-Objekt, und füllen Sie es mit dem URL-Bezeichner des verschlüsselten XML-Elements. Dieser URL-Bezeichner teilt einem Entschlüssler mit, dass die XML ein verschlüsseltes Element enthält. Sie können das XmlEncElementUrl-Feld verwenden, um den URL-Bezeichner anzugeben. Das Nur-Text XML-Element wird durch ein <EncrypotedData>-Element ersetzt, das von diesem EncryptedData-Objekt gekapselt wird.

   Dim edElement As New EncryptedData()
   edElement.Type = EncryptedXml.XmlEncElementUrl
   edElement.Id = EncryptionElementID
   

            EncryptedData edElement = new EncryptedData();
               edElement.Type = EncryptedXml.XmlEncElementUrl;
               edElement.Id = EncryptionElementID;
   

8. Erstellen Sie ein EncryptionMethod-Objekt, das mit dem URL-Bezeichner des für die Generierung des Sitzungsschlüssels verwendeten kryptografischen Algorithmus initialisiert wird. Übergeben Sie das EncryptionMethod-Objekt an die EncryptionMethod-Eigenschaft.

   edElement.EncryptionMethod = New EncryptionMethod(EncryptedXml.XmlEncAES256Url)
   

            edElement.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
   

9. Erstellen Sie ein EncryptedKey-Objekt, das den verschlüsselten Sitzungsschlüssel enthalten soll. Verschlüsseln Sie den Sitzungsschlüssel, fügen Sie ihn dem EncryptedKey-Objekt hinzu, und geben Sie für diesen Sitzungsschlüssel einen Namen und einen URL-Bezeichner ein.

   Dim ek As New EncryptedKey()
   
   Dim encryptedKey As Byte() = EncryptedXml.EncryptKey(sessionKey.Key, Alg, False)
   
   ek.CipherData = New CipherData(encryptedKey)
   
   ek.EncryptionMethod = New EncryptionMethod(EncryptedXml.XmlEncRSA15Url)
   

            EncryptedKey ek = new EncryptedKey();
   
               byte[] encryptedKey = EncryptedXml.EncryptKey(sessionKey.Key, Alg, false);
   
               ek.CipherData = new CipherData(encryptedKey);
   
               ek.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);
   

10. Erstellen Sie ein neues DataReference-Objekt, das die verschlüsselten Daten einem bestimmten Sitzungsschlüssel zuordnet. Mit diesem optionalen Schritt können Sie ohne großen Aufwand angeben, dass mehrere Teile eines XML-Dokuments mit einem einzelnen Schlüssel verschlüsselt wurden.

    Dim dRef As New DataReference()
    
    ' Specify the EncryptedData URI. 
    dRef.Uri = "#" + EncryptionElementID
    
    ' Add the DataReference to the EncryptedKey.
    ek.AddReference(dRef)
    

             DataReference dRef = new DataReference();
    
                // Specify the EncryptedData URI.
                dRef.Uri = "#" + EncryptionElementID;
    
                // Add the DataReference to the EncryptedKey.
                ek.AddReference(dRef);
    

11. Fügen Sie den verschlüsselten Schlüssel dem EncryptedData-Objekt hinzu.

    edElement.KeyInfo.AddClause(New KeyInfoEncryptedKey(ek))
    

             edElement.KeyInfo.AddClause(new KeyInfoEncryptedKey(ek));
    

12. Erstellen Sie ein neues KeyInfo-Objekt, um den Namen des RSA-Schlüssels anzugeben. Fügen Sie es dem EncryptedData-Objekt hinzu. Dies hilft dem Entschlüssler, beim Entschlüsseln des Sitzungsschlüssels den richtigen asymmetrischen Schlüssel festzulegen.

    ' Create a new KeyInfo element.
    edElement.KeyInfo = New KeyInfo()
    
    ' Create a new KeyInfoName element.
    Dim kin As New KeyInfoName()
    
    ' Specify a name for the key.
    kin.Value = KeyName
    
    ' Add the KeyInfoName element to the 
    ' EncryptedKey object.
    ek.KeyInfo.AddClause(kin)
    

             // Create a new KeyInfo element.
                edElement.KeyInfo = new KeyInfo();
    
                // Create a new KeyInfoName element.
                KeyInfoName kin = new KeyInfoName();
    
                // Specify a name for the key.
                kin.Value = KeyName;
    
                // Add the KeyInfoName element to the
                // EncryptedKey object.
                ek.KeyInfo.AddClause(kin);
    

13. Fügen Sie die verschlüsselten Elementdaten dem EncryptedData-Objekt hinzu.

    edElement.CipherData.CipherValue = encryptedElement
    

             edElement.CipherData.CipherValue = encryptedElement;
    

14. Ersetzen Sie das Element des ursprünglichen XmlDocument-Objekts durch das EncryptedData-Element.

    EncryptedXml.ReplaceElement(elementToEncrypt, edElement, False)
    

             EncryptedXml.ReplaceElement(elementToEncrypt, edElement, false);
    

15. Speichern Sie das XmlDocument-Objekt.

    xmlDoc.Save("test.xml")
    

             xmlDoc.Save("test.xml");
    

Beispiel

Imports System
Imports System.Xml
Imports System.Security.Cryptography
Imports System.Security.Cryptography.Xml



Module Program

    Sub Main(ByVal args() As String)
        ' Create an XmlDocument object.
        Dim xmlDoc As New XmlDocument()

        ' Load an XML file into the XmlDocument object.
        Try
            xmlDoc.PreserveWhitespace = True
            xmlDoc.Load("test.xml")
        Catch e As Exception
            Console.WriteLine(e.Message)
        End Try
        ' Create a new CspParameters object to specify
        ' a key container.
        Dim cspParams As New CspParameters()
        cspParams.KeyContainerName = "XML_ENC_RSA_KEY"
        ' Create a new RSA key and save it in the container.  This key will encrypt 
        ' a symmetric key, which will then be encryped in the XML document.
        Dim rsaKey As New RSACryptoServiceProvider(cspParams)
        Try
            ' Encrypt the "creditcard" element.
            Encrypt(xmlDoc, "creditcard", "EncryptedElement1", rsaKey, "rsaKey")


            ' Save the XML document.
            xmlDoc.Save("test.xml")
            ' Display the encrypted XML to the console.
            Console.WriteLine("Encrypted XML:")
            Console.WriteLine()
            Console.WriteLine(xmlDoc.OuterXml)

        Catch e As Exception
            Console.WriteLine(e.Message)
        Finally
            ' Clear the RSA key.
            rsaKey.Clear()
        End Try


        Console.ReadLine()

    End Sub


    Sub Encrypt(ByVal Doc As XmlDocument, ByVal ElementToEncryptName As String, ByVal EncryptionElementID As String, ByVal Alg As RSA, ByVal KeyName As String)
        ' Check the arguments.  
        If Doc Is Nothing Then
            Throw New ArgumentNullException("Doc")
        End If
        If ElementToEncryptName Is Nothing Then
            Throw New ArgumentNullException("ElementToEncrypt")
        End If
        If EncryptionElementID Is Nothing Then
            Throw New ArgumentNullException("EncryptionElementID")
        End If
        If Alg Is Nothing Then
            Throw New ArgumentNullException("Alg")
        End If
        If KeyName Is Nothing Then
            Throw New ArgumentNullException("KeyName")
        End If
        ''''''''''''''''''''''''''''''''''''''''''''''''''
        ' Find the specified element in the XmlDocument
        ' object and create a new XmlElemnt object.
        ''''''''''''''''''''''''''''''''''''''''''''''''''
        Dim elementToEncrypt As XmlElement = Doc.GetElementsByTagName(ElementToEncryptName)(0)


        ' Throw an XmlException if the element was not found.
        If elementToEncrypt Is Nothing Then
            Throw New XmlException("The specified element was not found")
        End If
        Dim sessionKey As RijndaelManaged = Nothing

        Try
            ''''''''''''''''''''''''''''''''''''''''''''''''''
            ' Create a new instance of the EncryptedXml class 
            ' and use it to encrypt the XmlElement with the 
            ' a new random symmetric key.
            ''''''''''''''''''''''''''''''''''''''''''''''''''
            ' Create a 256 bit Rijndael key.
            sessionKey = New RijndaelManaged()
            sessionKey.KeySize = 256
            Dim eXml As New EncryptedXml()

            Dim encryptedElement As Byte() = eXml.EncryptData(elementToEncrypt, sessionKey, False)
            ''''''''''''''''''''''''''''''''''''''''''''''''''
            ' Construct an EncryptedData object and populate
            ' it with the desired encryption information.
            ''''''''''''''''''''''''''''''''''''''''''''''''''
            Dim edElement As New EncryptedData()
            edElement.Type = EncryptedXml.XmlEncElementUrl
            edElement.Id = EncryptionElementID
            ' Create an EncryptionMethod element so that the 
            ' receiver knows which algorithm to use for decryption.
            edElement.EncryptionMethod = New EncryptionMethod(EncryptedXml.XmlEncAES256Url)
            ' Encrypt the session key and add it to an EncryptedKey element.
            Dim ek As New EncryptedKey()

            Dim encryptedKey As Byte() = EncryptedXml.EncryptKey(sessionKey.Key, Alg, False)

            ek.CipherData = New CipherData(encryptedKey)

            ek.EncryptionMethod = New EncryptionMethod(EncryptedXml.XmlEncRSA15Url)
            ' Create a new DataReference element
            ' for the KeyInfo element.  This optional
            ' element specifies which EncryptedData 
            ' uses this key.  An XML document can have
            ' multiple EncryptedData elements that use
            ' different keys.
            Dim dRef As New DataReference()

            ' Specify the EncryptedData URI. 
            dRef.Uri = "#" + EncryptionElementID

            ' Add the DataReference to the EncryptedKey.
            ek.AddReference(dRef)
            ' Add the encrypted key to the 
            ' EncryptedData object.
            edElement.KeyInfo.AddClause(New KeyInfoEncryptedKey(ek))
            ' Set the KeyInfo element to specify the
            ' name of the RSA key.
            ' Create a new KeyInfo element.
            edElement.KeyInfo = New KeyInfo()

            ' Create a new KeyInfoName element.
            Dim kin As New KeyInfoName()

            ' Specify a name for the key.
            kin.Value = KeyName

            ' Add the KeyInfoName element to the 
            ' EncryptedKey object.
            ek.KeyInfo.AddClause(kin)
            ' Add the encrypted element data to the 
            ' EncryptedData object.
            edElement.CipherData.CipherValue = encryptedElement
            ''''''''''''''''''''''''''''''''''''''''''''''''''
            ' Replace the element from the original XmlDocument
            ' object with the EncryptedData element.
            ''''''''''''''''''''''''''''''''''''''''''''''''''
            EncryptedXml.ReplaceElement(elementToEncrypt, edElement, False)
        Catch e As Exception
            ' re-throw the exception.
            Throw e
        Finally
            If Not (sessionKey Is Nothing) Then
                sessionKey.Clear()
            End If
        End Try

    End Sub
End Module

using System;
using System.Xml;
using System.Security.Cryptography;
using System.Security.Cryptography.Xml;

class Program
{
    static void Main(string[] args)
    {
        // Create an XmlDocument object.
        XmlDocument xmlDoc = new XmlDocument();

        // Load an XML file into the XmlDocument object.
        try
        {
            xmlDoc.PreserveWhitespace = true;
            xmlDoc.Load("test.xml");
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }

        // Create a new CspParameters object to specify
        // a key container.
        CspParameters cspParams = new CspParameters();
        cspParams.KeyContainerName = "XML_ENC_RSA_KEY";

        // Create a new RSA key and save it in the container.  This key will encrypt
        // a symmetric key, which will then be encryped in the XML document.
        RSACryptoServiceProvider rsaKey = new RSACryptoServiceProvider(cspParams);

        try
        {
            // Encrypt the "creditcard" element.
            Encrypt(xmlDoc, "creditcard", "EncryptedElement1", rsaKey, "rsaKey");


            // Save the XML document.
            xmlDoc.Save("test.xml");

            // Display the encrypted XML to the console.
            Console.WriteLine("Encrypted XML:");
            Console.WriteLine();
            Console.WriteLine(xmlDoc.OuterXml);

        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        finally
        {
            // Clear the RSA key.
            rsaKey.Clear();
        }


        Console.ReadLine();
    }

    public static void Encrypt(XmlDocument Doc, string ElementToEncrypt, string EncryptionElementID, RSA Alg, string KeyName)
    {
        // Check the arguments.
        if (Doc == null)
            throw new ArgumentNullException("Doc");
        if (ElementToEncrypt == null)
            throw new ArgumentNullException("ElementToEncrypt");
        if (EncryptionElementID == null)
            throw new ArgumentNullException("EncryptionElementID");
        if (Alg == null)
            throw new ArgumentNullException("Alg");
        if (KeyName == null)
            throw new ArgumentNullException("KeyName");

        ////////////////////////////////////////////////
        // Find the specified element in the XmlDocument
        // object and create a new XmlElemnt object.
        ////////////////////////////////////////////////
        XmlElement elementToEncrypt = Doc.GetElementsByTagName(ElementToEncrypt)[0] as XmlElement;

        // Throw an XmlException if the element was not found.
        if (elementToEncrypt == null)
        {
            throw new XmlException("The specified element was not found");

        }
        RijndaelManaged sessionKey = null;

        try
        {
            //////////////////////////////////////////////////
            // Create a new instance of the EncryptedXml class
            // and use it to encrypt the XmlElement with the
            // a new random symmetric key.
            //////////////////////////////////////////////////

            // Create a 256 bit Rijndael key.
            sessionKey = new RijndaelManaged();
            sessionKey.KeySize = 256;

            EncryptedXml eXml = new EncryptedXml();

            byte[] encryptedElement = eXml.EncryptData(elementToEncrypt, sessionKey, false);
            ////////////////////////////////////////////////
            // Construct an EncryptedData object and populate
            // it with the desired encryption information.
            ////////////////////////////////////////////////

            EncryptedData edElement = new EncryptedData();
            edElement.Type = EncryptedXml.XmlEncElementUrl;
            edElement.Id = EncryptionElementID;
            // Create an EncryptionMethod element so that the
            // receiver knows which algorithm to use for decryption.

            edElement.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
            // Encrypt the session key and add it to an EncryptedKey element.
            EncryptedKey ek = new EncryptedKey();

            byte[] encryptedKey = EncryptedXml.EncryptKey(sessionKey.Key, Alg, false);

            ek.CipherData = new CipherData(encryptedKey);

            ek.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);

            // Create a new DataReference element
            // for the KeyInfo element.  This optional
            // element specifies which EncryptedData
            // uses this key.  An XML document can have
            // multiple EncryptedData elements that use
            // different keys.
            DataReference dRef = new DataReference();

            // Specify the EncryptedData URI.
            dRef.Uri = "#" + EncryptionElementID;

            // Add the DataReference to the EncryptedKey.
            ek.AddReference(dRef);
            // Add the encrypted key to the
            // EncryptedData object.

            edElement.KeyInfo.AddClause(new KeyInfoEncryptedKey(ek));
            // Set the KeyInfo element to specify the
            // name of the RSA key.

            // Create a new KeyInfo element.
            edElement.KeyInfo = new KeyInfo();

            // Create a new KeyInfoName element.
            KeyInfoName kin = new KeyInfoName();

            // Specify a name for the key.
            kin.Value = KeyName;

            // Add the KeyInfoName element to the
            // EncryptedKey object.
            ek.KeyInfo.AddClause(kin);
            // Add the encrypted element data to the
            // EncryptedData object.
            edElement.CipherData.CipherValue = encryptedElement;
            ////////////////////////////////////////////////////
            // Replace the element from the original XmlDocument
            // object with the EncryptedData element.
            ////////////////////////////////////////////////////
            EncryptedXml.ReplaceElement(elementToEncrypt, edElement, false);
        }
        catch(Exception e)
        {
            // re-throw the exception.
            throw e;
        }
        finally
        {
            if (sessionKey != null)
            {
                sessionKey.Clear();
            }

        }

    }

}

Dieses Beispiel setzt voraus, dass eine Datei mit dem Namen "test.xml" im gleichen Verzeichnis wie das kompilierte Programm vorhanden ist. Vorausgesetzt wird auch, dass "test.xml" ein "creditcard"-Element enthält. Sie können die folgende XML in eine Datei mit dem Namen test.xml einfügen und mit diesem Beispiel verwenden.

<root>
    <creditcard>
        <number>19834209</number>
        <expiry>02/02/2002</expiry>
    </creditcard>
</root>

Kompilieren des Codes

• Um dieses Beispiel zu kompilieren, müssen Sie einen Verweis auf System.Security.dll einfügen.

• Fügen Sie die folgenden Namespaces hinzu: System.Xml, System.Security.Cryptography und System.Security.Cryptography.Xml.

Sicherheit

Speichern Sie einen symmetrischen, kryptografischen Schlüssel nie im Nur-Text-Format, bzw. übertragen Sie einen symmetrischen Schlüssel nie im Nur-Text-Format zwischen Computern. Speichern oder Übertragen Sie außerdem den privaten Schlüssel eines asymmetrischen Schlüsselpaars nie im Nur-Text-Format. Weitere Informationen über symmetrische und asymmetrische, kryptografische Schlüssel finden Sie unter Erzeugen von Schlüsseln für die Ver- und Entschlüsselung.

Betten Sie einen Schlüssel nie direkt in den Quellcode ein. Eingebettete Schlüssel können problemlos aus einer Assembly mithilfe von MSIL Disassembler-Tool (Ildasm.exe) oder durch Öffnen der Assembly in einem Text-Editor wie Windows Editor gelesen werden.

Wenn Sie einen kryptografischen Schlüssel nicht mehr benötigen, entfernen Sie ihn aus dem Speicher, indem Sie jedes Byte auf 0 (null) festlegen, oder indem Sie die Clear-Methode der verwalteten Kryptografieklasse aufrufen. Kryptografische Schlüssel können manchmal von einem Debugger aus dem Speicher oder einer Festplatte gelesen werden, falls der Speicherort auf dem Datenträger ausgelagert wurde.

Siehe auch

Aufgaben

Gewusst wie: Entschlüsseln von XML-Elementen mit asymmetrischen Schlüsseln

Referenz

System.Security.Cryptography.Xml

Weitere Ressourcen

XML-Verschlüsselung und digitale Signaturen