Ler em inglês

Partilhar via


SignedXml Classe

Definição

Fornece um wrapper em um objeto de assinatura do núcleo XML para facilitar a criação de assinaturas de XML.

public class SignedXml
Herança
SignedXml

Exemplos

O exemplo de código a seguir mostra como assinar e verificar um documento XML inteiro usando uma assinatura em envelope.

//
// This example signs an XML file using an
// envelope signature. It then verifies the 
// signed XML.
//
using System;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Security.Cryptography.Xml;
using System.Text;
using System.Xml;

public class SignVerifyEnvelope
{

    public static void Main(String[] args)
    {
        try
        {
           // Generate a signing key.
           RSA Key = RSA.Create();

           // Create an XML file to sign.
           CreateSomeXml("Example.xml");
           Console.WriteLine("New XML file created."); 

           // Sign the XML that was just created and save it in a 
           // new file.
           SignXmlFile("Example.xml", "signedExample.xml", Key);
           Console.WriteLine("XML file signed."); 

           // Verify the signature of the signed XML.
           Console.WriteLine("Verifying signature...");
           bool result = VerifyXmlFile("SignedExample.xml", Key);

           // Display the results of the signature verification to 
           // the console.
           if(result)
           {
               Console.WriteLine("The XML signature is valid.");
           }
           else
           {
            Console.WriteLine("The XML signature is not valid.");
           }
        }
        catch(CryptographicException e)
        {
            Console.WriteLine(e.Message);
        }
    }

    // Sign an XML file and save the signature in a new file. This method does not  
    // save the public key within the XML file.  This file cannot be verified unless  
    // the verifying code has the key with which it was signed.
    public static void SignXmlFile(string FileName, string SignedFileName, RSA Key)
    {
        // Create a new XML document.
        XmlDocument doc = new XmlDocument();

        // Load the passed XML file using its name.
        doc.Load(new XmlTextReader(FileName));

        // Create a SignedXml object.
        SignedXml signedXml = new SignedXml(doc);

        // Add the key to the SignedXml document. 
        signedXml.SigningKey = Key;

        // Create a reference to be signed.
        Reference reference = new Reference();
        reference.Uri = "";

        // Add an enveloped transformation to the reference.
        XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform();
        reference.AddTransform(env);

        // Add the reference to the SignedXml object.
        signedXml.AddReference(reference);

        // Compute the signature.
        signedXml.ComputeSignature();

        // Get the XML representation of the signature and save
        // it to an XmlElement object.
        XmlElement xmlDigitalSignature = signedXml.GetXml();

        // Append the element to the XML document.
        doc.DocumentElement.AppendChild(doc.ImportNode(xmlDigitalSignature, true));
        
        if (doc.FirstChild is XmlDeclaration)  
        {
            doc.RemoveChild(doc.FirstChild);
        }

        // Save the signed XML document to a file specified
        // using the passed string.
        XmlTextWriter xmltw = new XmlTextWriter(SignedFileName, new UTF8Encoding(false));
        doc.WriteTo(xmltw);
        xmltw.Close();
    }

    // Verify the signature of an XML file against an asymmetric 
    // algorithm and return the result.
    public static Boolean VerifyXmlFile(String Name, RSA Key)
    {
        // Create a new XML document.
        XmlDocument xmlDocument = new XmlDocument();

        // Load the passed XML file into the document. 
        xmlDocument.Load(Name);

        // Create a new SignedXml object and pass it
        // the XML document class.
        SignedXml signedXml = new SignedXml(xmlDocument);

        // Find the "Signature" node and create a new
        // XmlNodeList object.
        XmlNodeList nodeList = xmlDocument.GetElementsByTagName("Signature");

        // Load the signature node.
        signedXml.LoadXml((XmlElement)nodeList[0]);

        // Check the signature and return the result.
        return signedXml.CheckSignature(Key);
    }

    // Create example data to sign.
    public static void CreateSomeXml(string FileName)
    {
        // Create a new XmlDocument object.
        XmlDocument document = new XmlDocument();

        // Create a new XmlNode object.
        XmlNode  node = document.CreateNode(XmlNodeType.Element, "", "MyElement", "samples");
        
        // Add some text to the node.
        node.InnerText = "Example text to be signed.";

        // Append the node to the document.
        document.AppendChild(node);

        // Save the XML document to the file name specified.
        XmlTextWriter xmltw = new XmlTextWriter(FileName, new UTF8Encoding(false));
        document.WriteTo(xmltw);
        xmltw.Close();
    }
}

O exemplo de código a seguir mostra como assinar e verificar um único elemento de um documento XML usando uma assinatura envolvente.

//
// This example signs an XML file using an
// envelope signature. It then verifies the
// signed XML.
//
using System;
using System.Security.Cryptography;
using System.Security.Cryptography.Xml;
using System.Text;
using System.Xml;

public class SignVerifyEnvelope
{

    public static void Main(String[] args)
    {
        // Generate a signing key.
       RSA Key = RSA.Create();

       try
       {
           // Specify an element to sign.
           string[] elements =  { "#tag1" };

           // Sign an XML file and save the signature to a
           // new file.
           SignXmlFile("Test.xml", "SignedExample.xml", Key, elements);
           Console.WriteLine("XML file signed.");

           // Verify the signature of the signed XML.
           Console.WriteLine("Verifying signature...");

           bool result = VerifyXmlFile("SignedExample.xml");

           // Display the results of the signature verification to
           // the console.
           if (result)
           {
               Console.WriteLine("The XML signature is valid.");
           }
           else
           {
               Console.WriteLine("The XML signature is not valid.");
           }
       }
       catch (CryptographicException e)
       {
           Console.WriteLine(e.Message);
       }
       finally
       {
           // Clear resources associated with the
           // RSA instance.
           Key.Clear();
       }
   }

    // Sign an XML file and save the signature in a new file.
    public static void SignXmlFile(string FileName, string SignedFileName, RSA Key, string[] ElementsToSign)
    {
        // Check the arguments.
        if (FileName == null)
            throw new ArgumentNullException("FileName");
        if (SignedFileName == null)
            throw new ArgumentNullException("SignedFileName");
        if (Key == null)
            throw new ArgumentNullException("Key");
        if (ElementsToSign == null)
            throw new ArgumentNullException("ElementsToSign");

        // Create a new XML document.
        XmlDocument doc = new XmlDocument();

        // Format the document to ignore white spaces.
        doc.PreserveWhitespace = false;

        // Load the passed XML file using it's name.
        doc.Load(new XmlTextReader(FileName));

        // Create a SignedXml object.
        SignedXml signedXml = new SignedXml(doc);

        // Add the key to the SignedXml document.
        signedXml.SigningKey = Key;

        // Loop through each passed element to sign
        // and create a reference.
        foreach (string s in ElementsToSign)
        {
            // Create a reference to be signed.
            Reference reference = new Reference();
            reference.Uri = s;

            // Add an enveloped transformation to the reference.
            XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform();
            reference.AddTransform(env);

            // Add the reference to the SignedXml object.
            signedXml.AddReference(reference);
        }

        // Add an RSAKeyValue KeyInfo (optional; helps recipient find key to validate).
        KeyInfo keyInfo = new KeyInfo();
        keyInfo.AddClause(new RSAKeyValue((RSA)Key));
        signedXml.KeyInfo = keyInfo;

        // Compute the signature.
        signedXml.ComputeSignature();

        // Get the XML representation of the signature and save
        // it to an XmlElement object.
        XmlElement xmlDigitalSignature = signedXml.GetXml();

        // Append the element to the XML document.
        doc.DocumentElement.AppendChild(doc.ImportNode(xmlDigitalSignature, true));

        if (doc.FirstChild is XmlDeclaration)
        {
            doc.RemoveChild(doc.FirstChild);
        }

        // Save the signed XML document to a file specified
        // using the passed string.
        XmlTextWriter xmltw = new XmlTextWriter(SignedFileName, new UTF8Encoding(false));
        doc.WriteTo(xmltw);
        xmltw.Close();
    }
    // Verify the signature of an XML file and return the result.
    public static Boolean VerifyXmlFile(String Name)
    {
        // Check the arguments.
        if (Name == null)
            throw new ArgumentNullException("Name");

        // Create a new XML document.
        XmlDocument xmlDocument = new XmlDocument();

        // Format using white spaces.
        xmlDocument.PreserveWhitespace = true;

        // Load the passed XML file into the document.
        xmlDocument.Load(Name);

        // Create a new SignedXml object and pass it
        // the XML document class.
        SignedXml signedXml = new SignedXml(xmlDocument);

        // Find the "Signature" node and create a new
        // XmlNodeList object.
        XmlNodeList nodeList = xmlDocument.GetElementsByTagName("Signature");

        // Load the signature node.
        signedXml.LoadXml((XmlElement)nodeList[0]);

        // Check the signature and return the result.
        return signedXml.CheckSignature();
    }
}

Comentários

Para obter mais informações sobre essa API, consulte Comentários da API complementar para SignedXml.

Construtores

SignedXml()

Inicializa uma nova instância da classe SignedXml.

SignedXml(XmlDocument)

Inicializa uma nova instância da classe SignedXml do documento XML especificado.

SignedXml(XmlElement)

Inicializa uma nova instância da classe SignedXml do objeto XmlElement especificado.

Campos

m_signature

Representa o objeto Signature do objeto SignedXml atual.

m_strSigningKeyName

Representa o nome da chave instalada a ser usada para assinar o objeto SignedXml.

XmlDecryptionTransformUrl

Representa o URI (Uniform Resource Identifier) da transformação de descriptografia do modo XML. Este campo é constante.

XmlDsigBase64TransformUrl

Representa o URI (Uniform Resource Identifier) da transformação de base 64. Este campo é constante.

XmlDsigC14NTransformUrl

Representa o URI (Uniform Resource Identifier) para a transformação XML canônica. Este campo é constante.

XmlDsigC14NWithCommentsTransformUrl

Representa o URI (Uniform Resource Identifier) da transformação XML canônica, com comentários. Este campo é constante.

XmlDsigCanonicalizationUrl

Representa o URI (Uniform Resource Identifier) do algoritmo de canonicalização padrão para assinaturas digitais XML. Este campo é constante.

XmlDsigCanonicalizationWithCommentsUrl

Representa o URI (Uniform Resource Identifier) do algoritmo de canonização padrão para assinaturas digitais XML e inclui comentários. Este campo é constante.

XmlDsigDSAUrl

Representa o URI (Uniform Resource Identifier) do algoritmo de DSA padrão para assinaturas digitais XML. Este campo é constante.

XmlDsigEnvelopedSignatureTransformUrl

Representa o URI (Uniform Resource Identifier) da transformação de assinatura envelopada. Este campo é constante.

XmlDsigExcC14NTransformUrl

Representa o URI (Uniform Resource Identifier) para a conversão em formato canônico exclusiva do XML. Este campo é constante.

XmlDsigExcC14NWithCommentsTransformUrl

Representa o URI (Uniform Resource Identifier) da canonicalização XML exclusiva, com comentários. Este campo é constante.

XmlDsigHMACSHA1Url

Representa o URI (Uniform Resource Identifier) do algoritmo de HMACSHA1 padrão para assinaturas digitais XML. Este campo é constante.

XmlDsigMinimalCanonicalizationUrl

Representa o URI (Uniform Resource Identifier) do algoritmo mínimo de canonicalização padrão para assinaturas digitais XML. Este campo é constante.

XmlDsigNamespaceUrl

Representa o URI (Uniform Resource Identifier) do algoritmo de namespace padrão para assinaturas digitais XML. Este campo é constante.

XmlDsigRSASHA1Url

Representa o URI (Uniform Resource Identifier) do método de assinatura RSA padrão para assinaturas digitais XML. Este campo é constante.

XmlDsigRSASHA256Url

Representa o URI (Uniform Resource Identifier) para a variação do RSA método de assinatura SHA-256 para assinaturas digitais XML. Este campo é constante.

XmlDsigRSASHA384Url

Representa o URI (Uniform Resource Identifier) para a variação do RSA método de assinatura SHA-384 para assinaturas digitais XML. Este campo é constante.

XmlDsigRSASHA512Url

Representa o URI (Uniform Resource Identifier) para a variação do RSA método de assinatura SHA-512 para assinaturas digitais XML. Este campo é constante.

XmlDsigSHA1Url

Representa o URI (Uniform Resource Identifier) do método de resumo SHA1 padrão para assinaturas digitais XML. Este campo é constante.

XmlDsigSHA256Url

Representa o URI (Uniform Resource Identifier) do método de resumo SHA256 padrão para assinaturas digitais XML. Este campo é constante.

XmlDsigSHA384Url

Representa o URI (Uniform Resource Identifier) do método de resumo SHA384 padrão para assinaturas digitais XML. Este campo é constante.

XmlDsigSHA512Url

Representa o URI (Uniform Resource Identifier) do método de resumo SHA512 padrão para assinaturas digitais XML. Este campo é constante.

XmlDsigXPathTransformUrl

Representa o URI (Uniform Resource Identifier) do XPath (Linguagem XML). Este campo é constante.

XmlDsigXsltTransformUrl

Representa o URI (Uniform Resource Identifier) de transformações XSLT. Este campo é constante.

XmlLicenseTransformUrl

Representa o URI (Uniform Resource Identifier) do algoritmo de transformação de licença usado para normalizar licenças XrML para assinaturas.

Propriedades

EncryptedXml

Obtém ou define um objeto EncryptedXml que define as regras de processamento de criptografia XML.

KeyInfo

Obtém ou define o objeto KeyInfo do objeto SignedXml atual.

Resolver

Define o objeto XmlResolver atual.

SafeCanonicalizationMethods

Obtém os nomes dos métodos cujos algoritmos de canonicalização são explicitamente permitidos.

Signature

Obtém o objeto Signature do objeto SignedXml atual.

SignatureFormatValidator

Obtém um delegado que será chamado para validar o formato (não a segurança criptográfica) de uma assinatura XML.

SignatureLength

Obtém o comprimento da assinatura do objeto SignedXml atual.

SignatureMethod

Obtém o método de assinatura do objeto SignedXml atual.

SignatureValue

Obtém o valor de assinatura do objeto SignedXml atual.

SignedInfo

Obtém o objeto SignedInfo do objeto SignedXml atual.

SigningKey

Obtém ou define a chave de algoritmo assimétrico usada para assinar um objeto SignedXml.

SigningKeyName

Obtém ou define o nome da chave instalada a ser usada para assinar o objeto SignedXml.

Métodos

AddObject(DataObject)

Adiciona um objeto DataObject à lista de objetos a serem assinados.

AddReference(Reference)

Adiciona um objeto Reference ao objeto SignedXml que descreve um método de resumo, o valor de resumo e a transformação a ser usada para criar uma assinatura digital XML.

CheckSignature()

Determina se a propriedade Signature é verificada usando a chave pública na assinatura.

CheckSignature(AsymmetricAlgorithm)

Determina se a propriedade Signature verifica se a chave especificada existe.

CheckSignature(KeyedHashAlgorithm)

Determina se a propriedade Signature é verificada em relação ao algoritmo MAC (Message Authentication Code) especificado.

CheckSignature(X509Certificate2, Boolean)

Determina se a propriedade Signature verifica o objeto X509Certificate2 especificado e, opcionalmente, se o certificado é válido.

CheckSignatureReturningKey(AsymmetricAlgorithm)

Determina se a propriedade Signature é verificada usando a chave pública na assinatura.

ComputeSignature()

Calcula uma assinatura digital XML.

ComputeSignature(KeyedHashAlgorithm)

Calcula uma assinatura digital XML usando o algoritmo MAC (Message Authentication Code) especificado.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetIdElement(XmlDocument, String)

Retorna o objeto XmlElement com a ID especificada do objeto XmlDocument especificado.

GetPublicKey()

Retorna a chave pública de uma assinatura.

GetType()

Obtém o Type da instância atual.

(Herdado de Object)
GetXml()

Retorna a representação XML de um objeto SignedXml.

LoadXml(XmlElement)

Carrega um estado SignedXml de um elemento XML.

MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)

Aplica-se a

Produto Versões
.NET 8 (package-provided), 9 (package-provided)
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7 (package-provided), 4.7, 4.7.1 (package-provided), 4.7.1, 4.7.2 (package-provided), 4.7.2, 4.8 (package-provided), 4.8, 4.8.1
.NET Standard 2.0 (package-provided)
Windows Desktop 3.0, 3.1, 5, 6, 7, 8, 9

Confira também