SignedXml Classe

Définition

Espace de noms:

System.Security.Cryptography.Xml

Assembly:

System.Security.Cryptography.Xml.dll

Source:

SignedXml.cs

Fournit un wrapper sur un objet de signature XML principal afin de faciliter la création de signatures XML.

C#

public class SignedXml

Héritage

Object

SignedXml

Exemples

L’exemple de code suivant montre comment signer et vérifier un document XML entier à l’aide d’une signature enveloppée.

C#

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

L’exemple de code suivant montre comment signer et vérifier un élément unique d’un document XML à l’aide d’une signature enveloppante.

C#

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

Remarques

Pour plus d’informations sur cette API, consultez Remarques supplémentaires sur l’API pour SignedXml.

Constructeurs

SignedXml()	Initialise une nouvelle instance de la classe SignedXml.
SignedXml(XmlDocument)	Initialise une nouvelle instance de la classe SignedXml à partir du document XML spécifié.
SignedXml(XmlElement)	Initialise une nouvelle instance de la classe SignedXml à partir de l'objet XmlElement spécifié.

Champs

m_signature	Représente l'objet Signature de l'objet SignedXml en cours.
m_strSigningKeyName	Représente le nom de la clé installée à utiliser pour signer l'objet SignedXml.
XmlDecryptionTransformUrl	Représente l'URI de la transformation du déchiffrement du mode XML. Ce champ est constant.
XmlDsigBase64TransformUrl	Représente l'URI de la transformation en base 64. Ce champ est constant.
XmlDsigC14NTransformUrl	Représente l'URI de la transformation XML canonique. Ce champ est constant.
XmlDsigC14NWithCommentsTransformUrl	Représente l'URI de la transformation XML canonique, avec des commentaires Ce champ est constant.
XmlDsigCanonicalizationUrl	Représente l'URI de l'algorithme de canonisation standard pour les signatures numériques XML. Ce champ est constant.
XmlDsigCanonicalizationWithCommentsUrl	Représente l'URI de l'algorithme de canonisation standard pour les signatures numériques XML. Il inclut des commentaires. Ce champ est constant.
XmlDsigDSAUrl	Représente l'URI de l'algorithme DSA standard pour les signatures numériques XML. Ce champ est constant.
XmlDsigEnvelopedSignatureTransformUrl	Représente l'URI de la transformation de signature enveloppée. Ce champ est constant.
XmlDsigExcC14NTransformUrl	Représente l'URI de la canonisation XML exclusive. Ce champ est constant.
XmlDsigExcC14NWithCommentsTransformUrl	Représente l'URI de la canonisation XML exclusive, avec des commentaires. Ce champ est constant.
XmlDsigHMACSHA1Url	Représente l'URI de l'algorithme HMACSHA1 standard pour les signatures numériques XML. Ce champ est constant.
XmlDsigMinimalCanonicalizationUrl	Représente l'URI de l'algorithme de canonisation minimal pour les signatures numériques XML. Ce champ est constant.
XmlDsigNamespaceUrl	Représente l'URI de l'espace de noms standard pour les signatures numériques XML. Ce champ est constant.
XmlDsigRSASHA1Url	Représente l'URI de la méthode de signature RSA standard pour les signatures numériques XML. Ce champ est constant.
XmlDsigRSASHA256Url	Représente l’URI (Uniform Resource Identifier) pour la RSA variante de méthode de signature SHA-256 pour les signatures numériques XML. Ce champ est constant.
XmlDsigRSASHA384Url	Représente l’URI (Uniform Resource Identifier) pour la RSA variante de méthode de signature SHA-384 pour les signatures numériques XML. Ce champ est constant.
XmlDsigRSASHA512Url	Représente l’URI (Uniform Resource Identifier) pour la RSA variante de méthode de signature SHA-512 pour les signatures numériques XML. Ce champ est constant.
XmlDsigSHA1Url	Représente l’URI (Uniform Resource Identifier) de la méthode digest SHA1 standard pour les signatures numériques XML. Ce champ est constant.
XmlDsigSHA256Url	Représente l’URI (Uniform Resource Identifier) de la méthode digest SHA256 standard pour les signatures numériques XML. Ce champ est constant.
XmlDsigSHA384Url	Représente l’URI (Uniform Resource Identifier) de la méthode digest SHA384 standard pour les signatures numériques XML. Ce champ est constant.
XmlDsigSHA512Url	Représente l’URI (Uniform Resource Identifier) de la méthode digest SHA512 standard pour les signatures numériques XML. Ce champ est constant.
XmlDsigXPathTransformUrl	Représente l'URI de XPath (XML Path Language). Ce champ est constant.
XmlDsigXsltTransformUrl	Représente l'URI des transformations XSLT. Ce champ est constant.
XmlLicenseTransformUrl	Représente l'URI de l'algorithme de transformation de licence utilisé pour normaliser les licences XrML pour signatures.

Propriétés

EncryptedXml	Obtient ou définit un objet EncryptedXml qui définit les règles de traitement du chiffrement XML.
KeyInfo	Obtient ou définit l'objet KeyInfo de l'objet SignedXml en cours.
Resolver	Définit l'objet XmlResolver en cours.
SafeCanonicalizationMethods	Obtient les noms des méthodes dont les algorithmes de canonisation sont explicitement autorisés.
Signature	Obtient l'objet Signature de l'objet SignedXml en cours.
SignatureFormatValidator	Obtient un délégué qui sera appelé pour valider le format (et non la sécurité de chiffrement) d'une signature XML.
SignatureLength	Obtient la longueur de la signature pour l'objet SignedXml actuel.
SignatureMethod	Obtient la méthode de signature de l'objet SignedXml actuel.
SignatureValue	Obtient la valeur de signature de l'objet SignedXml actuel.
SignedInfo	Obtient l'objet SignedInfo de l'objet SignedXml en cours.
SigningKey	Obtient ou définit la clé de l'algorithme asymétrique utilisée pour signer un objet SignedXml.
SigningKeyName	Obtient ou définit le nom de la clé installée à utiliser pour signer l'objet SignedXml.

Méthodes

AddObject(DataObject)	Ajoute un objet DataObject à la liste des objets à signer.
AddReference(Reference)	Ajoute un objet Reference à l'objet SignedXml qui décrit une méthode Digest, valeur Digest et transformation à utiliser pour créer une signature numérique XML.
CheckSignature()	Détermine si la propriété Signature est vérifiée comme valide avec la clé publique contenue dans la signature.
CheckSignature(AsymmetricAlgorithm)	Détermine si la propriété Signature est vérifiée comme valide pour la clé spécifiée.
CheckSignature(KeyedHashAlgorithm)	Détermine si la propriété Signature est vérifiée comme valide pour l'algorithme MAC (Message Authentication Code) spécifié.
CheckSignature(X509Certificate2, Boolean)	Détermine si la propriété Signature est vérifiée comme valide pour l'objet X509Certificate2 spécifié et, éventuellement, si le certificat est valide.
CheckSignatureReturningKey(AsymmetricAlgorithm)	Détermine si la propriété Signature est vérifiée comme valide avec la clé publique contenue dans la signature.
ComputeSignature()	Calcule une signature numérique XML.
ComputeSignature(KeyedHashAlgorithm)	Calcule une signature numérique XML en utilisant l'algorithme MAC spécifié.
GetIdElement(XmlDocument, String)	Retourne l'objet XmlElement avec l'ID spécifié à partir de l'objet XmlDocument spécifié.
GetPublicKey()	Retourne la clé publique d'une signature.
GetXml()	Retourne la représentation XML d'un objet SignedXml.
LoadXml(XmlElement)	Charge un état de SignedXml à partir d'un élément XML.

S’applique à

Voir aussi

• Meilleures pratiques relatives aux signatures XML