Como: Criptografar elementos XML com chaves assimétricas

Você pode usar as classes de System.Security.Cryptography.Xml o namespace para criptografar um elemento dentro de um documento XML. Criptografia XML é uma maneira padrão de troca ou armazena os dados criptografados de XML, sem se preocupar sobre os dados que está sendo lidos facilmente. Para obter mais informações sobre o padrão de criptografia XML, consulte que a especificação de World Wide Web Consortium (W3C) para criptografia XML localizado em http://www.w3.org/TR/xmldsig-core/.

Você pode usar a criptografia XML para substituir qualquer elemento XML ou documento com um <EncryptedData> elemento que contém os dados criptografados do XML. O <EncryptedData> elemento também pode conter elementos sub que incluem informações sobre as chaves e os processos usados durante a criptografia. Criptografia XML permite que um documento contêm vários elementos criptografados e permite que um elemento a ser criptografado várias vezes. O exemplo de código neste procedimento mostra como criar um <EncryptedData> elemento juntamente com vários outros elementos de sub que você pode usar mais tarde durante a descriptografia.

Este exemplo criptografa um elemento XML usando duas chaves. Ele gera um par de chaves pública/privada RSA e salva o par de chaves para um recipiente de chave seguro. O exemplo cria uma chave de sessão separada usando o algoritmo de criptografia (AES), também chamado algoritmo Rijndael. O exemplo usa a chave de sessão AES para criptografar o documento XML e, em seguida, usa a chave pública RSA para criptografar a chave de sessão AES. Finalmente, o exemplo salva a chave de sessão criptografada AES e os dados criptografados do XML ao documento XML dentro de um novo <EncryptedData> elemento.

Para descriptografar o elemento XML, recuperar a chave particular de RSA do recipiente da chave, use-o para descriptografar a chave de sessão e use a chave de sessão para descriptografar o documento. Para obter mais informações sobre como descriptografar um elemento XML que foi criptografado usando este procedimento, consulte Como: Decrypt elementos XML com teclas Asymmetric.

Este exemplo é apropriado para situações em que vários aplicativos precisam compartilhar dados criptografados ou onde um aplicativo precisa salvar os dados criptografados entre as horas que ele é executado.

Para criptografar um elemento XML com uma chave assimétrica

1. Criar um CspParameters de objeto e especifique o nome do contêiner de chave.

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

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

2. Gerar um simétrica chave usando o RSACryptoServiceProvider classe. A chave é salvo automaticamente para o recipiente de chave quando você passar o CspParameters o objeto para o construtor da RSACryptoServiceProvider classe. Essa chave será usada para criptografar a chave de sessão AES e pode ser recuperada posteriormente descriptografá-lo.

   Dim rsaKey As New RSACryptoServiceProvider(cspParams)
   

   RSACryptoServiceProvider rsaKey = new RSACryptoServiceProvider(cspParams);
   

3. Criar um XmlDocument objeto carregando um arquivo XML a partir do disco. O XmlDocument objeto contém o elemento XML para criptografar.

   ' 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. Localizar o elemento especificado na XmlDocument de objeto e criar um novo XmlElement o objeto para representar o elemento que você deseja criptografar. Neste exemplo, o "creditcard" elemento está criptografado.

   Dim elementToEncrypt As XmlElement = Doc.GetElementsByTagName(EncryptionElement)(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. Criar uma chave de sessão de novo usando o RijndaelManaged classe. Essa chave será criptografar o elemento XML e em seguida, criptografada propriamente dito e colocada no documento XML.

   ' 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. Criar uma nova instância de EncryptedXml de classe e usá-la para criptografar o elemento especificado usando a chave de sessão. O EncryptData método retorna o elemento criptografado como uma matriz de bytes criptografados.

   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. Construir um EncryptedData de objeto e preenchê-lo com o identificador de URL do elemento criptografado do XML. Esse identificador de URL permite uma festa de descriptografia sabe que o XML contém um elemento criptografado. Você pode usar o XmlEncElementUrl campo para especificar o identificador de URL. O elemento XML de texto sem formatação será substituído por um <EncryptedData> elemento encapsulado por isso EncryptedData objeto.

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

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

8. Criar um EncryptionMethod objeto que é inicializado para o identificador de URL do algoritmo de criptografia usado para gerar a chave de sessão. Passar o EncryptionMethod o objeto para o EncryptionMethod propriedade.

   edElement.EncryptionMethod = New EncryptionMethod(EncryptedXml.XmlEncAES256Url)
   

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

9. Criar um EncryptedKey o objeto para conter a chave de sessão criptografada. Criptografar a chave de sessão, adicioná-lo para o EncryptedKey object e digite um nome de chave de sessão e o identificador de chave URL.

   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. Criar uma nova DataReference objeto que mapeia os dados criptografados em uma chave de sessão específica. Esta etapa opcional permite que você especifique facilmente que várias partes de um documento XML foram criptografados por uma única chave.

    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. Adicionar a chave criptografada para o EncryptedData objeto.

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

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

12. Criar uma nova KeyInfo o objeto para especificar o nome da chave RSA. Adicioná-lo para o EncryptedData objeto. Isso ajuda a festa descriptografando a identificar a chave assimétrica correta a ser usada ao descriptografar a chave de sessão.

    ' 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 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. Adicionar os dados criptografados de elemento para o EncryptedData objeto.

    edElement.CipherData.CipherValue = encryptedElement
    

    edElement.CipherData.CipherValue = encryptedElement;
    

14. Substituir o elemento do original XmlDocument de objeto com o EncryptedData elemento.

    EncryptedXml.ReplaceElement(elementToEncrypt, edElement, False)
    

    EncryptedXml.ReplaceElement(elementToEncrypt, edElement, false);
    

15. Salve o XmlDocument objeto.

    xmlDoc.Save("test.xml")
    

    xmlDoc.Save("test.xml");
    

Exemplo

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



Class Program

    Shared 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)
            Decrypt(xmlDoc, rsaKey, "rsaKey")
            xmlDoc.Save("test.xml")
            ' Display the encrypted XML to the console.
            Console.WriteLine()
            Console.WriteLine("Decrypted 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 'Main


    Public Shared Sub Encrypt(ByVal Doc As XmlDocument, ByVal EncryptionElement 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 EncryptionElement Is Nothing Then
            Throw New ArgumentNullException("EncryptionElement")
        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(EncryptionElement)(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 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 'Encrypt



    Public Shared Sub Decrypt(ByVal Doc As XmlDocument, ByVal Alg As RSA, ByVal KeyName As String)
        ' Check the arguments.  
        If Doc Is Nothing Then
            Throw New ArgumentNullException("Doc")
        End If
        If Alg Is Nothing Then
            Throw New ArgumentNullException("Alg")
        End If
        If KeyName Is Nothing Then
            Throw New ArgumentNullException("KeyName")
        End If
        ' Create a new EncryptedXml object.
        Dim exml As New EncryptedXml(Doc)

        ' Add a key-name mapping.
        ' This method can only decrypt documents
        ' that present the specified key name.
        exml.AddKeyNameMapping(KeyName, Alg)

        ' Decrypt the element.
        exml.DecryptDocument()

    End Sub 'Decrypt 
End Class 'Program

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);
            Decrypt(xmlDoc, rsaKey, "rsaKey");
            xmlDoc.Save("test.xml");
            // Display the encrypted XML to the console.
            Console.WriteLine();
            Console.WriteLine("Decrypted 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 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();
            }

        }

    }

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

        // Create a new EncryptedXml object.
        EncryptedXml exml = new EncryptedXml(Doc);

        // Add a key-name mapping.
        // This method can only decrypt documents
        // that present the specified key name.
        exml.AddKeyNameMapping(KeyName, Alg);

        // Decrypt the element.
        exml.DecryptDocument();

    }

}

Este exemplo assume que um arquivo chamado "test.xml" existe no mesmo diretório que o programa compilado. Ele também pressupõe que "test.xml" contém um "creditcard" elemento. Você pode colocar o XML a seguir em um arquivo denominado test.xml e usá-lo com este exemplo.

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

Compilando o código

• Para compilar este exemplo, você precisa incluir uma referência a System.Security.dll.

• Incluem os seguintes namespaces: System.Xml, System.Security.Cryptography, and System.Security.Cryptography.Xml.

Segurança

Nunca armazene uma chave de criptografia simétrica em texto sem formatação ou transferir uma chave simétrica entre máquinas em texto sem formatação. Além disso, nunca armazene ou transferir a chave particular de um par de chaves assimétricas em texto sem formatação. Para obter mais informações sobre chaves de criptografia simétricas e assimétricas, consulte A geração de chaves de criptografia e descriptografia.

Nunca incorpore uma chave diretamente em seu código-fonte. Chaves incorporadas podem ser facilmente lidas a partir de um assembly usando o Ildasm. exe (desmontador MSIL) ou abrindo o assembly em um editor de texto como o bloco de notas.

Quando você terminar usando uma chave criptográfica, desmarcá-la da memória, definindo cada byte para zero ou chamando o Clear o método da classe de criptografia gerenciadas. Às vezes, as chaves criptográficas podem ser lido da memória por um depurador ou ler a partir de um disco rígido se o local da memória é paginado para disco.

Consulte também

Tarefas

Como: Decrypt elementos XML com teclas Asymmetric

Referência

System.Security.Cryptography.Xml

Outros recursos

Criptografia XML e assinaturas digitais