Criptografar elementos XML com chaves assimétricas

Você pode usar as classes no namespace System.Security.Cryptography.Xml para criptografar um elemento em um documento XML. A Criptografia XML é uma maneira padrão de trocar ou armazenar dados XML criptografados, sem se preocupar com a facilidade de leitura dos dados. Para obter mais informações sobre o padrão de Criptografia XML, consulte a especificação World Wide Web Consortium (W3C) para Criptografia XML localizada em https://www.w3.org/TR/xmldsig-core/.

Você pode usar a Criptografia XML para substituir qualquer elemento ou documento XML por um elemento <EncryptedData> que contenha os dados XML criptografados. O elemento <EncryptedData> também pode conter subelementos que incluem informações sobre as chaves e processos usados durante a criptografia. A Criptografia XML permite que um documento contenha vários elementos criptografados e permite que um elemento seja criptografado várias vezes. O exemplo de código neste procedimento mostra como criar um elemento <EncryptedData> junto com vários outros subelementos que você pode usar posteriormente 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 em um contêiner de chave segura. O exemplo cria uma chave de sessão separada usando o algoritmo Advanced Encryption Standard (AES). 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. Por fim, o exemplo salva a chave de sessão AES criptografada e os dados XML criptografados no documento XML em um novo elemento <EncryptedData>.

Para descriptografar o elemento XML, você recupera a chave privada RSA do contêiner de chaves, usa-a para descriptografar a chave de sessão e, em seguida, usa 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: descriptografar elementos XML com chaves assimétricas.

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

Para criptografar um elemento XML com uma chave assimétrica

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

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

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

2. Gere uma chave assimétrica usando a classe RSACryptoServiceProvider. A chave é salva automaticamente no contêiner de chaves quando você passa o objeto CspParameters para o construtor da classe RSACryptoServiceProvider. Essa chave será usada para criptografar a chave de sessão AES e pode ser recuperada posteriormente para descriptografá-la.

   RSACryptoServiceProvider rsaKey = new RSACryptoServiceProvider(cspParams);
   

   Dim rsaKey As New RSACryptoServiceProvider(cspParams)
   

3. Crie um objeto XmlDocument carregando um arquivo XML do disco. O objeto XmlDocument contém o elemento XML a ser criptografado.

   // 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 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
   

4. Encontre o elemento especificado no objeto XmlDocument e crie um novo objeto XmlElement para representar o elemento que você deseja criptografar. Neste exemplo, o elemento "creditcard" é criptografado.

   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");
   }
   

   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
   

5. Crie uma nova chave de sessão usando a classe Aes. Essa chave criptografará o elemento XML e, em seguida, será criptografada e colocada no documento XML.

   // Create an AES key.
   sessionKey = Aes.Create();
   

   ' Create an AES key.
   sessionKey = Aes.Create()
   

6. Crie uma nova instância da classe EncryptedXml e use-a para criptografar o elemento especificado usando a chave de sessão. O método EncryptData retorna o elemento criptografado como uma matriz de bytes criptografados.

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

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

7. Construa um objeto EncryptedData e preencha-o com o identificador de URL do elemento XML criptografado. Esse identificador de URL permite que uma parte descriptografada saiba que o XML contém um elemento criptografado. Você pode usar o campo XmlEncElementUrl para especificar o identificador de URL. O elemento XML de texto simples será substituído por um elemento <EncryptedData> encapsulado por este objeto EncryptedData.

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

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

8. Crie um objeto EncryptionMethod que seja inicializado com o identificador de URL do algoritmo criptográfico usado para gerar a chave de sessão. Passe o objeto EncryptionMethod para a propriedade EncryptionMethod.

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

   edElement.EncryptionMethod = New EncryptionMethod(EncryptedXml.XmlEncAES256Url)
   

9. Crie um objeto EncryptedKey para conter a chave de sessão criptografada. Criptografe a chave de sessão, adicione-a ao objeto EncryptedKey e insira um nome de chave de sessão e um URL de identificador de chave.

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

   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)
   

10. Crie um novo objeto DataReference que mapeie os dados criptografados para uma chave de sessão específica. Essa etapa opcional permite especificar facilmente que várias partes de um documento XML foram criptografadas por uma única chave.

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

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

11. Adicione a chave criptografada ao objeto EncryptedData.

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

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

12. Crie um novo objeto KeyInfo para especificar o nome da chave RSA. Adicione-o ao objeto EncryptedData. Isso ajuda a parte descriptografadora a identificar a chave assimétrica correta a ser usada ao descriptografar a chave de sessão.

    
    // 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);
    

    ' 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)
    

13. Adicione os dados do elemento criptografado ao objeto EncryptedData.

    edElement.CipherData.CipherValue = encryptedElement;
    

    edElement.CipherData.CipherValue = encryptedElement
    

14. Substitua o elemento do objeto XmlDocument original pelo elemento EncryptedData.

    EncryptedXml.ReplaceElement(elementToEncrypt, edElement, false);
    

    EncryptedXml.ReplaceElement(elementToEncrypt, edElement, False)
    

15. Salve o objeto XmlDocument.

    xmlDoc.Save("test.xml");
    

    xmlDoc.Save("test.xml")
    

Exemplo

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

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

using System;
using System.Xml;
using System.Security.Cryptography;
using System.Security.Cryptography.Xml;
using System.Runtime.Versioning;

[SupportedOSPlatform("windows")]
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 encrypted 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 XmlElement 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");
        }
        Aes? 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 an AES key.
            sessionKey = Aes.Create();

            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);
        }
        finally
        {
            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();
    }
}

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 encrypted 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


    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.
        ArgumentNullException.ThrowIfNull(Doc)
        ArgumentNullException.ThrowIfNull(EncryptionElement)
        ArgumentNullException.ThrowIfNull(EncryptionElementID)
        ArgumentNullException.ThrowIfNull(Alg)
        ArgumentNullException.ThrowIfNull(KeyName)
        '//////////////////////////////////////////////
        ' Find the specified element in the XmlDocument
        ' object and create a new XmlElement 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 Aes = 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 an AES key.
            sessionKey = Aes.Create()
            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
        Finally
            If Not (sessionKey Is Nothing) Then
                sessionKey.Clear()
            End If
        End Try

    End Sub



    Public Shared Sub Decrypt(ByVal Doc As XmlDocument, ByVal Alg As RSA, ByVal KeyName As String)
        ' Check the arguments.
        ArgumentNullException.ThrowIfNull(Doc)
        ArgumentNullException.ThrowIfNull(Alg)
        ArgumentNullException.ThrowIfNull(KeyName)
        ' 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
End Class

Compilando o código

• Em um projeto que tem como destino o .NET Framework, inclua uma referência a System.Security.dll.
• Em um projeto direcionado ao .NET Core ou ao .NET 5, instale o pacote NuGet System.Security.Cryptography.Xml.
• Inclua os seguintes namespaces: System.Xml, System.Security.Cryptography e System.Security.Cryptography.Xml.

Segurança do .NET

Nunca armazene uma chave criptográfica simétrica em texto simples ou transfira uma chave simétrica entre máquinas em texto simples. Além disso, nunca armazene nem transfira a chave privada de um par de chaves assimétricas em texto não criptografado. Para mais informações sobre chaves criptográficas simétricas e assimétricas, confira Como gerar chaves para criptografia e descriptografia.

Dica

Para desenvolvimento, use o Gerenciador de segredos para armazenamento seguro de segredos. Na produção, considere um produto como o Azure Key Vault.

Nunca incorpore uma chave diretamente em seu código-fonte. As chaves inseridas podem ser facilmente lidas de um assembly usando Ildasm.exe (Desmontador IL) ou abrindo o assembly em um editor de texto, como o Bloco de Notas.

Quando terminar de usar uma chave criptográfica, apague-a da memória definindo cada byte como zero ou chamando o método Clear da classe de criptografia gerenciada. Às vezes, as chaves criptográficas podem ser lidas da memória por um depurador ou lidas de um disco rígido se o local da memória for paginado em disco.

Confira também

• Modelo de criptografia
• Serviços criptográficos
• Criptografia multiplataforma- System.Security.Cryptography.Xml
• Como descriptografar elementos XML com chaves assimétricas
• Proteção de dados do ASP.NET Core