SignedXml Sınıf

Tanım

XML imzaları oluşturmayı kolaylaştırmak için bir çekirdek XML imza nesnesi üzerinde sarmalayıcı sağlar.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
Devralma
SignedXml

Örnekler

Aşağıdaki kod örneği, bir XML belgesinin bir paketlenmiş imza kullanılarak nasıl imzalandığını ve doğrulandığını gösterir.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 

Aşağıdaki kod örneği, enveloping imzasını kullanarak bir XML belgesinin tek bir öğesinin nasıl imzalandığını ve doğrulandığını gösterir.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

Açıklamalar

SignedXmlSınıfı, XMLDSıG (XML dijital imzası) olarak da bilinen World Wide Web Konsorsiyumu (W3C) XML imzası sözdizimi ve işleme belirtiminin.net uygulamasıdır.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, bir XML belgesinin tamamını veya bir kısmını veya bir Tekdüzen Kaynak tanımlayıcısından (URI) adreslenebilir olan diğer verileri imzalamak ve doğrulamak için standartlara dayalı, birlikte çalışabilen bir yoldur.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).

SignedXmlIMZALı XML verilerini uygulamalar veya kuruluşlar arasında standart bir şekilde paylaşmanız her seferinde sınıfını kullanın.Use the SignedXml class whenever you need to share signed XML data between applications or organizations in a standard way. Bu sınıf kullanılarak imzalanan tüm veriler, XMLDSIG için W3C belirtiminin herhangi bir uyumlu uygulamasıyla doğrulanabilir.Any data signed using this class can be verified by any conforming implementation of the W3C specification for XMLDSIG.

SignedXmlSınıfı, aşağıdaki üç tür XML dijital imzayı oluşturmanızı sağlar:The SignedXml class allows you to create the following three kinds of XML digital signatures:

İmza türüSignature Type AçıklamaDescription
Zarflanan imzaEnveloped signature İmza, imzalanmakta olan XML öğesi içinde yer alır.The signature is contained within the XML element being signed.
Enveloping imzasıEnveloping signature İmzalı XML öğesi içinde bulunur <Signature> .The signed XML is contained within the <Signature> element.
İç ayrılmış imzaInternal detached signature İmza ve imzalı XML aynı belgedir, ancak hiçbir öğe diğerini içermez.The signature and signed XML are in the same document, but neither element contains the other.

Ayrıca, veri ve imza ayrı XML belgelerinde olduğunda, dış ayrılmış imza olarak adlandırılan dört tür imza de vardır.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. Dış ayrılmış imzalar sınıf tarafından desteklenmiyor SignedXml .External detached signatures are not supported by the SignedXml class.

XML Imzasının yapısıThe structure of an XML Signature

XMLDSIG, bir <Signature> XML belgesinin dijital imzasını veya BIR URI 'den adreslenebilir diğer verileri içeren bir öğesi oluşturur.XMLDSIG creates a <Signature> element, which contains a digital signature of an XML document or other data that is addressable from a URI. <Signature>Öğesi, isteğe bağlı olarak imzayı doğrulayan bir anahtarın nerede bulunacağı ve imzalanmak üzere hangi şifreleme algoritmasının kullanıldığı hakkında bilgi içerebilir.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. Temel yapı aşağıdaki gibidir: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>

Bu yapının ana kısımları şunlardır:The main parts of this structure are:

  • <CanonicalizationMethod>ÖğeThe <CanonicalizationMethod> element

    Signatureİmza doğrulaması için ÖĞEYI XML/metinden bayt olarak yeniden yazma kurallarını belirtir.Specifies the rules for rewriting the Signature element from XML/text into bytes for signature validation. .NET ' te varsayılan değer http://www.w3.org/TR/2001/REC-xml-c14n-20010315 , güvenilir bir algoritmayı tanımlar.The default value in .NET is http://www.w3.org/TR/2001/REC-xml-c14n-20010315, which identifies a trustworthy algorithm. Bu öğe, özelliği tarafından temsil edilir SignedInfo.CanonicalizationMethod .This element is represented by the SignedInfo.CanonicalizationMethod property.

  • <SignatureMethod>ÖğeThe <SignatureMethod> element

    İmza oluşturma ve doğrulama için kullanılan algoritmayı belirtir ve <Signature> içindeki değeri üretmek için öğesine uygulanır <SignatureValue> .Specifies the algorithm used for signature generation and validation, which was applied to the <Signature> element to produce the value in <SignatureValue>. Önceki örnekte, değer http://www.w3.org/2000/09/xmldsig#rsa-sha1 BIR RSA PKCS1 SHA-1 imzasını tanımlar.In the previous example, the value http://www.w3.org/2000/09/xmldsig#rsa-sha1 identifies an RSA PKCS1 SHA-1 signature. SHA-1 ile ilgili çarpışma sorunları nedeniyle, Microsoft SHA-256 veya daha iyi bir güvenlik modeli önerir.Due to collision problems with SHA-1, Microsoft recommends a security model based on SHA-256 or better. Bu öğe, özelliği tarafından temsil edilir SignatureMethod .This element is represented by the SignatureMethod property.

  • <SignatureValue>ÖğeThe <SignatureValue> element

    Öğe için şifreleme imzasını belirtir <Signature> .Specifies the cryptographic signature for the <Signature> element. Bu imza doğrulanmaz, bloğun bir kısmı <Signature> ile oynanmış demektir ve belge geçersiz olarak kabul edilir.If this signature does not verify, then some portion of the <Signature> block was tampered with, and the document is considered invalid. <CanonicalizationMethod>Değer güvenilir olduğu sürece, bu değer izinsiz değişikliklere karşı çok daha dayanıklıdır.As long as the <CanonicalizationMethod> value is trustworthy, this value is highly resistant to tampering. Bu öğe, özelliği tarafından temsil edilir SignatureValue .This element is represented by the SignatureValue property.

  • URI <Reference> Öğesinin özniteliğiThe URI attribute of the <Reference> element

    Bir URI başvurusu kullanarak bir veri nesnesini belirtir.Specifies a data object using a URI reference. Bu öznitelik, özelliği tarafından temsil edilir Reference.Uri .This attribute is represented by the Reference.Uri property.

    • Özniteliği belirtmeyen, URI diğer bir deyişle, Reference.Uri özelliğinin olarak ayarlanması, null alıcı uygulamanın nesnenin kimliğini öğrenmesi beklenen anlamına gelir.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. Çoğu durumda, bir null URI bir özel durum oluşmasına neden olur.In most cases, a null URI will result in an exception being thrown. nullUygulamanız bunu gerektiren bir protokolle birlikte ilişkilendirilmediği takdirde URI kullanmayın.Do not use a null URI, unless your application is interoperating with a protocol which requires it.

    • URIÖzniteliği boş bir dizeye ayarlamak, belgenin kök öğesinin bir paketlenmiş imza formu olarak imzalandığını gösterir.Setting the URI attribute to an empty string indicates that the root element of the document is being signed, a form of enveloped signature.

    • URIÖzniteliğin değeri # ile başlıyorsa, değer geçerli belgedeki bir öğeye çözümlenmelidir.If the value of URI attribute starts with #, then the value must resolve to an element in the current document. Bu form desteklenen imza türleri (zarflanan imza, enveloping imzası veya iç ayrılmış imza) ile kullanılabilir.This form can be used with any of the supported signature types (enveloped signature, enveloping signature or internal detached signature).

    • Başka herhangi bir şey, dış kaynak ayrılmış imzası olarak değerlendirilir ve sınıfı tarafından desteklenmez SignedXml .Anything else is considered an external resource detached signature and is not supported by the SignedXml class.

  • <Transforms>ÖğeThe <Transforms> element

    <Transform>İmzalayanın, veri nesnesini bir şekilde nasıl edinildiği hakkında betimleyen öğelerin sıralı bir listesini içerir.Contains an ordered list of <Transform> elements that describe how the signer obtained the data object that was digested. Dönüşüm algoritması kurallı metoda benzerdir, ancak öğesini yeniden yazmak yerine, <Signature> öğesinin özniteliği tarafından tanımlanan içeriği yeniden yazar URI <Reference> .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. <Transforms>Öğesi sınıfı tarafından temsil edilir TransformChain .The <Transforms> element is represented by the TransformChain class.

    • Her dönüşüm algoritması, girdi olarak XML (XPath düğüm kümesi) veya bayt almak için tanımlanır.Each transform algorithm is defined as taking either XML (an XPath node-set) or bytes as input. Geçerli verilerin biçimi dönüştürme girişi gereksinimlerinden farklıysa, dönüştürme kuralları uygulanır.If the format of the current data differs from the transform input requirements, conversion rules are applied.

    • Her dönüşüm algoritması, çıkış olarak XML veya bayt üreten şekilde tanımlanır.Each transform algorithm is defined as producing either XML or bytes as the output.

    • Son dönüştürme algoritmasının çıktısı bayt cinsinden tanımlanmazsa (veya hiçbir dönüşüm belirtilmemişse), kurallı kullanım yöntemi örtük bir dönüşüm olarak kullanılır (öğesinde farklı bir algoritma belirtilmiş olsa bile <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).

    • http://www.w3.org/2000/09/xmldsig#enveloped-signatureDönüştürme algoritması için bir değeri, öğeyi belgeden kaldır olarak yorumlanan bir kuralı kodluyor <Signature> .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. Aksi takdirde, bir zarfla imza dahil olmak üzere belgeyi özetlemesi, ancak imza uygulanmadan önce, farklı yanıtlara bir işlem yapmadan önce imzalayan belgeyi bir Özet olarak görür.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.

  • <DigestMethod>ÖğeThe <DigestMethod> element

    Öğesinin özniteliği tarafından tanımlanan dönüştürülmüş içerikte uygulanacak Özet (şifreleme karması) yöntemini tanımlar URI <Reference> .Identifies the digest (cryptographic hash) method to apply on the transformed content identified by the URI attribute of the <Reference> element. Bu, özelliği tarafından temsil edilir Reference.DigestMethod .This is represented by the Reference.DigestMethod property.

Kurallaştırma yöntemi seçmeChoosing a canonicalization method

Farklı bir değer kullanımını gerektiren bir belirtimle birlikte çalışma olmadığı takdirde, değeri olan XML-C14N 1,0 algoritması olan varsayılan .NET kurallı kullanım yöntemini kullanmanızı öneririz 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. XML-C14N 1,0 algoritmasının, özellikle de örtük bir son dönüşüm olduğu için, XMLDSıG 'ın tüm uygulamaları tarafından desteklenmesi gerekir.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.

Açıklamaları korumayı destekleyen kurallı kullanım algoritmalarının sürümleri vardır.There are versions of canonicalization algorithms which support preserving comments. Açıklama ile koruma özellikleri, "neyin görüldüğünü imzala" prensibi ihlal ettiğinden önerilmez.Comment-preserving canonicalization methods are not recommended because they violate the "sign what is seen" principle. Diğer bir deyişle, bir öğesindeki Yorumlar <Signature> imza nasıl gerçekleştirildiğiyle ilgili işlem mantığını değiştirmez, yalnızca imza değeri olarak değişir.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. Zayıf imza algoritmasıyla birleştirildiğinde, yorumların dahil edilmesini sağlamak, bir saldırganın karma çarpışmayı zorlamaya zorlanmasına izin vermek için gereksiz bir belgenin yasal görünmesini sağlar.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. .NET Framework, varsayılan olarak yalnızca yerleşik canonicalizers desteklenir.In the .NET Framework, only built-in canonicalizers are supported by default. Ek veya özel canonicalizers desteklemek için, özelliğine bakın SafeCanonicalizationMethods .To support additional or custom canonicalizers, see the SafeCanonicalizationMethods property. Belge, özelliği tarafından temsil edilen koleksiyonda olmayan bir kurallı kullanım yöntemi kullanıyorsa SafeCanonicalizationMethods , CheckSignature yöntemi döndürür 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.

Not

Son savunma uygulaması, imzalayanların koleksiyondan kullanmasını beklemediği tüm değerleri kaldırabilir SafeCanonicalizationMethods .An extremely defensive application can remove any values it does not expect signers to use from the SafeCanonicalizationMethods collection.

Başvuru değerleri izinsiz güvenli mi?Are the Reference values safe from tampering?

Evet, <Reference> değerler izinsiz güvenli.Yes, the <Reference> values are safe from tampering. .NET, <SignatureValue> <Reference> değerleri ve bunlarla ilişkili dönüştürmeleri işlemeden önce hesaplamayı doğrular ve potansiyel olarak kötü amaçlı işlem yönergelerinden kaçınmak için erken durdurulacak..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.

İmzalanacak öğeleri seçmeChoosing the elements to sign

Mümkünse, özniteliği için "" değerini kullanmanızı öneririz URI (veya Uri özelliği boş bir dize olarak ayarlayabilirsiniz).We recommend that you use the value of "" for the URI attribute (or set the Uri property to an empty string), if possible. Bu, tüm belgenin Özet hesaplama için kabul edildiği anlamına gelir. Bu, belgenin tamamının izinsiz korunduğu anlamına gelir.This means the whole document is considered for the digest computation, which means the whole document is protected from tampering.

URIDeğerleri, ID özniteliği "foo" olan bir öğeye başvuran #foo gibi Tutturucuların biçiminde görmek çok yaygındır.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". Ne yazık ki, bağlam değil yalnızca hedef öğenin içeriğini içerdiğinden bunun üzerinde oynanmış olması kolaydır.Unfortunately, it is easy for this to be tampered with because this includes only the content of the target element, not the context. Bu ayrımı kullanmak XML Imza sarmalama (XSW) olarak bilinir.Abusing this distinction is known as XML Signature Wrapping (XSW).

Uygulamanız açıklamaları anlam (XML ile ilgilenirken yaygın değil) anlamlı olacak şekilde düşünürken, "#foo" yerine "" ve "#xpointer (kimlik (' foo '))" yerine "#xpointer (/)" kullanmanız gerekir.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". #Xpointer sürümler açıklamalar dahil olarak yorumlanır, ancak ShortName formları açıklamaları dışlarken.The #xpointer versions are interpreted as including comments, while the shortname forms are excluding comments.

Yalnızca kısmen korunan belgeleri kabul etmeniz gerekiyorsa ve imzanın koruduğu içeriği okumaktan emin olmak istiyorsanız, GetIdElement yöntemini kullanın.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.

KeyInfo öğesiyle ilgili güvenlik konularıSecurity considerations about the KeyInfo element

<KeyInfo> KeyInfo Bir imzayı doğrulamak için bir anahtar içeren isteğe bağlı öğedeki (yani, özelliği) veriler güvenilir olmamalıdır.The data in the optional <KeyInfo> element (that is, the KeyInfo property), which contains a key to validate the signature, should not be trusted.

Özellikle, KeyInfo değer bir tam RSA, dsa veya ECDSA ortak anahtarını temsil ettiğinde, CheckSignature yöntemin, imzanın geçerli olduğunu raporlamasına rağmen, belge ile oynanmış olabilir.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. Bu durum, değişiklik yapan varlığın yeni bir anahtar oluşturması ve değiştirilen belgeyi bu yeni anahtarla yeniden imzalayacağından meydana gelebilir.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. Bu nedenle, uygulamanız ortak anahtarın beklenen bir değer olduğunu doğrularsa, belge üzerinde oynanmış gibi değerlendirilmelidir.So, unless your application verifies that the public key is an expected value, the document should be treated as if it were tampered with. Bu, uygulamanızın belge içinde gömülü ortak anahtarı incelemesini ve belge bağlamı için bilinen değerler listesine karşı doğrulamasını gerektirir.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. Örneğin, belge, bilinen bir kullanıcı tarafından verilmek üzere anlaşılabildiği için, anahtarı bu kullanıcı tarafından kullanılan bilinen anahtarların bir listesine karşı kontrol edersiniz.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.

Ayrıca, yöntemini kullanarak, yöntemini kullanarak belgeyi işledikten sonra anahtarı doğrulayabilirsiniz CheckSignatureReturningKey CheckSignature .You can also verify the key after processing the document by using the CheckSignatureReturningKey method, instead of using the CheckSignature method. Ancak, en iyi güvenlik için anahtarı önceden doğrulamanız gerekir.But, for the optimal security, you should verify the key beforehand.

Alternatif olarak, öğenin öğe içinde neler olduğunu okumak yerine, kullanıcının kayıtlı ortak anahtarlarını denemeyi düşünün <KeyInfo> .Alternately, consider trying the user's registered public keys, rather than reading what's in the <KeyInfo> element.

X509Data öğesiyle ilgili güvenlik konularıSecurity considerations about the X509Data element

İsteğe bağlı <X509Data> öğe, öğesinin bir alt öğesidir <KeyInfo> ve bir veya daha fazla x509 sertifikası veya x509 sertifikaları için tanımlayıcı içerir.The optional <X509Data> element is a child of the <KeyInfo> element and contains one or more X509 certificates or identifiers for X509 certificates. <X509Data>Öğesindeki verilerin de doğal olarak güvenilir olmaması gerekir.The data in the <X509Data> element should also not be inherently trusted.

Katıştırılmış öğesiyle bir belge doğrulanırken <X509Data> , .net yalnızca verilerin belge imzasını doğrulamak için, ortak anahtarı başarıyla kullanılan bir x509 sertifikasına çözümlendiğini doğrular.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. CheckSignatureYöntemi verifySignatureOnly olarak ayarlanan parametre ile çağırmanın aksine false , iptal denetimi gerçekleştirilmez, hiçbir zincir güveni denetlenmez ve süre sonu doğrulanmaz.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. Uygulamanız sertifikayı ayıklasa ve CheckSignature parametresi olarak ayarlanmış olan yönteme geçirse de verifySignatureOnly false , belge üzerinde değişiklik yapılmasını engellemek için yeterli doğrulama yoktur.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. Sertifikanın imzalanmakta olan belgeye uygun olarak doğrulanması gerekir.The certificate still needs to be verified as being appropriate for the document being signed.

Katıştırılmış imza sertifikası kullanmak, <X509Data> bölümünde veya belge içeriğinde olan yararlı anahtar döndürme stratejileri sağlayabilir.Using an embedded signing certificate can provide useful key rotation strategies, whether in the <X509Data> section or in the document content. Bu yaklaşımı kullanırken bir uygulama sertifikayı el ile ayıklamalı ve şuna benzer bir doğrulama gerçekleştirmelidir:When using this approach an application should extract the certificate manually and perform validation similar to:

  • Sertifika, genel sertifikası uygulamaya eklenmiş olan bir sertifika yetkilisi (CA) tarafından doğrudan veya bir zincir aracılığıyla verilmiş.The certificate was issued directly or via a chain by a Certificate Authority (CA) whose public certificate is embedded in the application.

    Bilinen bir konu adı gibi ek denetimler olmadan işletim sistemi tarafından sunulan güven listesinin kullanılması, üzerinde değişiklik yapılmasını engellemek için yeterli değildir SignedXml .Using the OS-provided trust list without additional checks, such as a known subject name, is not sufficient to prevent tampering in SignedXml.

  • Belge imzalama sırasında sertifikanın süresi dolmadı (veya neredeyse gerçek zamanlı belge işleme için "Şimdi").The certificate is verified to have not been expired at the time of document signing (or "now" for near real-time document processing).

  • İptali destekleyen bir CA tarafından verilen uzun süreli sertifikalar için, sertifikanın iptal edilmediğini doğrulayın.For long-lived certificates issued by a CA which supports revocation, verify the certificate was not revoked.

  • Sertifika konusu, geçerli belgeye uygun şekilde doğrulanır.The certificate subject is verified as being appropriate to the current document.

Dönüştürme algoritmasını seçmeChoosing the transform algorithm

Belirli değerleri (XrML gibi) dikte eden bir belirtimle birlikte çalışıyorsanız, belirtimi izlemeniz gerekir.If you are interoperating with a specification which has dictated specific values (such as XrML), then you need to follow the specification. Zarflı bir imzanız varsa (tüm belgeyi imzalarken olduğu gibi), kullanmanız gerekir http://www.w3.org/2000/09/xmldsig#enveloped-signature (sınıfı tarafından temsil edilir XmlDsigEnvelopedSignatureTransform ).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). Örtük XML-C14N dönüşümünü de belirtebilirsiniz, ancak bu gerekli değildir.You can specify the implicit XML-C14N transform as well, but it's not necessary. Bir enveloping veya ayrılmış imza için hiçbir dönüşüm gerekli değildir.For an enveloping or detached signature, no transforms are required. Örtük XML-C14N dönüştürmesi her şeyi üstlenir.The implicit XML-C14N transform takes care of everything.

Microsoft Güvenlik BÜLTENI MS16-035tarafından sunulan güvenlik güncelleştirmesi sayesinde, .net, CheckSignature her zaman geri dönüşmesine neden olan güvenilmeyen dönüşümler sayesinde, varsayılan olarak belge doğrulamasında hangi dönüşümlerin kullanılabileceğini kısıtlamıştır 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. Özellikle, ek giriş gerektiren (XML 'de alt öğeler olarak belirtilen) dönüşümler, kötü amaçlı kullanıcılar tarafından kötüye kullanım 'nin kullanım dışı olması nedeniyle artık izin verilmez.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. W3C, bu kısıtlamaların etkilediği iki ana dönüşüm olan XPath ve XSLT dönüştürmelerini önler.The W3C advises avoiding the XPath and XSLT transforms, which are the two main transforms affected by these restrictions.

Dış başvurularla ilgili sorunThe problem with external references

Bir uygulama dış başvuruların geçerli bağlam için uygun göründüğünü doğrulamadığı zaman, çok sayıda güvenlik açığı (hizmet reddi, dağıtılmış yansıma Hizmeti reddi, bilgilerin açığa çıkması, Imza atlama ve uzaktan kod yürütme dahil) için sağladığı yollarla bir dizi şekilde ele alınabilir.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). Bir uygulama dış başvuru URI 'sini doğrulayabilse de, iki kez yüklenmekte olan kaynakla ilgili bir sorun kalabilir: uygulamanız onu okurken bir kez ve okurken bir kez SignedXml .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. Uygulamanın okuma ve belge doğrulama adımlarının aynı içeriğe sahip olduğundan emin olmadığı için imza, güvenilirliği sağlamaz.Since there's no guarantee that the application read and document verify steps have the same content, the signature does not provide trustworthiness.

Dış başvuruların riskleri göz önüne alındığında, SignedXml bir dış başvuruya rastlana kadar bir özel durum oluşturur.Given the risks of external references, SignedXml will throw an exception when an external reference is encountered. Bu sorun hakkında daha fazla bilgi için bkz. KB makalesi 3148821.For more information about this issue, see KB article 3148821.

Oluşturucular

SignedXml()

SignedXml sınıfının yeni bir örneğini başlatır.Initializes a new instance of the SignedXml class.

SignedXml(XmlDocument)

SignedXmlBELIRTILEN XML belgesinden sınıfının yeni bir örneğini başlatır.Initializes a new instance of the SignedXml class from the specified XML document.

SignedXml(XmlElement)

Belirtilen nesneden sınıfının yeni bir örneğini başlatır SignedXml XmlElement .Initializes a new instance of the SignedXml class from the specified XmlElement object.

Alanlar

m_signature

SignatureGeçerli nesnenin nesnesini temsil eder SignedXml .Represents the Signature object of the current SignedXml object.

m_strSigningKeyName

Nesneyi imzalamak için kullanılacak yüklü anahtarın adını temsil eder SignedXml .Represents the name of the installed key to be used for signing the SignedXml object.

XmlDecryptionTransformUrl

XML modu şifre çözme dönüştürmesi için Tekdüzen Kaynak tanımlayıcısı 'nı (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the XML mode decryption transformation. Bu alan sabittir.This field is constant.

XmlDsigBase64TransformUrl

Base 64 dönüştürmesi için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the base 64 transformation. Bu alan sabittir.This field is constant.

XmlDsigC14NTransformUrl

Kurallı XML dönüştürmesi için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the Canonical XML transformation. Bu alan sabittir.This field is constant.

XmlDsigC14NWithCommentsTransformUrl

Kurallı XML dönüştürmesi için Tekdüzen Kaynak tanımlayıcısını (URI) açıklama ile temsil eder.Represents the Uniform Resource Identifier (URI) for the Canonical XML transformation, with comments. Bu alan sabittir.This field is constant.

XmlDsigCanonicalizationUrl

XML dijital imzaları için standart kurallı kullanım algoritması için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the standard canonicalization algorithm for XML digital signatures. Bu alan sabittir.This field is constant.

XmlDsigCanonicalizationWithCommentsUrl

XML dijital imzaları için standart kurallı kullanım algoritması için Tekdüzen Kaynak tanımlayıcısı 'nı (URI) temsil eder ve açıklamalar içerir.Represents the Uniform Resource Identifier (URI) for the standard canonicalization algorithm for XML digital signatures and includes comments. Bu alan sabittir.This field is constant.

XmlDsigDSAUrl

XML dijital imzaları için standart algoritma için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder DSA .Represents the Uniform Resource Identifier (URI) for the standard DSA algorithm for XML digital signatures. Bu alan sabittir.This field is constant.

XmlDsigEnvelopedSignatureTransformUrl

Zarflanan imza dönüştürmesi için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for enveloped signature transformation. Bu alan sabittir.This field is constant.

XmlDsigExcC14NTransformUrl

Özel XML kurallı kullanım için Tekdüzen Kaynak tanımlayıcısı 'nı (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for exclusive XML canonicalization. Bu alan sabittir.This field is constant.

XmlDsigExcC14NWithCommentsTransformUrl

Özel XML kurallı kullanım için Tekdüzen Kaynak tanımlayıcısı 'nı (URI) yorumlarla birlikte temsil eder.Represents the Uniform Resource Identifier (URI) for exclusive XML canonicalization, with comments. Bu alan sabittir.This field is constant.

XmlDsigHMACSHA1Url

XML dijital imzaları için standart algoritma için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder HMACSHA1 .Represents the Uniform Resource Identifier (URI) for the standard HMACSHA1 algorithm for XML digital signatures. Bu alan sabittir.This field is constant.

XmlDsigMinimalCanonicalizationUrl

XML dijital imzaları için standart minimal kurallı kullanım algoritması için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the standard minimal canonicalization algorithm for XML digital signatures. Bu alan sabittir.This field is constant.

XmlDsigNamespaceUrl

XML dijital imzaları için standart ad alanı için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the standard namespace for XML digital signatures. Bu alan sabittir.This field is constant.

XmlDsigRSASHA1Url

RSAXML dijital imzaları için standart imza yönteminin Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the standard RSA signature method for XML digital signatures. Bu alan sabittir.This field is constant.

XmlDsigRSASHA256Url

RSAXML dijital imzaları için SHA-256 imza yöntemi çeşitlemesi Için Tekdüzen Kaynak tanımlayıcısı 'nı (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the RSA SHA-256 signature method variation for XML digital signatures. Bu alan sabittir.This field is constant.

XmlDsigRSASHA384Url

RSAXML dijital imzaları için SHA-384 imza yöntemi çeşitlemesi Için Tekdüzen Kaynak tanımlayıcısı 'nı (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the RSA SHA-384 signature method variation for XML digital signatures. Bu alan sabittir.This field is constant.

XmlDsigRSASHA512Url

RSAXML dijital imzaları için SHA-512 imza yöntemi çeşitlemesi Için Tekdüzen Kaynak tanımlayıcısı 'nı (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the RSA SHA-512 signature method variation for XML digital signatures. Bu alan sabittir.This field is constant.

XmlDsigSHA1Url

SHA1XML dijital imzaları için standart Özet yöntemi Için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the standard SHA1 digest method for XML digital signatures. Bu alan sabittir.This field is constant.

XmlDsigSHA256Url

SHA256XML dijital imzaları için standart Özet yöntemi Için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the standard SHA256 digest method for XML digital signatures. Bu alan sabittir.This field is constant.

XmlDsigSHA384Url

SHA384XML dijital imzaları için standart Özet yöntemi Için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the standard SHA384 digest method for XML digital signatures. Bu alan sabittir.This field is constant.

XmlDsigSHA512Url

SHA512XML dijital imzaları için standart Özet yöntemi Için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the standard SHA512 digest method for XML digital signatures. Bu alan sabittir.This field is constant.

XmlDsigXPathTransformUrl

XML yol dili (XPath) için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the XML Path Language (XPath). Bu alan sabittir.This field is constant.

XmlDsigXsltTransformUrl

XSLT dönüştürmeleri için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for XSLT transformations. Bu alan sabittir.This field is constant.

XmlLicenseTransformUrl

İmzalara yönelik XrML lisanslarını normalleştirmek için kullanılan lisans dönüştürme algoritması için Tekdüzen Kaynak tanımlayıcısını (URI) temsil eder.Represents the Uniform Resource Identifier (URI) for the license transform algorithm used to normalize XrML licenses for signatures.

Özellikler

EncryptedXml

EncryptedXmlXML şifreleme işleme kurallarını tanımlayan bir nesne alır veya ayarlar.Gets or sets an EncryptedXml object that defines the XML encryption processing rules.

KeyInfo

KeyInfoGeçerli nesnenin nesnesini alır veya ayarlar SignedXml .Gets or sets the KeyInfo object of the current SignedXml object.

Resolver

Geçerli nesneyi ayarlar XmlResolver .Sets the current XmlResolver object.

SafeCanonicalizationMethods

Kurallı kullanım algoritmalarına açıkça izin verilen yöntemlerin adlarını alır.Gets the names of methods whose canonicalization algorithms are explicitly allowed.

Signature

SignatureGeçerli nesnenin nesnesini alır SignedXml .Gets the Signature object of the current SignedXml object.

SignatureFormatValidator

Bir XML imzasının biçimini doğrulamak için çağrılacak bir temsilci alır (şifreleme güvenliği değil).Gets a delegate that will be called to validate the format (not the cryptographic security) of an XML signature.

SignatureLength

Geçerli nesne için imzanın uzunluğunu alır SignedXml .Gets the length of the signature for the current SignedXml object.

SignatureMethod

Geçerli nesnenin imza yöntemini alır SignedXml .Gets the signature method of the current SignedXml object.

SignatureValue

Geçerli nesnenin imza değerini alır SignedXml .Gets the signature value of the current SignedXml object.

SignedInfo

SignedInfoGeçerli nesnenin nesnesini alır SignedXml .Gets the SignedInfo object of the current SignedXml object.

SigningKey

Bir nesneyi imzalamak için kullanılan asimetrik algoritma anahtarını alır veya ayarlar SignedXml .Gets or sets the asymmetric algorithm key used for signing a SignedXml object.

SigningKeyName

Nesneyi imzalamak için kullanılacak yüklü anahtarın adını alır veya ayarlar SignedXml .Gets or sets the name of the installed key to be used for signing the SignedXml object.

Yöntemler

AddObject(DataObject)

DataObjectİmzalanacak nesneler listesine bir nesne ekler.Adds a DataObject object to the list of objects to be signed.

AddReference(Reference)

Nesneye bir Reference SignedXml Özet yöntemi, Özet değeri ve bir XML dijital imzası oluşturmak için kullanılacak dönüşümü tanımlayan bir nesne ekler.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()

SignatureÖzelliğin İmzadaki ortak anahtarı kullanarak doğrulayıp doğrulamadığını belirler.Determines whether the Signature property verifies using the public key in the signature.

CheckSignature(AsymmetricAlgorithm)

SignatureÖzelliğin belirtilen anahtar için doğrulayıp doğrulamadığını belirler.Determines whether the Signature property verifies for the specified key.

CheckSignature(KeyedHashAlgorithm)

SignatureÖzelliğin belirtilen ileti kimlik doğrulama kodu (Mac) algoritması için doğrulayıp doğrulamadığını belirler.Determines whether the Signature property verifies for the specified message authentication code (MAC) algorithm.

CheckSignature(X509Certificate2, Boolean)

SignatureÖzelliğin belirtilen nesne için doğrulayıp doğrulamadığını X509Certificate2 ve isteğe bağlı olarak sertifikanın geçerli olup olmadığını belirler.Determines whether the Signature property verifies for the specified X509Certificate2 object and, optionally, whether the certificate is valid.

CheckSignatureReturningKey(AsymmetricAlgorithm)

SignatureÖzelliğin İmzadaki ortak anahtarı kullanarak doğrulayıp doğrulamadığını belirler.Determines whether the Signature property verifies using the public key in the signature.

ComputeSignature()

Bir XML dijital imzasını hesaplar.Computes an XML digital signature.

ComputeSignature(KeyedHashAlgorithm)

Belirtilen ileti kimlik doğrulama kodu (MAC) algoritmasını kullanarak bir XML dijital imzasını hesaplar.Computes an XML digital signature using the specified message authentication code (MAC) algorithm.

Equals(Object)

Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler.Determines whether the specified object is equal to the current object.

(Devralındığı yer: Object)
GetHashCode()

Varsayılan karma işlevi olarak işlev görür.Serves as the default hash function.

(Devralındığı yer: Object)
GetIdElement(XmlDocument, String)

Belirtilen XmlElement nesneden BELIRTILEN kimliğe sahip nesneyi döndürür XmlDocument .Returns the XmlElement object with the specified ID from the specified XmlDocument object.

GetPublicKey()

Bir imzanın ortak anahtarını döndürür.Returns the public key of a signature.

GetType()

TypeGeçerli örneği alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
GetXml()

Bir nesnenin XML gösterimini döndürür SignedXml .Returns the XML representation of a SignedXml object.

LoadXml(XmlElement)

SignedXmlXML öğesinden bir durum yükler.Loads a SignedXml state from an XML element.

MemberwiseClone()

Geçerli bir basit kopyasını oluşturur Object .Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
ToString()

Geçerli nesneyi temsil eden dizeyi döndürür.Returns a string that represents the current object.

(Devralındığı yer: Object)

Şunlara uygulanır

Ayrıca bkz.