XmlDsigC14NWithCommentsTransform Classe

Définition

Espace de noms:

System.Security.Cryptography.Xml

Assembly:

System.Security.Cryptography.Xml.dll

Paquet:

System.Security.Cryptography.Xml v8.0.0

Source:

XmlDsigC14NWithCommentsTransform.cs

Représente la transformation, avec commentaires, selon les spécifications de canonisation (C14N) XML d'une signature numérique définies par le W3C (World Wide Web Consortium).

public ref class XmlDsigC14NWithCommentsTransform : System::Security::Cryptography::Xml::XmlDsigC14NTransform

public class XmlDsigC14NWithCommentsTransform : System.Security.Cryptography.Xml.XmlDsigC14NTransform

type XmlDsigC14NWithCommentsTransform = class
    inherit XmlDsigC14NTransform

Public Class XmlDsigC14NWithCommentsTransform
Inherits XmlDsigC14NTransform

Héritage

Object

Transform

XmlDsigC14NTransform

XmlDsigC14NWithCommentsTransform

Exemples

Cette section contient deux exemples de code. Le premier exemple montre comment signer un fichier XML à l’aide d’une signature détachée. Cet exemple crée une signature de www.microsoft.com dans un fichier XML, puis vérifie le fichier. Le deuxième exemple montre comment signer un fichier XML à l’aide d’une signature d’enveloppe. Cet exemple crée une signature d’un fichier XML, puis enregistre la signature dans un nouveau fichier XML.

Exemple n°1

//
// This example signs a file specified by a URI 
// using a detached signature. It then verifies  
// the signed XML.
//
#using <System.Security.dll>
#using <System.Xml.dll>

using namespace System;
using namespace System::Security::Cryptography;
using namespace System::Security::Cryptography::Xml;
using namespace System::Text;
using namespace System::Xml;

// Sign an XML file and save the signature in a new file.
void SignDetachedResource( String^ URIString, String^ XmlSigFileName, RSA^ RSAKey )
{
   
   // Create a SignedXml object.
   SignedXml^ signedXml = gcnew SignedXml;
   
   // Assign the key to the SignedXml object.
   signedXml->SigningKey = RSAKey;
   
   // Create a reference to be signed.
   Reference^ reference = gcnew Reference;
   
   // Add the passed URI to the reference object.
   reference->Uri = URIString;
   
   // Add a transformation if the URI is an XML file.
   if ( URIString->EndsWith( "xml" ) )
   {
      
      // Add the reference to the SignedXml object.
      signedXml->AddReference( reference );
      
      // Add an RSAKeyValue KeyInfo (optional; helps recipient find key to validate).
      KeyInfo^ keyInfo = gcnew KeyInfo;
      keyInfo->AddClause( gcnew RSAKeyValue( safe_cast<RSA^>(RSAKey) ) );
      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();
      
      // Save the signed XML document to a file specified
      // using the passed string.
      XmlTextWriter^ xmltw = gcnew XmlTextWriter( XmlSigFileName,gcnew UTF8Encoding( false ) );
      xmlDigitalSignature->WriteTo( xmltw );
      xmltw->Close();
   }
}


// Verify the signature of an XML file and return the result.
Boolean VerifyDetachedSignature( String^ XmlSigFileName )
{
   
   // Create a new XML document.
   XmlDocument^ xmlDocument = gcnew XmlDocument;
   
   // Load the passed XML file into the document.
   xmlDocument->Load( XmlSigFileName );
   
   // Create a new SignedXMl object.
   SignedXml^ signedXml = gcnew SignedXml;
   
   // Find the S"Signature" node and create a new
   // XmlNodeList object.
   XmlNodeList^ nodeList = xmlDocument->GetElementsByTagName( "Signature" );
   
   // Load the signature node.
   signedXml->LoadXml( safe_cast<XmlElement^>(nodeList->Item( 0 )) );
   
   // Check the signature and return the result.
   return signedXml->CheckSignature();
}


int main()
{
   
   // The URI to sign.
   String^ resourceToSign = "http://www.microsoft.com";
   
   // The name of the file to which to save the XML signature.
   String^ XmlFileName = "xmldsig.xml";
   try
   {
      
      // Generate a signing key.
      RSA^ Key = RSA::Create();
      Console::WriteLine( "Signing: {0}", resourceToSign );
      
      // Sign the detached resourceand save the signature in an XML file.
      SignDetachedResource( resourceToSign, XmlFileName, Key );
      Console::WriteLine( "XML signature was successfully computed and saved to {0}.", XmlFileName );
      
      // Verify the signature of the signed XML.
      Console::WriteLine( "Verifying signature..." );
      
      //Verify the XML signature in the XML file.
      bool result = VerifyDetachedSignature( XmlFileName );
      
      // 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 );
   }

}

//
// This example signs a file specified by a URI 
// using a detached signature. It then verifies  
// the signed XML.
//

using System;
using System.Security.Cryptography;
using System.Security.Cryptography.Xml;
using System.Text;
using System.Xml;

class XMLDSIGDetached
{
    
    [STAThread]
    static void Main(string[] args)
    {
        // The URI to sign.
        string resourceToSign = "http://www.microsoft.com";
        
        // The name of the file to which to save the XML signature.
        string XmlFileName = "xmldsig.xml";

        try
        {

            // Generate a signing key.
            RSA Key = RSA.Create();

            Console.WriteLine("Signing: {0}", resourceToSign);

            // Sign the detached resourceand save the signature in an XML file.
            SignDetachedResource(resourceToSign, XmlFileName, Key);

            Console.WriteLine("XML signature was successfully computed and saved to {0}.", XmlFileName);

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

            //Verify the XML signature in the XML file.
            bool result = VerifyDetachedSignature(XmlFileName);

            // 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.
    public static void SignDetachedResource(string URIString, string XmlSigFileName, RSA Key)
    {
        // Create a SignedXml object.
        SignedXml signedXml = new SignedXml();

        // Assign the key to the SignedXml object.
        signedXml.SigningKey = Key;

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

        // Add the passed URI to the reference object.
        reference.Uri = URIString;
        
        // 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();

        // Save the signed XML document to a file specified
        // using the passed string.
        XmlTextWriter xmltw = new XmlTextWriter(XmlSigFileName, new UTF8Encoding(false));
        xmlDigitalSignature.WriteTo(xmltw);
        xmltw.Close();
    }
    // Verify the signature of an XML file and return the result.
    public static Boolean VerifyDetachedSignature(string XmlSigFileName)
    {	
        // Create a new XML document.
        XmlDocument xmlDocument = new XmlDocument();

        // Load the passed XML file into the document.
        xmlDocument.Load(XmlSigFileName);
    
        // Create a new SignedXMl object.
        SignedXml signedXml = new SignedXml();

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

' This example signs a file specified by a URI 
' using a detached signature. It then verifies  
' the signed XML.

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

Class XMLDSIGDetached

   
   <STAThread()>  _
   Overloads Shared Sub Main(args() As String)
      ' The URI to sign.
      Dim resourceToSign As String = "http://www.microsoft.com"
      
      ' The name of the file to which to save the XML signature.
      Dim XmlFileName As String = "xmldsig.xml"
      
      Try
         
         ' Generate a signing key.
         Dim Key As RSA = RSA.Create()
         
         Console.WriteLine("Signing: {0}", resourceToSign)
         
         ' Sign the detached resourceand save the signature in an XML file.
         SignDetachedResource(resourceToSign, XmlFileName, Key)
         
         Console.WriteLine("XML signature was successfully computed and saved to {0}.", XmlFileName)
         
         ' Verify the signature of the signed XML.
         Console.WriteLine("Verifying signature...")
         
         'Verify the XML signature in the XML file.
         Dim result As Boolean = VerifyDetachedSignature(XmlFileName)
         
         ' Display the results of the signature verification to 
         ' the console.
         If result Then
            Console.WriteLine("The XML signature is valid.")
         Else
            Console.WriteLine("The XML signature is not valid.")
         End If
      Catch e As CryptographicException
         Console.WriteLine(e.Message)
      End Try 
   End Sub 
   
   ' Sign an XML file and save the signature in a new file.
   Public Shared Sub SignDetachedResource(URIString As String, XmlSigFileName As String, Key As RSA)
      ' Create a SignedXml object.
      Dim signedXml As New SignedXml()
      
      ' Assign the key to the SignedXml object.
      signedXml.SigningKey = Key
      
      ' Create a reference to be signed.
      Dim reference As New Reference()
      
      ' Add the passed URI to the reference object.
      reference.Uri = URIString
      
      ' Add the reference to the SignedXml object.
      signedXml.AddReference(reference)
      
      ' Add an RSAKeyValue KeyInfo (optional; helps recipient find key to validate).
      Dim keyInfo As New KeyInfo()
      keyInfo.AddClause(New RSAKeyValue(CType(Key, RSA)))
      signedXml.KeyInfo = keyInfo
      
      ' Compute the signature.
      signedXml.ComputeSignature()
      
      ' Get the XML representation of the signature and save
      ' it to an XmlElement object.
      Dim xmlDigitalSignature As XmlElement = signedXml.GetXml()
      
      ' Save the signed XML document to a file specified
      ' using the passed string.
      Dim xmltw As New XmlTextWriter(XmlSigFileName, New UTF8Encoding(False))
      xmlDigitalSignature.WriteTo(xmltw)
      xmltw.Close()
   End Sub 
   
   ' Verify the signature of an XML file and return the result.
   Public Shared Function VerifyDetachedSignature(XmlSigFileName As String) As [Boolean]
      ' Create a new XML document.
      Dim xmlDocument As New XmlDocument()
      
      ' Load the passed XML file into the document.
      xmlDocument.Load(XmlSigFileName)
      
      ' Create a new SignedXMl object.
      Dim signedXml As New SignedXml()
      
      ' Find the "Signature" node and create a new
      ' XmlNodeList object.
      Dim nodeList As XmlNodeList = xmlDocument.GetElementsByTagName("Signature")
      
      ' Load the signature node.
      signedXml.LoadXml(CType(nodeList(0), XmlElement))
      
      ' Check the signature and return the result.
      Return signedXml.CheckSignature()
   End Function
End Class

Exemple n°2

// This example signs an XML file using an
// envelope signature. It then verifies the 
// signed XML.
#using <System.Security.dll>
#using <System.Xml.dll>

using namespace System;
using namespace System::Security::Cryptography;
using namespace System::Security::Cryptography::Xml;
using namespace System::Text;
using namespace System::Xml;

// Sign an XML file and save the signature in a new file.
void SignXmlFile( String^ FileName, String^ SignedFileName, RSA^ Key )
{
   
   // Create a new XML document.
   XmlDocument^ doc = gcnew XmlDocument;
   
   // Format the document to ignore white spaces.
   doc->PreserveWhitespace = false;
   
   // Load the passed XML file using it's name.
   doc->Load( gcnew XmlTextReader( FileName ) );
   
   // Create a SignedXml Object*.
   SignedXml^ signedXml = gcnew SignedXml( doc );
   
   // Add the key to the SignedXml document. 
   signedXml->SigningKey = Key;
   
   // Create a reference to be signed.
   Reference^ reference = gcnew Reference;
   reference->Uri = "";
   
   // Add an enveloped transformation to the reference.
   XmlDsigEnvelopedSignatureTransform^ env = gcnew 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 = gcnew KeyInfo;
   keyInfo->AddClause( gcnew RSAKeyValue( safe_cast<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)->GetType() == XmlDeclaration::typeid )
   {
      doc->RemoveChild( doc->FirstChild );
   }

   
   // Save the signed XML document to a file specified
   // using the passed String*.
   XmlTextWriter^ xmltw = gcnew XmlTextWriter( SignedFileName,gcnew UTF8Encoding( false ) );
   doc->WriteTo( xmltw );
   xmltw->Close();
}


// Verify the signature of an XML file and return the result.
Boolean VerifyXmlFile( String^ Name )
{
   
   // Create a new XML document.
   XmlDocument^ xmlDocument = gcnew 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 = gcnew SignedXml( xmlDocument );
   
   // Find the S"Signature" node and create a new
   // XmlNodeList Object*.
   XmlNodeList^ nodeList = xmlDocument->GetElementsByTagName( "Signature" );
   
   // Load the signature node.
   signedXml->LoadXml( safe_cast<XmlElement^>(nodeList->Item( 0 )) );
   
   // Check the signature and return the result.
   return signedXml->CheckSignature();
}


// Create example data to sign.
void CreateSomeXml( String^ FileName )
{
   
   // Create a new XmlDocument Object*.
   XmlDocument^ document = gcnew 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 = gcnew XmlTextWriter( FileName,gcnew UTF8Encoding( false ) );
   document->WriteTo( xmltw );
   xmltw->Close();
}

void main()
{
   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" );
      
      // 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 );
   }

}

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

            // 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.
    public static void SignXmlFile(string FileName, string SignedFileName, RSA Key)
    {
        // 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;

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

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

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

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


Public Class SignVerifyEnvelope

   Overloads Public Shared Sub Main(args() As [String])
      Try
         ' Generate a signing key.
         Dim Key As RSA = 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...")
         Dim result As Boolean = VerifyXmlFile("SignedExample.xml")
         
         ' Display the results of the signature verification to \
         ' the console.
         If result Then
            Console.WriteLine("The XML signature is valid.")
         Else
            Console.WriteLine("The XML signature is not valid.")
         End If
      Catch e As CryptographicException
         Console.WriteLine(e.Message)
      End Try
   End Sub 
   
   
   ' Sign an XML file and save the signature in a new file.
   Public Shared Sub SignXmlFile(FileName As String, SignedFileName As String, Key As RSA)
      ' Create a new XML document.
      Dim doc As 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.
      Dim signedXml As New SignedXml(doc)
      
      ' Add the key to the SignedXml document. 
      signedXml.SigningKey = Key
      
      ' Create a reference to be signed.
      Dim reference As New Reference()
      reference.Uri = ""
      
      ' Add an enveloped transformation to the reference.
      Dim env As 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).
      Dim keyInfo As New KeyInfo()
      keyInfo.AddClause(New RSAKeyValue(CType(Key, RSA)))
      signedXml.KeyInfo = keyInfo
      
      ' Compute the signature.
      signedXml.ComputeSignature()
      
      ' Get the XML representation of the signature and save
      ' it to an XmlElement object.
      Dim xmlDigitalSignature As XmlElement = signedXml.GetXml()
      
      ' Append the element to the XML document.
      doc.DocumentElement.AppendChild(doc.ImportNode(xmlDigitalSignature, True))
      
      
      If TypeOf doc.FirstChild Is XmlDeclaration Then
         doc.RemoveChild(doc.FirstChild)
      End If
      
      ' Save the signed XML document to a file specified
      ' using the passed string.
      Dim xmltw As New XmlTextWriter(SignedFileName, New UTF8Encoding(False))
      doc.WriteTo(xmltw)
      xmltw.Close()
   End Sub 
   
   ' Verify the signature of an XML file and return the result.
   Public Shared Function VerifyXmlFile(Name As [String]) As [Boolean]
      ' Create a new XML document.
      Dim xmlDocument As 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.
      Dim signedXml As New SignedXml(xmlDocument)
      
      ' Find the "Signature" node and create a new
      ' XmlNodeList object.
      Dim nodeList As XmlNodeList = xmlDocument.GetElementsByTagName("Signature")
      
      ' Load the signature node.
      signedXml.LoadXml(CType(nodeList(0), XmlElement))
      
      ' Check the signature and return the result.
      Return signedXml.CheckSignature()
   End Function 
   
   ' Create example data to sign.
   Public Shared Sub CreateSomeXml(FileName As String)
      ' Create a new XmlDocument object.
      Dim document As New XmlDocument()
      
      ' Create a new XmlNode object.
      Dim node As XmlNode = 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.
      Dim xmltw As New XmlTextWriter(FileName, New UTF8Encoding(False))
      document.WriteTo(xmltw)
      xmltw.Close()
   End Sub 
End Class

Remarques

La XmlDsigC14NWithCommentsTransform classe représente la transformation de canonisation XML C14N qui décrit la forme canonique d’un document XML. Cette transformation permet à un signataire de créer un condensé à l’aide de la forme canonique d’un document XML. Un destinataire peut ensuite vérifier la signature numérique à l’aide de la même forme canonique du document XML avec la même transformation.

Utilisez la XmlDsigC14NWithCommentsTransform classe lorsque vous devez signer un document XML qui contient des commentaires.

Notez que vous ne pouvez pas créer directement une nouvelle instance d’une classe de transformation de canonisation. Pour spécifier une transformation de canonisation, transmettez l’URI (Uniform Resource Identifier) qui décrit la transformation à la CanonicalizationMethod propriété, qui est accessible à partir de la SignedInfo propriété . Pour acquérir une référence à la transformation de canonisation, utilisez la CanonicalizationMethodObject propriété , qui est accessible à partir de la SignedInfo propriété .

L’URI qui décrit la XmlDsigExcC14NWithCommentsTransform classe est défini par le XmlDsigExcC14NWithCommentsTransformUrl champ .

L’URI qui décrit la XmlDsigC14NWithCommentsTransform classe est défini par le XmlDsigC14NWithCommentsTransformUrl champ et le XmlDsigCanonicalizationWithCommentsUrl champ .

Pour plus d’informations sur la transformation C14N avec commentaires, consultez les sections 6.5 et 6.6.1 de la spécification XMLDSIG du W3C. L’algorithme de canonisation est défini dans la spécification XML canonique du W3C.

Constructeurs

XmlDsigC14NWithCommentsTransform()

Initialise une nouvelle instance de la classe XmlDsigC14NWithCommentsTransform.

Propriétés

Algorithm	Obtient ou définit l'URI (Uniform Resource Identifier) qui identifie l'algorithme exécuté par la transformation actuelle. (Hérité de Transform)
Context	Obtient ou définit un objet XmlElement qui représente le contexte de document dans lequel l'objet Transform actuel est exécuté. (Hérité de Transform)
InputTypes	Obtient un tableau de types qui constituent des entrées valides dans les méthodes LoadInput(Object) de l'objet XmlDsigC14NTransform en cours. (Hérité de XmlDsigC14NTransform)
OutputTypes	Obtient un tableau de types qui constituent des sorties valides des méthodes GetOutput() de l'objet XmlDsigC14NTransform en cours. (Hérité de XmlDsigC14NTransform)
PropagatedNamespaces	Obtient ou définit un objet Hashtable qui contient les espaces de noms qui sont propagés dans la signature. (Hérité de Transform)
Resolver	Définit l'objet XmlResolver en cours. (Hérité de Transform)

Méthodes

Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetDigestedOutput(HashAlgorithm)	Retourne le Digest associé à un objet XmlDsigC14NTransform. (Hérité de XmlDsigC14NTransform)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetInnerXml()	Retourne une représentation XML des paramètres d'un objet XmlDsigC14NTransform qui conviennent pour être inclus comme sous-éléments d'un élément <Transform> XMLDSIG. (Hérité de XmlDsigC14NTransform)
GetOutput()	Retourne la sortie de l'objet XmlDsigC14NTransform en cours. (Hérité de XmlDsigC14NTransform)
GetOutput(Type)	Retourne la sortie de l'objet XmlDsigC14NTransform en cours, de type Stream. (Hérité de XmlDsigC14NTransform)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
GetXml()	Retourne la représentation XML de l'objet Transform en cours. (Hérité de Transform)
LoadInnerXml(XmlNodeList)	Analyse l'objet XmlNodeList spécifié en tant que contenu spécifique à la transformation d'un élément <Transform> ; cette méthode n'est pas prise en charge car cet élément ne possède pas d'éléments XML internes. (Hérité de XmlDsigC14NTransform)
LoadInput(Object)	Charge l'entrée spécifiée dans l'objet XmlDsigC14NTransform en cours. (Hérité de XmlDsigC14NTransform)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)