SignedXml Classe

Definizione

Fornisce un wrapper per un oggetto firma XML core per facilitare la creazione di firme XML.Provides a wrapper on a core XML signature object to facilitate creating XML signatures.

public ref class SignedXml
public class SignedXml
type SignedXml = class
Public Class SignedXml
Ereditarietà
SignedXml

Esempio

Nell'esempio di codice riportato di seguito viene illustrato come firmare e verificare un intero documento XML utilizzando una firma protetta.The following code example shows how to sign and verify an entire XML document using an enveloped signature.

//
// 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::X509Certificates;
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. 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.
void SignXmlFile( String^ FileName, String^ SignedFileName, RSA^ Key )
{
   
   // Create a new XML document.
   XmlDocument^ doc = gcnew XmlDocument;
   
   // Load the passed XML file using its 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 );
   
   // 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 against an asymmetric 
// algorithm and return the result.
Boolean VerifyXmlFile( String^ Name, RSA^ Key )
{
   
   // Create a new XML document.
   XmlDocument^ xmlDocument = gcnew 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 = gcnew SignedXml( xmlDocument );
   
   // Find the "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( Key );
}


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

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

}

//
// 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();
    }
}
'
' This example signs an XML file using an
' envelope signature. It then verifies the 
' signed XML.
'
Imports System.Security.Cryptography
Imports System.Security.Cryptography.X509Certificates
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", Key)
         
         ' 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. 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 Shared Sub SignXmlFile(FileName As String, SignedFileName As String, Key As RSA)
      ' Create a new XML document.
      Dim doc As New XmlDocument()
      
      ' Load the passed XML file using its 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)
      
      ' 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 against an asymmetric 
   ' algorithm and return the result.
   Public Shared Function VerifyXmlFile(Name As [String], Key As RSA) As [Boolean]
      ' Create a new XML document.
      Dim xmlDocument As 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.
      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(Key)
   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 

Nell'esempio di codice seguente viene illustrato come firmare e verificare un singolo elemento di un documento XML utilizzando una firma di inviluppo.The following code example shows how to sign and verify a single element of an XML document using an enveloping signature.

//
// This example signs an XML file using an
// envelope signature. It then verifies the 
// signed XML.
//
#using <System.Xml.dll>
#using <System.Security.dll>
#using <System.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.
static void SignXmlFile( String^ FileName, String^ SignedFileName, RSA^ Key, array<String^>^ElementsToSign )
{
   
   // Check the arguments.  
   if ( FileName == nullptr )
      throw gcnew ArgumentNullException( L"FileName" );

   if ( SignedFileName == nullptr )
      throw gcnew ArgumentNullException( L"SignedFileName" );

   if ( Key == nullptr )
      throw gcnew ArgumentNullException( L"Key" );

   if ( ElementsToSign == nullptr )
      throw gcnew ArgumentNullException( L"ElementsToSign" );

   
   // 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;
   
   // Loop through each passed element to sign 
   // and create a reference.
   System::Collections::IEnumerator^ myEnum = ElementsToSign->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ s = safe_cast<String^>(myEnum->Current);
      
      // Create a reference to be signed.
      Reference^ reference = gcnew Reference;
      reference->Uri = s;
      
      // 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( dynamic_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 ( dynamic_cast<XmlDeclaration^>(doc->FirstChild) )
   {
      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.
static Boolean VerifyXmlFile( String^ Name )
{
   
   // Check the arguments.  
   if ( Name == nullptr )
      throw gcnew ArgumentNullException( L"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 "Signature" node and create a new
   // XmlNodeList object.
   XmlNodeList^ nodeList = xmlDocument->GetElementsByTagName( L"Signature" );
   
   // Load the signature node.
   signedXml->LoadXml( dynamic_cast<XmlElement^>(nodeList->Item( 0 )) );
   
   // Check the signature and return the result.
   return signedXml->CheckSignature();
}

int main()
{
   
   // Generate a signing key.
   RSA^ Key = RSA::Create();
   try
   {
      
      // Specify an element to sign. 
      array<String^>^elements = {L"#tag1"};
      
      // Sign an XML file and save the signature to a 
      // new file.
      SignXmlFile( L"Test.xml", L"SignedExample.xml", Key, elements );
      Console::WriteLine( L"XML file signed." );
      
      // Verify the signature of the signed XML.
      Console::WriteLine( L"Verifying signature..." );
      bool result = VerifyXmlFile( L"SignedExample.xml" );
      
      // Display the results of the signature verification to 
      // the console.
      if ( result )
      {
         Console::WriteLine( L"The XML signature is valid." );
      }
      else
      {
         Console::WriteLine( L"The XML signature is not valid." );
      }
   }
   catch ( CryptographicException^ e ) 
   {
      Console::WriteLine( e->Message );
   }
   finally
   {
      
      // Clear resources associated with the 
      // RSA instance.
      Key->Clear();
   }

   return 1;
}

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



Module SignVerifyEnvelope



    Sub Main(ByVal args() As String)
        ' Generate a signing key.
        Dim Key As RSA = RSA.Create()

        Try
            ' Specify an element to sign. 
            Dim elements As String() = New String() {"#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...")

            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)
        Finally
            ' Clear resources associated with the 
            ' RSA instance.
            Key.Clear()
        End Try

    End Sub


    ' Sign an XML file and save the signature in a new file.
    Sub SignXmlFile(ByVal FileName As String, ByVal SignedFileName As String, ByVal Key As RSA, ByVal ElementsToSign() As String)
        ' Check the arguments.  
        If FileName Is Nothing Then
            Throw New ArgumentNullException("FileName")
        End If
        If SignedFileName Is Nothing Then
            Throw New ArgumentNullException("SignedFileName")
        End If
        If Key Is Nothing Then
            Throw New ArgumentNullException("Key")
        End If
        If ElementsToSign Is Nothing Then
            Throw New ArgumentNullException("ElementsToSign")
        End If
        ' 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

        ' Loop through each passed element to sign 
        ' and create a reference.
        Dim s As String
        For Each s In ElementsToSign
            ' Create a reference to be signed.
            Dim reference As New Reference()
            reference.Uri = s

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

        ' 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.
    Function VerifyXmlFile(ByVal Name As String) As [Boolean]
        ' Check the arguments.  
        If Name Is Nothing Then
            Throw New ArgumentNullException("Name")
        End If
        ' 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
End Module

Commenti

La SignedXml classe è l'implementazione .NET della sintassi e della specifica di elaborazione della firma XMLWorld Wide Web Consortium (W3C), nota anche come XMLDSIG (firma digitale XML).The SignedXml class is the .NET implementation of the World Wide Web Consortium (W3C) XML Signature Syntax and Processing Specification, also known as XMLDSIG (XML Digital Signature). XMLDSIG è un metodo interoperativo basato su standard per firmare e verificare interamente o in parte un documento XML o altri dati indirizzabili da un Uniform Resource Identifier (URI).XMLDSIG is a standards-based, interoperable way to sign and verify all or part of an XML document or other data that is addressable from a Uniform Resource Identifier (URI).

Usare la SignedXml classe ogni volta che è necessario condividere i dati XML firmati tra applicazioni o organizzazioni in modo standard.Use the SignedXml class whenever you need to share signed XML data between applications or organizations in a standard way. Tutti i dati firmati con questa classe possono essere verificati da qualsiasi implementazione conforme della specifica W3C per XMLDSIG.Any data signed using this class can be verified by any conforming implementation of the W3C specification for XMLDSIG.

La SignedXml classe consente di creare i tre tipi di firme digitali XML seguenti:The SignedXml class allows you to create the following three kinds of XML digital signatures:

Tipo di firmaSignature Type DescrizioneDescription
Firma bustaEnveloped signature La firma è contenuta all'interno dell'elemento XML firmato.The signature is contained within the XML element being signed.
Firma di inviluppoEnveloping signature Il codice XML firmato è contenuto all'interno dell' <Signature> elemento.The signed XML is contained within the <Signature> element.
Firma scollegata internaInternal detached signature La firma e il codice XML firmato si trovano nello stesso documento, ma nessun elemento contiene l'altro.The signature and signed XML are in the same document, but neither element contains the other.

Esiste anche un quarto tipo di firma, ovvero una firma scollegata esterna, ovvero quando i dati e la firma si trovano in documenti XML distinti.There is also a fourth kind of signature called an external detached signature which is when the data and signature are in separate XML documents. Le firme scollegate esterne non sono supportate dalla SignedXml classe.External detached signatures are not supported by the SignedXml class.

Struttura di una firma XMLThe structure of an XML Signature

XMLDSIG crea un <Signature> elemento che contiene una firma digitale di un documento XML o altri dati indirizzabili da un URI.XMLDSIG creates a <Signature> element, which contains a digital signature of an XML document or other data that is addressable from a URI. L' <Signature> elemento può facoltativamente contenere informazioni su dove trovare una chiave che verificherà la firma e l'algoritmo di crittografia usato per la firma.The <Signature> element can optionally contain information about where to find a key that will verify the signature and which cryptographic algorithm was used for signing. La struttura di base è la seguente:The basic structure is as follows:

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

Le parti principali di questa struttura sono:The main parts of this structure are:

  • Elemento <CanonicalizationMethod>The <CanonicalizationMethod> element

    Specifica le regole per la riscrittura dell' Signature elemento da XML/testo in byte per la convalida della firma.Specifies the rules for rewriting the Signature element from XML/text into bytes for signature validation. Il valore predefinito in .NET è http://www.w3.org/TR/2001/REC-xml-c14n-20010315 , che identifica un algoritmo attendibile.The default value in .NET is http://www.w3.org/TR/2001/REC-xml-c14n-20010315, which identifies a trustworthy algorithm. Questo elemento è rappresentato dalla SignedInfo.CanonicalizationMethod Proprietà.This element is represented by the SignedInfo.CanonicalizationMethod property.

  • Elemento <SignatureMethod>The <SignatureMethod> element

    Specifica l'algoritmo utilizzato per la generazione e la convalida della firma, che è stato applicato all' <Signature> elemento per produrre il valore in <SignatureValue> .Specifies the algorithm used for signature generation and validation, which was applied to the <Signature> element to produce the value in <SignatureValue>. Nell'esempio precedente, il valore http://www.w3.org/2000/09/xmldsig#rsa-sha1 identifica una firma RSA PKCS1 SHA-1.In the previous example, the value http://www.w3.org/2000/09/xmldsig#rsa-sha1 identifies an RSA PKCS1 SHA-1 signature. A causa di problemi di collisione con SHA-1, Microsoft consiglia un modello di sicurezza basato su SHA-256 o superiore.Due to collision problems with SHA-1, Microsoft recommends a security model based on SHA-256 or better. Questo elemento è rappresentato dalla SignatureMethod Proprietà.This element is represented by the SignatureMethod property.

  • Elemento <SignatureValue>The <SignatureValue> element

    Specifica la firma crittografica per l' <Signature> elemento.Specifies the cryptographic signature for the <Signature> element. Se la firma non viene verificata, una parte del <Signature> blocco è stata manomessa e il documento viene considerato non valido.If this signature does not verify, then some portion of the <Signature> block was tampered with, and the document is considered invalid. Fino a quando il <CanonicalizationMethod> valore è attendibile, questo valore è altamente resistente alla manomissione.As long as the <CanonicalizationMethod> value is trustworthy, this value is highly resistant to tampering. Questo elemento è rappresentato dalla SignatureValue Proprietà.This element is represented by the SignatureValue property.

  • URIAttributo dell'elemento. <Reference>The URI attribute of the <Reference> element

    Specifica un oggetto dati utilizzando un riferimento URI.Specifies a data object using a URI reference. Questo attributo è rappresentato dalla Reference.Uri Proprietà.This attribute is represented by the Reference.Uri property.

    • Se non si specifica l' URI attributo, ovvero si imposta la Reference.Uri proprietà su null , significa che l'applicazione ricevente deve essere in grado di identificare l'identità dell'oggetto.Not specifying the URI attribute, that is, setting the Reference.Uri property to null, means that the receiving application is expected to know the identity of the object. Nella maggior parte dei casi, un URI comporterà la generazione di null un'eccezione.In most cases, a null URI will result in an exception being thrown. Non usare un null URI, a meno che l'applicazione non stia interoperando con un protocollo che lo richiede.Do not use a null URI, unless your application is interoperating with a protocol which requires it.

    • URISe si imposta l'attributo su una stringa vuota, viene indicato che l'elemento radice del documento viene firmato, una forma di firma in busta.Setting the URI attribute to an empty string indicates that the root element of the document is being signed, a form of enveloped signature.

    • Se il valore di URI attribute inizia con #, il valore deve essere risolto in un elemento del documento corrente.If the value of URI attribute starts with #, then the value must resolve to an element in the current document. Questo modulo può essere usato con uno qualsiasi dei tipi di firma supportati (firma in busta, firma di inviluppo o firma scollegata interna).This form can be used with any of the supported signature types (enveloped signature, enveloping signature or internal detached signature).

    • Qualsiasi altra operazione viene considerata una firma scollegata della risorsa esterna e non è supportata dalla SignedXml classe.Anything else is considered an external resource detached signature and is not supported by the SignedXml class.

  • Elemento <Transforms>The <Transforms> element

    Contiene un elenco ordinato di <Transform> elementi che descrivono come il firmatario ha ottenuto l'oggetto dati digestato.Contains an ordered list of <Transform> elements that describe how the signer obtained the data object that was digested. Un algoritmo di trasformazione è simile al metodo di canonizzazione, ma anziché riscrivere l' <Signature> elemento, riscrive il contenuto identificato dall' URI attributo dell' <Reference> elemento.A transform algorithm is similar to the canonicalization method, but instead of rewriting the <Signature> element, it rewrites the content identified by the URI attribute of the <Reference> element. L' <Transforms> elemento è rappresentato dalla TransformChain classe.The <Transforms> element is represented by the TransformChain class.

    • Ogni algoritmo di trasformazione viene definito come input XML (un set di nodi XPath) o byte come input.Each transform algorithm is defined as taking either XML (an XPath node-set) or bytes as input. Se il formato dei dati correnti è diverso dai requisiti di input di trasformazione, vengono applicate le regole di conversione.If the format of the current data differs from the transform input requirements, conversion rules are applied.

    • Ogni algoritmo di trasformazione viene definito come output XML o byte.Each transform algorithm is defined as producing either XML or bytes as the output.

    • Se l'output dell'ultimo algoritmo di trasformazione non è definito in byte (o se non è stata specificata alcuna trasformazione), il metodo di canonizzazione viene usato come trasformazione implicita (anche se nell'elemento è stato specificato un algoritmo diverso <CanonicalizationMethod> ).If the output of the last transform algorithm is not defined in bytes (or no transforms were specified), then the canonicalization method is used as an implicit transform (even if a different algorithm was specified in the <CanonicalizationMethod> element).

    • Il valore http://www.w3.org/2000/09/xmldsig#enveloped-signature per l'algoritmo Transform codifica una regola interpretata come rimuovere l' <Signature> elemento dal documento.A value of http://www.w3.org/2000/09/xmldsig#enveloped-signature for the transform algorithm encodes a rule which is interpreted as remove the <Signature> element from the document. In caso contrario, un verificatore di una firma protetta eseguirà il digest del documento, inclusa la firma, ma il firmatario avrebbe effettuato il digest del documento prima dell'applicazione della firma, ottenendo risposte diverse.Otherwise, a verifier of an enveloped signature will digest the document, including the signature, but the signer would have digested the document before the signature was applied, leading to different answers.

  • Elemento <DigestMethod>The <DigestMethod> element

    Identifica il metodo digest (hash crittografico) da applicare al contenuto trasformato identificato dall' URI attributo dell' <Reference> elemento.Identifies the digest (cryptographic hash) method to apply on the transformed content identified by the URI attribute of the <Reference> element. Questa proprietà è rappresentata dalla Reference.DigestMethod Proprietà.This is represented by the Reference.DigestMethod property.

Scelta di un metodo di canonizzazioneChoosing a canonicalization method

A meno che non si stia interoperando con una specifica che richiede l'uso di un valore diverso, è consigliabile usare il metodo di canonizzazione .NET predefinito, ovvero l'algoritmo XML-C14N 1,0, il cui valore è http://www.w3.org/TR/2001/REC-xml-c14n-20010315 .Unless interoperating with a specification which requires the use of a different value, we recommend that you use the default .NET canonicalization method, which is the XML-C14N 1.0 algorithm, whose value is http://www.w3.org/TR/2001/REC-xml-c14n-20010315. È necessario che l'algoritmo XML-C14N 1,0 sia supportato da tutte le implementazioni di XMLDSIG, in particolare perché si tratta di una trasformazione finale implicita da applicare.The XML-C14N 1.0 algorithm is required to be supported by all implementations of XMLDSIG, particularly as it is an implicit final transform to apply.

Sono disponibili versioni degli algoritmi di canonizzazione che supportano la conservazione dei commenti.There are versions of canonicalization algorithms which support preserving comments. I metodi di canonizzazione con mantenimento dei commenti non sono consigliati perché violano il principio "Sign What is seen".Comment-preserving canonicalization methods are not recommended because they violate the "sign what is seen" principle. Ovvero, i commenti in un <Signature> elemento non modificheranno la logica di elaborazione per la modalità di esecuzione della firma, bensì semplicemente il valore della firma.That is, the comments in a <Signature> element will not alter the processing logic for how the signature is performed, merely what the signature value is. In combinazione con un algoritmo di firma debole, consentire l'inclusione dei commenti fornisce a un utente malintenzionato la libertà necessaria per forzare una collisione hash, rendendo legittimo un documento manomesso.When combined with a weak signature algorithm, allowing the comments to be included gives an attacker unnecessary freedom to force a hash collision, making a tampered document appear legitimate. Nel .NET Framework, per impostazione predefinita sono supportati solo canonicalizers predefiniti.In the .NET Framework, only built-in canonicalizers are supported by default. Per supportare canonicalizers aggiuntivi o personalizzati, vedere la SafeCanonicalizationMethods Proprietà.To support additional or custom canonicalizers, see the SafeCanonicalizationMethods property. Se il documento usa un metodo di canonizzazione che non è presente nella raccolta rappresentata dalla SafeCanonicalizationMethods proprietà, il CheckSignature metodo restituirà false .If the document uses a canonicalization method that is not in the collection represented by the SafeCanonicalizationMethods property, then the CheckSignature method will return false.

Nota

Un'applicazione estremamente difensiva può rimuovere tutti i valori che non prevede che i firmatari usino dalla SafeCanonicalizationMethods raccolta.An extremely defensive application can remove any values it does not expect signers to use from the SafeCanonicalizationMethods collection.

I valori di riferimento sono protetti da eventuali manomissioni?Are the Reference values safe from tampering?

Sì, i <Reference> valori sono sicuri da eventuali manomissioni.Yes, the <Reference> values are safe from tampering. .NET verifica il <SignatureValue> calcolo prima di elaborare i <Reference> valori e le trasformazioni associate e interromperà presto per evitare istruzioni di elaborazione potenzialmente dannose..NET verifies the <SignatureValue> computation before processing any of the <Reference> values and their associated transforms, and will abort early to avoid potentially malicious processing instructions.

Scelta degli elementi da firmareChoosing the elements to sign

È consigliabile usare il valore di "" per l' URI attributo (o impostare la Uri proprietà su una stringa vuota), se possibile.We recommend that you use the value of "" for the URI attribute (or set the Uri property to an empty string), if possible. Ciò significa che l'intero documento viene considerato per il calcolo del digest, il che significa che l'intero documento è protetto dalle manomissioni.This means the whole document is considered for the digest computation, which means the whole document is protected from tampering.

È molto comune visualizzare URI i valori sotto forma di ancoraggi, ad esempio #foo, che fanno riferimento a un elemento il cui attributo ID è "foo".It is very common to see URI values in the form of anchors such as #foo, referring to an element whose ID attribute is "foo". Sfortunatamente, è facile che questo venga manomesso perché include solo il contenuto dell'elemento di destinazione, non il contesto.Unfortunately, it is easy for this to be tampered with because this includes only the content of the target element, not the context. L'abuso di questa distinzione è noto come wrapping della firma XML (XSW).Abusing this distinction is known as XML Signature Wrapping (XSW).

Se l'applicazione considera i commenti come semantici (operazione non comune quando si utilizza XML), è necessario utilizzare "#xpointer (/)" invece di "" e "#xpointer (ID (' foo '))" anziché "#foo".If your application considers comments to be semantic (which is not common when dealing with XML), then you should use "#xpointer(/)" instead of "", and "#xpointer(id('foo'))" instead of "#foo". Le versioni di #xpointer vengono interpretate come commenti di inclusione, mentre i moduli ShortName escludono i commenti.The #xpointer versions are interpreted as including comments, while the shortname forms are excluding comments.

Se è necessario accettare documenti che sono solo parzialmente protetti e si desidera assicurarsi che si stia leggendo lo stesso contenuto protetto dalla firma, utilizzare il GetIdElement metodo.If you need to accept documents which are only partially protected and you want to ensure that you are reading the same content that the signature protected, use the GetIdElement method.

Considerazioni sulla sicurezza relative all'elemento infoSecurity considerations about the KeyInfo element

I dati nell'elemento facoltativo <KeyInfo> (ovvero la KeyInfo proprietà), che contiene una chiave per convalidare la firma, non devono essere attendibili.The data in the optional <KeyInfo> element (that is, the KeyInfo property), which contains a key to validate the signature, should not be trusted.

In particolare, quando il KeyInfo valore rappresenta una chiave pubblica RSA, DSA o ECDSA, il documento potrebbe essere stato manomesso, nonostante il CheckSignature metodo che segnala che la firma è valida.In particular, when the KeyInfo value represents a bare RSA, DSA or ECDSA public key, the document could have been tampered with, despite the CheckSignature method reporting that the signature is valid. Questo problema può verificarsi perché l'entità che esegue la manomissione deve solo generare una nuova chiave e firmare nuovamente il documento manomesso con la nuova chiave.This can happen because the entity doing the tampering just has to generate a new key and re-sign the tampered document with that new key. Quindi, a meno che l'applicazione non verifichi che la chiave pubblica è un valore previsto, il documento deve essere considerato come se fosse stato alterato.So, unless your application verifies that the public key is an expected value, the document should be treated as if it were tampered with. A tale scopo, l'applicazione deve esaminare la chiave pubblica incorporata nel documento e verificarla rispetto a un elenco di valori noti per il contesto del documento.This requires that your application examine the public key embedded within the document and verify it against a list of known values for the document context. Se, ad esempio, il documento potrebbe essere riconosciuto come emesso da un utente noto, è necessario controllare la chiave in base a un elenco di chiavi note utilizzate da tale utente.For example, if the document could be understood to be issued by a known user, you'd check the key against a list of known keys used by that user.

È anche possibile verificare la chiave dopo l'elaborazione del documento usando il CheckSignatureReturningKey metodo, anziché usare il CheckSignature metodo.You can also verify the key after processing the document by using the CheckSignatureReturningKey method, instead of using the CheckSignature method. Tuttavia, per una sicurezza ottimale, è necessario verificare la chiave in anticipo.But, for the optimal security, you should verify the key beforehand.

In alternativa, provare a provare le chiavi pubbliche registrate dell'utente, anziché leggere ciò che è presente nell' <KeyInfo> elemento.Alternately, consider trying the user's registered public keys, rather than reading what's in the <KeyInfo> element.

Considerazioni sulla sicurezza sull'elemento X509DataSecurity considerations about the X509Data element

L' <X509Data> elemento facoltativo è figlio dell' <KeyInfo> elemento e contiene uno o più certificati o identificatori X509 per i certificati X509.The optional <X509Data> element is a child of the <KeyInfo> element and contains one or more X509 certificates or identifiers for X509 certificates. Anche i dati nell' <X509Data> elemento non devono essere intrinsecamente attendibili.The data in the <X509Data> element should also not be inherently trusted.

Quando si verifica un documento con l' <X509Data> elemento incorporato, .NET verifica solo che i dati vengano risolti in un certificato X509 la cui chiave pubblica può essere utilizzata correttamente per convalidare la firma del documento.When verifying a document with the embedded <X509Data> element, .NET verifies only that the data resolves to an X509 certificate whose public key can be successfully used to validate the document signature. A differenza della chiamata al CheckSignature metodo con il verifySignatureOnly parametro impostato su false , non viene eseguito alcun controllo di revoca, non viene controllato alcun trust della catena e non viene verificata alcuna scadenza.Unlike calling the CheckSignature method with the verifySignatureOnly parameter set to false, no revocation check is performed, no chain trust is checked, and no expiration is verified. Anche se l'applicazione estrae il certificato stesso e lo passa al CheckSignature metodo con il verifySignatureOnly parametro impostato su false , la convalida non è ancora sufficiente per impedire la manomissione dei documenti.Even if your application extracts the certificate itself and passes it to the CheckSignature method with the verifySignatureOnly parameter set to false, that is still not sufficient validation to prevent document tampering. Il certificato deve ancora essere verificato come appropriato per il documento firmato.The certificate still needs to be verified as being appropriate for the document being signed.

L'uso di un certificato di firma incorporato può fornire utili strategie di rotazione delle chiavi, sia nella <X509Data> sezione che nel contenuto del documento.Using an embedded signing certificate can provide useful key rotation strategies, whether in the <X509Data> section or in the document content. Quando si usa questo approccio, un'applicazione deve estrarre il certificato manualmente ed eseguire una convalida simile alla seguente:When using this approach an application should extract the certificate manually and perform validation similar to:

  • Il certificato è stato emesso direttamente o tramite una catena da un'autorità di certificazione (CA) il cui certificato pubblico è incorporato nell'applicazione.The certificate was issued directly or via a chain by a Certificate Authority (CA) whose public certificate is embedded in the application.

    L'uso dell'elenco di attendibilità fornito dal sistema operativo senza controlli aggiuntivi, ad esempio un nome soggetto noto, non è sufficiente per impedire manomissioni in SignedXml .Using the OS-provided trust list without additional checks, such as a known subject name, is not sufficient to prevent tampering in SignedXml.

  • Il certificato è stato verificato che non sia scaduto al momento della firma del documento (o "ora" per l'elaborazione dei documenti quasi in tempo reale).The certificate is verified to have not been expired at the time of document signing (or "now" for near real-time document processing).

  • Per i certificati di lunga durata emessi da un'autorità di certificazione che supporta la revoca, verificare che il certificato non sia stato revocato.For long-lived certificates issued by a CA which supports revocation, verify the certificate was not revoked.

  • Il soggetto del certificato viene verificato come appropriato per il documento corrente.The certificate subject is verified as being appropriate to the current document.

Scelta dell'algoritmo TransformChoosing the transform algorithm

Se si interopera con una specifica che ha determinato valori specifici, ad esempio XrML, è necessario seguire la specifica.If you are interoperating with a specification which has dictated specific values (such as XrML), then you need to follow the specification. Se si dispone di una firma protetta, ad esempio quando si firma l'intero documento, è necessario usare http://www.w3.org/2000/09/xmldsig#enveloped-signature (rappresentato dalla XmlDsigEnvelopedSignatureTransform classe).If you have an enveloped signature (such as when signing the whole document), then you need to use http://www.w3.org/2000/09/xmldsig#enveloped-signature (represented by the XmlDsigEnvelopedSignatureTransform class). È possibile specificare anche la trasformazione implicita XML-C14N, ma non è necessario.You can specify the implicit XML-C14N transform as well, but it's not necessary. Per una firma imbustata o scollegata, non sono necessarie trasformazioni.For an enveloping or detached signature, no transforms are required. La trasformazione implicita XML-C14N si occupa di tutto.The implicit XML-C14N transform takes care of everything.

Con la sicurezza aggiornata introdotta dal Bollettino Microsoft sulla sicurezza MS16-035, .NET ha limitato le trasformazioni che possono essere usate nella verifica dei documenti per impostazione predefinita, con trasformazioni non attendibili che causano CheckSignature sempre la restituzione false .With the security updated introduced by the Microsoft Security Bulletin MS16-035, .NET has restricted what transforms can be used in document verification by default, with untrusted transforms causing CheckSignature to always return false. In particolare, le trasformazioni che richiedono input aggiuntivo (specificato come elementi figlio nel codice XML) non sono più consentite a causa della loro suscettibilità di abuso da parte di utenti malintenzionati.In particular, transforms which require additional input (specified as child elements in the XML) are no longer allowed due to their susceptibility of abuse by malicious users. Il W3C consiglia di evitare le trasformazioni XPath e XSLT, ovvero le due trasformazioni principali interessate da tali restrizioni.The W3C advises avoiding the XPath and XSLT transforms, which are the two main transforms affected by these restrictions.

Il problema con i riferimenti esterniThe problem with external references

Se un'applicazione non verifica che i riferimenti esterni siano appropriati per il contesto corrente, è possibile abusarne in modi che forniscono molte vulnerabilità di sicurezza, tra cui Denial of Service, Distributed Reflection Denial of Service, divulgazione di informazioni, bypass della firma ed esecuzione di codice in modalità remota.If an application does not verify that external references seem appropriate for the current context, they can be abused in ways that provide for many security vulnerabilities (including Denial of Service, Distributed Reflection Denial of Service, Information Disclosure, Signature Bypass, and Remote Code Execution). Anche se un'applicazione deve convalidare l'URI di riferimento esterno, si verificherà un problema della risorsa che viene caricata due volte: una volta quando l'applicazione la legge e una volta quando la SignedXml legge.Even if an application were to validate the external reference URI, there would remain a problem of the resource being loaded twice: once when your application reads it, and once when SignedXml reads it. Poiché non vi è alcuna garanzia che la procedura di lettura e di verifica dei documenti dell'applicazione abbia lo stesso contenuto, la firma non fornisce l'attendibilità.Since there's no guarantee that the application read and document verify steps have the same content, the signature does not provide trustworthiness.

Considerati i rischi dei riferimenti esterni, genererà SignedXml un'eccezione quando viene rilevato un riferimento esterno.Given the risks of external references, SignedXml will throw an exception when an external reference is encountered. Per ulteriori informazioni su questo problema, vedere l' articolo KB 3148821.For more information about this issue, see KB article 3148821.

Costruttori

SignedXml()

Inizializza una nuova istanza della classe SignedXml.Initializes a new instance of the SignedXml class.

SignedXml(XmlDocument)

Consente di inizializzare una nuova istanza della classe SignedXml dal documento XML specificato.Initializes a new instance of the SignedXml class from the specified XML document.

SignedXml(XmlElement)

Consente di inizializzare una nuova istanza della classe SignedXml dall'oggetto XmlElement specificato.Initializes a new instance of the SignedXml class from the specified XmlElement object.

Campi

m_signature

Rappresenta l'oggetto Signature dell'oggetto SignedXml corrente.Represents the Signature object of the current SignedXml object.

m_strSigningKeyName

Rappresenta il nome della chiave installata da utilizzare per la firma dell'oggetto SignedXml.Represents the name of the installed key to be used for signing the SignedXml object.

XmlDecryptionTransformUrl

Rappresenta l'URI (Uniform Resource Identifier) di trasformazione della modalità di decrittografia XML.Represents the Uniform Resource Identifier (URI) for the XML mode decryption transformation. Questo campo è costante.This field is constant.

XmlDsigBase64TransformUrl

Rappresenta l'URI (Uniform Resource Identifier) per la trasformazione base 64.Represents the Uniform Resource Identifier (URI) for the base 64 transformation. Questo campo è costante.This field is constant.

XmlDsigC14NTransformUrl

Rappresenta l'URI (Uniform Resource Identifier) per la trasformazione XML in formato canonico.Represents the Uniform Resource Identifier (URI) for the Canonical XML transformation. Questo campo è costante.This field is constant.

XmlDsigC14NWithCommentsTransformUrl

Rappresenta l'URI (Uniform Resource Identifier) per la trasformazione XML in formato canonico, con commenti.Represents the Uniform Resource Identifier (URI) for the Canonical XML transformation, with comments. Questo campo è costante.This field is constant.

XmlDsigCanonicalizationUrl

Rappresenta l'URI (Uniform Resource Identifier) per l'algoritmo standard di conversione in formato canonico delle firme digitali XML.Represents the Uniform Resource Identifier (URI) for the standard canonicalization algorithm for XML digital signatures. Questo campo è costante.This field is constant.

XmlDsigCanonicalizationWithCommentsUrl

Rappresenta l'URI (Uniform Resource Identifier) per l'algoritmo standard di conversione in formato canonico delle firme digitali XML e comprende i commenti.Represents the Uniform Resource Identifier (URI) for the standard canonicalization algorithm for XML digital signatures and includes comments. Questo campo è costante.This field is constant.

XmlDsigDSAUrl

Rappresenta l'URI (Uniform Resource Identifier) per l'algoritmo DSA standard delle firme digitali XML.Represents the Uniform Resource Identifier (URI) for the standard DSA algorithm for XML digital signatures. Questo campo è costante.This field is constant.

XmlDsigEnvelopedSignatureTransformUrl

Rappresenta l'URI (Uniform Resource Identifier) per la trasformazione della firma protetta.Represents the Uniform Resource Identifier (URI) for enveloped signature transformation. Questo campo è costante.This field is constant.

XmlDsigExcC14NTransformUrl

Rappresenta l'URI (Uniform Resource Identifier) per la conversione in formato canonico esclusivo XML.Represents the Uniform Resource Identifier (URI) for exclusive XML canonicalization. Questo campo è costante.This field is constant.

XmlDsigExcC14NWithCommentsTransformUrl

Rappresenta l'URI (Uniform Resource Identifier) per la conversione in formato canonico esclusivo XML, con commenti.Represents the Uniform Resource Identifier (URI) for exclusive XML canonicalization, with comments. Questo campo è costante.This field is constant.

XmlDsigHMACSHA1Url

Rappresenta l'URI (Uniform Resource Identifier) per l'algoritmo HMACSHA1 standard delle firme digitali XML.Represents the Uniform Resource Identifier (URI) for the standard HMACSHA1 algorithm for XML digital signatures. Questo campo è costante.This field is constant.

XmlDsigMinimalCanonicalizationUrl

Rappresenta l'URI (Uniform Resource Identifier) per l'algoritmo standard minimo di conversione in formato canonico delle firme digitali XML.Represents the Uniform Resource Identifier (URI) for the standard minimal canonicalization algorithm for XML digital signatures. Questo campo è costante.This field is constant.

XmlDsigNamespaceUrl

Rappresenta l'URI (Uniform Resource Identifier) dello spazio dei nomi standard delle firme digitali XML.Represents the Uniform Resource Identifier (URI) for the standard namespace for XML digital signatures. Questo campo è costante.This field is constant.

XmlDsigRSASHA1Url

Rappresenta l'URI (Uniform Resource Identifier) per il metodo di firma RSA standard delle firme digitali XML.Represents the Uniform Resource Identifier (URI) for the standard RSA signature method for XML digital signatures. Questo campo è costante.This field is constant.

XmlDsigRSASHA256Url

Rappresenta l'URI (Uniform Resource Identifier) per la variazione del metodo di firma SHA-256 RSA per le firme digitali XML.Represents the Uniform Resource Identifier (URI) for the RSA SHA-256 signature method variation for XML digital signatures. Questo campo è costante.This field is constant.

XmlDsigRSASHA384Url

Rappresenta l'URI (Uniform Resource Identifier) per la variazione del metodo di firma SHA-384 RSA per le firme digitali XML.Represents the Uniform Resource Identifier (URI) for the RSA SHA-384 signature method variation for XML digital signatures. Questo campo è costante.This field is constant.

XmlDsigRSASHA512Url

Rappresenta l'URI (Uniform Resource Identifier) per la variazione del metodo di firma SHA-512 RSA per le firme digitali XML.Represents the Uniform Resource Identifier (URI) for the RSA SHA-512 signature method variation for XML digital signatures. Questo campo è costante.This field is constant.

XmlDsigSHA1Url

Rappresenta l'URI (Uniform Resource Identifier) per il metodo digest SHA1 standard per le firme digitali XML.Represents the Uniform Resource Identifier (URI) for the standard SHA1 digest method for XML digital signatures. Questo campo è costante.This field is constant.

XmlDsigSHA256Url

Rappresenta l'URI (Uniform Resource Identifier) per il metodo digest SHA256 standard per le firme digitali XML.Represents the Uniform Resource Identifier (URI) for the standard SHA256 digest method for XML digital signatures. Questo campo è costante.This field is constant.

XmlDsigSHA384Url

Rappresenta l'URI (Uniform Resource Identifier) per il metodo digest SHA384 standard per le firme digitali XML.Represents the Uniform Resource Identifier (URI) for the standard SHA384 digest method for XML digital signatures. Questo campo è costante.This field is constant.

XmlDsigSHA512Url

Rappresenta l'URI (Uniform Resource Identifier) per il metodo digest SHA512 standard per le firme digitali XML.Represents the Uniform Resource Identifier (URI) for the standard SHA512 digest method for XML digital signatures. Questo campo è costante.This field is constant.

XmlDsigXPathTransformUrl

Rappresenta l'URI (Uniform Resource Identifier) per XPath (XML Path Language).Represents the Uniform Resource Identifier (URI) for the XML Path Language (XPath). Questo campo è costante.This field is constant.

XmlDsigXsltTransformUrl

Rappresenta l'URI (Uniform Resource Identifier) per le trasformazioni XSLT.Represents the Uniform Resource Identifier (URI) for XSLT transformations. Questo campo è costante.This field is constant.

XmlLicenseTransformUrl

Rappresenta l'URI (Uniform Resource Identifier) per l'algoritmo di trasformazione delle licenza utilizzato per normalizzare le licenze XrML delle firme.Represents the Uniform Resource Identifier (URI) for the license transform algorithm used to normalize XrML licenses for signatures.

Proprietà

EncryptedXml

Ottiene o imposta un oggetto EncryptedXml che definisce le regole di elaborazione della crittografia XML.Gets or sets an EncryptedXml object that defines the XML encryption processing rules.

KeyInfo

Ottiene o imposta l'oggetto KeyInfo dell'oggetto SignedXml corrente.Gets or sets the KeyInfo object of the current SignedXml object.

Resolver

Imposta l'oggetto XmlResolver corrente.Sets the current XmlResolver object.

SafeCanonicalizationMethods

Ottiene i nomi dei metodi di cui sono esplicitamente consentiti gli algoritmi di canonizzazione.Gets the names of methods whose canonicalization algorithms are explicitly allowed.

Signature

Ottiene l'oggetto Signature dell'oggetto SignedXml corrente.Gets the Signature object of the current SignedXml object.

SignatureFormatValidator

Ottiene un delegato che verrà chiamato per convalidare il formato (non la sicurezza tramite crittografia) di una firma XML.Gets a delegate that will be called to validate the format (not the cryptographic security) of an XML signature.

SignatureLength

Ottiene la lunghezza della firma per l'oggetto SignedXml corrente.Gets the length of the signature for the current SignedXml object.

SignatureMethod

Ottiene il metodo di firma per l'oggetto SignedXml corrente.Gets the signature method of the current SignedXml object.

SignatureValue

Ottiene il valore di firma dell'oggetto SignedXml corrente.Gets the signature value of the current SignedXml object.

SignedInfo

Ottiene l'oggetto SignedInfo dell'oggetto SignedXml corrente.Gets the SignedInfo object of the current SignedXml object.

SigningKey

Ottiene o imposta la chiave dell'algoritmo asimmetrico utilizzata per la firma dell'oggetto SignedXml.Gets or sets the asymmetric algorithm key used for signing a SignedXml object.

SigningKeyName

Ottiene o imposta il nome della chiave installata da utilizzare per la firma dell'oggetto SignedXml.Gets or sets the name of the installed key to be used for signing the SignedXml object.

Metodi

AddObject(DataObject)

Consente di aggiungere un oggetto DataObject all'elenco degli oggetti ai quali apporre la firma.Adds a DataObject object to the list of objects to be signed.

AddReference(Reference)

Consente di aggiungere un oggetto Reference all'oggetto SignedXml che descrive il metodo e il valore di digest, nonché la trasformazione da utilizzare per la creazione della firma digitale XML.Adds a Reference object to the SignedXml object that describes a digest method, digest value, and transform to use for creating an XML digital signature.

CheckSignature()

Determina se la proprietà Signature viene verificata mediante la chiave pubblica della firma.Determines whether the Signature property verifies using the public key in the signature.

CheckSignature(AsymmetricAlgorithm)

Determina se la proprietà Signature viene verificata per la chiave specificata.Determines whether the Signature property verifies for the specified key.

CheckSignature(KeyedHashAlgorithm)

Determina se viene effettuata la verifica della proprietà Signature per l'algoritmo di codice MAC (Message Authentication Code) specificato.Determines whether the Signature property verifies for the specified message authentication code (MAC) algorithm.

CheckSignature(X509Certificate2, Boolean)

Determina se la verifica della proprietà Signature viene effettuata per l'oggetto X509Certificate2 specificato e, eventualmente, se il certificato è valido.Determines whether the Signature property verifies for the specified X509Certificate2 object and, optionally, whether the certificate is valid.

CheckSignatureReturningKey(AsymmetricAlgorithm)

Determina se la proprietà Signature viene verificata mediante la chiave pubblica della firma.Determines whether the Signature property verifies using the public key in the signature.

ComputeSignature()

Consente di calcolare una firma digitale XML.Computes an XML digital signature.

ComputeSignature(KeyedHashAlgorithm)

Consente di elaborare una firma digitale XML utilizzando l'algoritmo di codice MAC (Message Authentication Code) specificato.Computes an XML digital signature using the specified message authentication code (MAC) algorithm.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetIdElement(XmlDocument, String)

Restituisce l'oggetto XmlElement con l'ID specificato dall'oggetto XmlDocument indicato.Returns the XmlElement object with the specified ID from the specified XmlDocument object.

GetPublicKey()

Restituisce la chiave pubblica della firma.Returns the public key of a signature.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
GetXml()

Restituisce la rappresentazione XML dell'oggetto SignedXml.Returns the XML representation of a SignedXml object.

LoadXml(XmlElement)

Consente di caricare uno stato della classe SignedXml da un elemento XML.Loads a SignedXml state from an XML element.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Si applica a