Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

SignedXml classe

 

Date de publication : août 2016

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

Espace de noms:   System.Security.Cryptography.Xml
Assembly:  System.Security (dans System.Security.dll)

System.Object
  System.Security.Cryptography.Xml.SignedXml

[HostProtectionAttribute(SecurityAction.LinkDemand, MayLeakOnAbort = true)]
public class SignedXml

NomDescription
System_CAPS_pubmethodSignedXml()

Initialise une nouvelle instance de la classe SignedXml.

System_CAPS_pubmethodSignedXml(XmlDocument)

Initialise une nouvelle instance de la SignedXml classe à partir du document XML spécifié.

System_CAPS_pubmethodSignedXml(XmlElement)

Initialise une nouvelle instance de la SignedXml classe spécifiés XmlElement objet.

NomDescription
System_CAPS_pubpropertyEncryptedXml

Obtient ou définit un EncryptedXml objet qui définit les règles de traitement du chiffrement XML.

System_CAPS_pubpropertyKeyInfo

Obtient ou définit le KeyInfo objet de l’utilisateur actuel SignedXml objet.

System_CAPS_pubpropertyResolver

Définit l’actuel XmlResolver objet.

System_CAPS_pubpropertySafeCanonicalizationMethods

[Pris en charge dans le .NET Framework 4.5.1 et versions ultérieures]

Obtient les noms des méthodes dont canonisation algorithmes sont explicitement autorisés.

System_CAPS_pubpropertySignature

Obtient le Signature objet de l’utilisateur actuel SignedXml objet.

System_CAPS_pubpropertySignatureFormatValidator

Obtient un délégué qui sera appelé pour valider le format (pas la sécurité de chiffrement) d’une signature XML.

System_CAPS_pubpropertySignatureLength

Obtient la longueur de la signature pour le SignedXml objet.

System_CAPS_pubpropertySignatureMethod

Obtient la méthode de signature de l’utilisateur actuel SignedXml objet.

System_CAPS_pubpropertySignatureValue

Obtient la valeur de la signature de l’utilisateur actuel SignedXml objet.

System_CAPS_pubpropertySignedInfo

Obtient le SignedInfo objet de l’utilisateur actuel SignedXml objet.

System_CAPS_pubpropertySigningKey

Obtient ou définit la clé de l’algorithme asymétrique utilisée pour signer un SignedXml objet.

System_CAPS_pubpropertySigningKeyName

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient ou définit le nom de la clé installée à utiliser pour signer le SignedXml objet.

NomDescription
System_CAPS_pubmethodAddObject(DataObject)

Ajoute un DataObject objet à la liste des objets à signer.

System_CAPS_pubmethodAddReference(Reference)

Ajoute un Reference de l’objet à le SignedXml objet qui décrit une méthode digest, valeur digest et transformation à utiliser pour la création d’une signature numérique XML.

System_CAPS_pubmethodCheckSignature()

Détermine si le Signature propriété vérifie à l’aide de la clé publique dans la signature.

System_CAPS_pubmethodCheckSignature(AsymmetricAlgorithm)

Détermine si le Signature propriété vérifie la clé spécifiée.

System_CAPS_pubmethodCheckSignature(KeyedHashAlgorithm)

Détermine si le Signature propriété vérifie pour l’algorithme spécifié message authentication code (MAC).

System_CAPS_pubmethodCheckSignature(X509Certificate2, Boolean)

Détermine si le Signature propriété vérifie spécifié X509Certificate2 objet et, éventuellement, si le certificat est valide.

System_CAPS_pubmethodCheckSignatureReturningKey(AsymmetricAlgorithm)

Détermine si le Signature propriété vérifie à l’aide de la clé publique dans la signature.

System_CAPS_pubmethodComputeSignature()

Calcule une signature numérique XML.

System_CAPS_pubmethodComputeSignature(KeyedHashAlgorithm)

Calcule une signature numérique XML à l’aide de l’algorithme spécifié message authentication code (MAC).

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodFinalize()

Autorise un objet à tenter de libérer des ressources et à exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par une opération garbage collection.(Hérité de Object.)

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetIdElement(XmlDocument, String)

Retourne le XmlElement objet avec l’ID spécifié à partir du spécifié XmlDocument objet.

System_CAPS_protmethodGetPublicKey()

Retourne la clé publique d’une signature.

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodGetXml()

Retourne la représentation XML d’un SignedXml objet.

System_CAPS_pubmethodLoadXml(XmlElement)

Charge un SignedXml l’état d’un élément XML.

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

NomDescription
System_CAPS_protfieldm_signature

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Représente le Signature objet de l’utilisateur actuel SignedXml objet.

System_CAPS_protfieldm_strSigningKeyName

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Représente le nom de la clé installée à utiliser pour signer le SignedXml objet.

System_CAPS_pubfieldSystem_CAPS_staticXmlDecryptionTransformUrl

Représente l’identificateur de ressource uniforme (URI) pour la transformation du déchiffrement du mode XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigBase64TransformUrl

Représente l’identificateur de ressource uniforme (URI) pour la transformation en base 64. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigC14NTransformUrl

Représente l’identificateur de ressource uniforme (URI) de la transformation XML canonique. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigC14NWithCommentsTransformUrl

Représente l’identificateur de ressource uniforme (URI) de la transformation XML canonique, avec des commentaires. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigCanonicalizationUrl

Représente l’identificateur de ressource uniforme (URI) de l’algorithme de canonisation standard pour les signatures numériques XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigCanonicalizationWithCommentsUrl

Représente l’identificateur de ressource uniforme (URI) de l’algorithme de canonisation standard pour les signatures numériques XML et inclut des commentaires. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigDSAUrl

Représente l’identificateur de ressource uniforme (URI) de la norme DSA algorithme pour les signatures numériques XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigEnvelopedSignatureTransformUrl

Représente l’identificateur de ressource uniforme (URI) pour la transformation de signature enveloppée. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigExcC14NTransformUrl

Représente l’identificateur de ressource uniforme (URI) de la canonisation XML exclusive. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigExcC14NWithCommentsTransformUrl

Représente l’identificateur de ressource uniforme (URI) de canonisation XML exclusive, avec commentaires. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigHMACSHA1Url

Représente l’identificateur de ressource uniforme (URI) de la norme HMACSHA1 algorithme pour les signatures numériques XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigMinimalCanonicalizationUrl

Représente l’identificateur de ressource uniforme (URI) de l’algorithme de canonisation minimal pour les signatures numériques XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigNamespaceUrl

Représente l’identificateur de ressource uniforme (URI) pour l’espace de noms standard pour les signatures numériques XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigRSASHA1Url

Représente l’identificateur de ressource uniforme (URI) de la norme RSA méthode de signature pour les signatures numériques XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigRSASHA256Url

Représente l’identificateur de ressource uniforme (URI) de la variation de méthode de signature SHA-256 RSA pour les signatures numériques XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigRSASHA384Url

Représente l’URI (Uniform Resource Identifier) de la variation de méthode de signature SHA-384 RSA pour les signatures numériques XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigRSASHA512Url

Représente l’identificateur de ressource uniforme (URI) de la variation de méthode de signature SHA-512 RSA pour les signatures numériques XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigSHA1Url

Représente l’identificateur de ressource uniforme (URI) de la norme SHA1 digest de méthode pour les signatures numériques XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigSHA256Url

Représente l’URI (Uniform Resource Identifier) de la méthode digest SHA256 standard pour les signatures numériques XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigSHA384Url

Représente l’URI (Uniform Resource Identifier) de la méthode digest SHA384 standard pour les signatures numériques XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigSHA512Url

Représente l’URI (Uniform Resource Identifier) de la méthode digest SHA512 standard pour les signatures numériques XML. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigXPathTransformUrl

Représente l’identificateur de ressource uniforme (URI) pour XML Path Language (XPath). Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlDsigXsltTransformUrl

Représente l’identificateur de ressource uniforme (URI) pour les transformations XSLT. Ce champ est constant.

System_CAPS_pubfieldSystem_CAPS_staticXmlLicenseTransformUrl

Représente l’identificateur de ressource uniforme (URI) pour l’algorithme de transformation de licence utilisé pour normaliser les licences XrML pour les signatures.

Le SignedXml classe est l’implémentation .NET Framework du World Wide Web Consortium (W3C) XML Signature Syntax and Processing Specification, également appelé XMLDSIG (Signature numérique XML). XMLDSIG est un moyen interopérable basée sur des normes pour signer et vérifier tout ou partie d’un document XML ou d’autres données qui sont adressables à partir une ressource identificateur URI (Uniform).

Utilisez la SignedXml classe dès que vous souhaitez partager des données XML signées entre applications ou organisations de manière standard. Toutes les données signées à l’aide de cette classe peuvent être vérifiées par une implémentation conforme de la spécification W3C pour XMLDSIG.

La SignedXml classe vous permet de créer les trois types de signatures numériques XML suivants :

Type de signature

Description

Signature enveloppée

La signature est contenue dans l’élément XML en cours de signature.

Signature enveloppante

Le XML signé est contenu dans le Signature> élément.

Signature détachée interne

La signature et XML signé sont dans le même document, mais aucun élément ne contient l’autre.

Il existe également un quatrième type de signature appelé une signature détachée externe lorsque les données et la signature sont dans des documents XML distincts. Signatures détachés externes ne sont pas pris en charge par la SignedXml classe.

XMLDSIG crée un Signature> élément, qui contient une signature numérique d’un document XML ou d’autres données qui sont adressables à partir d’un URI. Le Signature> élément peut éventuellement contenir des informations sur l’emplacement où rechercher une clé qui vérifiera la signature et l’algorithme de chiffrement qui a été utilisé pour la signature. La structure de base est la suivante :


<Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
    <SignedInfo>
      <CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
      <SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>
      <Reference URI="">
        <Transforms>
          <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
        </Transforms>
        <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
        <DigestValue>Base64EncodedValue==</DigestValue>
      </Reference>
    </SignedInfo>
    <SignatureValue>AnotherBase64EncodedValue===</SignatureValue>
  </Signature>

Les parties principales de cette structure sont :

Le CanonicalizationMethod> élément

Spécifie les règles de réécriture le Signature élément de texte/XML, en octets pour la validation de signature. La valeur par défaut dans le .NET Framework est http://www.w3.org/TR/2001/REC-xml-c14n-20010315, qui identifie un algorithme digne de confiance. Cet élément est représenté par le SignedInfo.CanonicalizationMethod propriété.

Le SignatureMethod> élément

Spécifie l’algorithme utilisé pour la génération des signatures et de validation, ce qui a été appliquée à la Signature> élément pour produire la valeur dans SignatureValue>. Dans l’exemple ci-dessus, la valeur http://www.w3.org/2000/09/xmldsig#rsa-sha1 identifie une signature RSA PKCS1 SHA-1. Cet élément est représenté par le SignatureMethod propriété.

Le SignatureValue> élément

Spécifie la signature de chiffrement pour le Signature> élément. Si cette signature ne vérifie pas, puis une partie de la Signature> bloc a été altéré et le document est considéré comme non valide. Tant que le CanonicalizationMethod> valeur est digne de confiance, cette valeur est très résistante aux falsifications. Cet élément est représenté par le SignatureValue propriété.

Le URI attribut de la Reference> élément

Spécifie un objet de données à l’aide d’une référence URI. Cet attribut est représenté par le Reference.Uri propriété.

  • Ne pas spécifier le URI attribut, autrement dit, le Reference.Uri propriété null, signifie que l’application de réception est attendue pour connaître l’identité de l’objet. Dans la plupart des cas, un null URI entraîne une exception est levée. N’utilisez pas un null URI, sauf si votre application interagit avec un protocole qui en a besoin.

  • Définition de la URI attribut à une chaîne vide indique que l’élément racine du document est en cours de signature, une forme de signature enveloppée.

  • Si la valeur de URI attribut commence par #, puis la valeur doit correspondre à un élément dans le document actif. Ce formulaire peut être utilisé avec les types de signature pris en charge (signature enveloppée, enveloppement signature ou signature détachée interne).

  • Tout autre élément est considéré comme une signature d’une ressource externe détachée et n’est pas pris en charge par la SignedXml classe.

Le Transforms> élément

Contient une liste ordonnée de Transform> éléments qui décrivent la façon dont le signataire obtenu l’objet de données qui a été minéralisé. Un algorithme de transformation est similaire à la méthode de canonisation, mais au lieu de réécrire la Signature> élément, il réécrit le contenu identifié par le URI attribut de la Reference> élément. Le Transforms> élément est représenté par la TransformChain classe.

  • Chaque algorithme de transformation est définie comme prenant XML (un ensemble de nœuds XPath) ou octets en entrée. Si le format des données actuelles est différente de la configuration requise d’entrée de transformation, les règles de conversion sont appliquées.

  • Chaque algorithme de transformation est défini comme la production XML ou octets comme sortie.

  • Si la sortie de l’algorithme de transformation dernière n’est pas définie en octets (ou aucune transformation n’a été spécifiée), puis le http://www.w3.org/TR/2001/REC-xml-c14n-20010315 méthode canonisation est utilisé comme une transformation implicite (même si un algorithme différent a été spécifié dans le CanonicalizationMethod> élément).

  • Valeur http://www.w3.org/2000/09/xmldsig#enveloped-signature pour l’algorithme de transformation encode une règle qui est interprétée en tant que de supprimer le Signature> élément à partir du document. Sinon, un vérificateur d’une signature enveloppée sera digest du document, y compris la signature, mais le signataire serait ont minéralisé le document avant que la signature a été appliquée, conduisant à des réponses différentes.

Le DigestMethod> élément

Identifie la méthode digest (hachage de chiffrement) à appliquer sur le contenu transformé identifié par le URI attribut de la Reference> élément. Il est représenté par le Reference.DigestMethod propriété.

À moins que l’interaction avec une spécification qui requiert l’utilisation d’une valeur différente, nous vous recommandons d’utiliser la méthode de canonisation par défaut dans le .NET Framework, qui est l’algorithme-C14N XML 1.0, dont la valeur est http://www.w3.org/TR/2001/REC-xml-c14n-20010315. L’algorithme-C14N XML 1.0 est requis pour être pris en charge par toutes les implémentations de XMLDSIG, en particulier car il n’est une transformation finale implicite à appliquer.

Il existe des versions des algorithmes de canonisation qui prennent en charge la conservation des commentaires. Méthodes de canonisation en conservant le commentaire ne sont pas recommandés, car ils violent le principe « connexion celle ». Autrement dit, les commentaires dans un Signature> élément ne modifie pas la logique de traitement pour le mode d’exécution de la signature, simplement la signature valeur. Lorsqu’il est associé à un algorithme de signature faible, ce qui permet des commentaires inclus donne à une personne malveillante inutiles de liberté forcer une collision de hachage, qui effectue un document falsifié apparence légitime. Dans le .NET Framework, uniquement les canonicalizers intégrées sont prises en charge par défaut. Pour prendre en charge canonicalizers supplémentaires ou personnalisés, consultez le SafeCanonicalizationMethods propriété. Si le document utilise une méthode de canonisation qui n’est pas dans la collection représentée par le SafeCanonicalizationMethods propriété, puis le CheckSignature méthode retournera false.

System_CAPS_noteRemarque

Une application extrêmement défensive peut supprimer toutes les valeurs qu’il n’attend pas signataires à utiliser à partir de la SafeCanonicalizationMethods collection.

Oui, le Reference> valeurs sont sécurisés contre la falsification. Le .NET framework vérifie les SignatureValue> calcul avant le traitement de la Reference> valeurs leur sont associées transforme et va être abandonné tôt pour éviter les instructions de traitement potentiellement malveillant.

Nous vous recommandons d’utiliser la valeur de « » pour le URI attribut (ou définir le Uri propriété à une chaîne vide), si possible. Cela signifie que l’ensemble du document est pris en compte pour le calcul de synthèse, ce qui signifie que l’ensemble du document est protégé contre la falsification.

Il est très courant de voir URI valeurs sous la forme d’ancres telles que #foo, qui fait référence à un élément dont l’attribut ID est « foo ». Malheureusement, il est facile pour cette option pour être falsifiés, car cela inclut uniquement le contenu de l’élément cible, pas le contexte. Abusives cette distinction est connu comme le renvoi à la ligne de Signature XML (XSW).

Si votre application prend en compte la sémantique de commentaires (qui est commun pas quand vous traitez des XML), vous devez utiliser « #xpointer(/) » au lieu de « » et « #xpointer(id('foo')) » au lieu de « #foo ». Les versions #xpointer sont interprétées comme y compris les commentaires, tandis que les formulaires shortname sont à l’exception des commentaires.

Si vous devez accepter les documents protégés que partiellement et que vous souhaitez vous assurer que vous lisez le même contenu protégé par la signature, utilisez la GetIdElement (méthode).

Les données dans le paramètre facultatif KeyInfo> élément (autrement dit, le KeyInfo propriété), qui contient une clé pour valider la signature, ne doit pas être approuvé.

En particulier, quand le KeyInfo valeur représente une clé publique RSA, DSA et ECDSA nue, le document peut avoir été falsifié, malgré le CheckSignature méthode indiquera que la signature est valide. Cela peut se produire, car l’entité effectuant la falsification simplement doit générer une nouvelle clé et la signer à nouveau le document falsifié avec cette nouvelle clé. Par conséquent, à moins que votre application vérifie que la clé publique est une valeur attendue, le document doit être traité comme si elles ont été falsifiées. Cela nécessite que votre application examine la clé publique est incorporée dans le document et vérifiez que l’opération sur une liste de valeurs connues pour le contexte de document. Par exemple, si le document peut être compris délivré par un utilisateur connu, vous devez vérifier la clé par rapport à une liste de clés connues utilisées par cet utilisateur.

Vous pouvez également vérifier la clé après avoir traité le document à l’aide de la CheckSignatureReturningKey méthode, au lieu d’utiliser le CheckSignature (méthode). Toutefois, pour une sécurité optimale, vous devez vérifier au préalable la clé.

Ou bien, envisagez de la tentative de l’utilisateur inscrit des clés publiques, au lieu de lire ce qui est dans le KeyInfo> élément.

Le paramètre facultatif X509Data> élément est un enfant de le KeyInfo> élément et contient un ou plusieurs X509 certificats ou des identificateurs de X509 certificats. Les données dans le X509Data> élément doit également être pas approuvée par nature.

Lors de la vérification d’un document avec le texte incorporé X509Data> élément, le .NET Framework vérifie uniquement que les données est résolu en un X509 certificat dont la clé publique peut être utilisée avec succès pour valider la signature de document. Contrairement à appeler le CheckSignature méthode avec la verifySignatureOnly paramètre la valeur false, aucune vérification de révocation est effectuée, aucune chaîne d’approbation n’est vérifiée, et sans date d’expiration est vérifié. Même si votre application extrait le certificat lui-même et le passe à la CheckSignature méthode avec la verifySignatureOnly paramètre la valeur false, qui est toujours une validation pas suffisante pour empêcher toute falsification de document. Le certificat doit toujours être vérifié comme étant appropriés pour le document en cours de signature.

À l’aide d’un certificat de signature incorporé peut fournir des stratégies de rotation des clés utile, si dans le X509Data> section ou dans le contenu du document. Lorsque vous utilisez cette approche une application doit extraire le certificat manuellement et effectuer une validation similaire à :

  • Le certificat a été émis directement ou via une chaîne par une autorité de certificat (CA) publique dont le certificat est incorporé dans l’application.

    À l’aide de la liste d’approbation fournie par le système d’exploitation sans contrôles supplémentaires, tel qu’un nom de l’objet connu, n’est pas suffisante pour empêcher toute falsification dans SignedXml.

  • Le certificat est vérifié n’a ne pas été expiré au moment de la signature de document (ou « maintenant » pour près de traitement des documents en temps réel).

  • Pour les certificats émis par une autorité de certification qui prend en charge de la révocation de longue durées, vérifiez que le certificat n’a pas révoqué.

  • L’objet du certificat est vérifié comme étant appropriée pour le document actif.

Si vous interagissez avec une spécification qui a défini des valeurs spécifiques (par exemple, XrML), vous devez suivre la spécification. Si vous avez une signature enveloppée (par exemple lorsque l’ensemble du document de signature), vous devez utiliser http://www.w3.org/2000/09/xmldsig#enveloped-signature (représenté par la XmlDsigEnvelopedSignatureTransform classe). Vous pouvez spécifier la transformation de XML-C14N implicite, mais il n’est pas nécessaire. Pour une signature d’enveloppe ou détachée, aucune transformation n’est nécessaire. Prend en charge la transformation XML-C14N implicite de tous les éléments.

Avec la mise à jour de sécurité introduits par le Microsoft Security Bulletin MS16-035, le .NET Framework a limité les transformations peuvent être utilisées dans la vérification du document par défaut, avec des transformations non approuvées à l’origine CheckSignature toujours retourner false. En particulier, les transformations qui nécessitent une entrée supplémentaire (spécifiée en tant qu’éléments enfants dans le fichier XML) ne sont plus autorisées en raison de leur sensibilité des abus par des utilisateurs malveillants. Le W3C indique ce qui évite les transformations XSLT et XPath, qui sont les deux transformations principales affectées par ces limitations.

Si une application ne vérifie pas que les références externes ne semblent appropriés pour le contexte actuel, ils peuvent être utilisées avec des méthodes qui fournissent de nombreuses failles de sécurité (y compris les attaques de déni de Service, réflexion déni de Service distribué, divulgation d’informations, le contournement de la Signature et l’exécution de Code à distance). Même si une application pour valider l’URI de référence externe, il reste un problème de la ressource en cours de chargement à deux reprises : une fois lorsque votre application lit et une deuxième fois lorsque SignedXml le lit. Comme il n’existe aucune garantie que la lecture de l’application et le document vérifient étapes ont le même contenu, la signature ne fournit pas de niveau de confiance.

Étant donné les risques de références externes, SignedXml lève une exception lorsqu’une référence externe est rencontrée. Pour plus d’informations sur ce problème, consultez KB article 3148821.

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

//
// 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.
           RSACryptoServiceProvider Key = new RSACryptoServiceProvider();

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

//
// 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.
       RSACryptoServiceProvider Key = new RSACryptoServiceProvider();

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

.NET Framework
Disponible depuis 1.1

Tous les membres statiques publics ( Shared en Visual Basic) de ce type sont thread-safe. Les membres d’instance n’ont pas la garantie d’être thread-safe.

Retour au début
Afficher: