XmlDsigExcC14NTransform 클래스

정의

네임스페이스:

System.Security.Cryptography.Xml

어셈블리:

System.Security.Cryptography.Xml.dll

패키지:

System.Security.Cryptography.Xml v8.0.0

Source:

XmlDsigExcC14NTransform.cs

W3C(World Wide Web 컨소시엄)에서 정의한 대로 설명이 없는 디지털 서명의 배타적 C14N XML 정식화 변환을 나타냅니다.

public ref class XmlDsigExcC14NTransform : System::Security::Cryptography::Xml::Transform

public class XmlDsigExcC14NTransform : System.Security.Cryptography.Xml.Transform

type XmlDsigExcC14NTransform = class
    inherit Transform

Public Class XmlDsigExcC14NTransform
Inherits Transform

상속

Object

Transform

XmlDsigExcC14NTransform

파생

System.Security.Cryptography.Xml.XmlDsigExcC14NWithCommentsTransform

예제

다음 코드 예제에서는 봉투 서명을 사용 하 여 클래스를 XmlDsigExcC14NTransform 사용 하 여 XML 문서에 서명 하는 방법을 보여 주는 합니다.

//
// 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::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.
static void SignXmlFile( String^ FileName, String^ SignedFileName, RSA^ Key )
{
   
   // Create a new XML document.
   XmlDocument^ doc = gcnew XmlDocument;
   
   // Format the document to ignore white spaces.
   doc->PreserveWhitespace = false;
   
   // Load the passed XML file using it's name.
   doc->Load( gcnew XmlTextReader( FileName ) );
   
   // Create a SignedXml object.
   SignedXml^ signedXml = gcnew SignedXml( doc );
   
   // Add the key to the SignedXml document. 
   signedXml->SigningKey = Key;
   
   // Specify a canonicalization method.
   signedXml->SignedInfo->CanonicalizationMethod = SignedXml::XmlDsigExcC14NTransformUrl;
   
   // Set the InclusiveNamespacesPrefixList property.        
   XmlDsigExcC14NTransform^ canMethod = dynamic_cast<XmlDsigExcC14NTransform^>(signedXml->SignedInfo->CanonicalizationMethodObject);
   canMethod->InclusiveNamespacesPrefixList = L"Sign";
   
   // Create a reference to be signed.
   Reference^ reference = gcnew Reference;
   reference->Uri = L"";
   
   // 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 )
{
   
   // 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();
}


// Create example data to sign.
static void CreateSomeXml( String^ FileName )
{
   
   // Create a new XmlDocument object.
   XmlDocument^ document = gcnew XmlDocument;
   
   // Create a new XmlNode object.
   XmlNode^ node = document->CreateNode( XmlNodeType::Element, L"", L"MyXML", L"Don't_Sign" );
   
   // Append the node to the document.
   document->AppendChild( node );
   
   // Create a new XmlNode object.
   XmlNode^ subnode = document->CreateNode( XmlNodeType::Element, L"", L"TempElement", L"Sign" );
   
   // Add some text to the node.
   subnode->InnerText = L"Here is some data to sign.";
   
   // Append the node to the document.
   document->DocumentElement->AppendChild( subnode );
   
   // 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( L"Example.xml" );
      Console::WriteLine( L"New XML file created." );
      
      // Sign the XML that was just created and save it in a 
      // new file.
      SignXmlFile( L"Example.xml", L"SignedExample.xml", Key );
      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 );
   }

   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.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");

            // Display the results of the signature verification to \
            // the console.
            if (result)
            {
                Console.WriteLine("The XML signature is valid.");
            }
            else
            {
                Console.WriteLine("The XML signature is not valid.");
            }
        }
        catch (CryptographicException e)
        {
            Console.WriteLine(e.Message);
        }
    }

    // Sign an XML file and save the signature in a new file.
    public static void SignXmlFile(string FileName, string SignedFileName, RSA Key)
    {
        // Create a new XML document.
        XmlDocument doc = new XmlDocument();

        // Format the document to ignore white spaces.
        doc.PreserveWhitespace = false;

        // Load the passed XML file using it's name.
        doc.Load(new XmlTextReader(FileName));

        // Create a SignedXml object.
        SignedXml signedXml = new SignedXml(doc);

        // Add the key to the SignedXml document.
        signedXml.SigningKey = Key;

        // Specify a canonicalization method.
        signedXml.SignedInfo.CanonicalizationMethod = SignedXml.XmlDsigExcC14NTransformUrl;

        // Set the InclusiveNamespacesPrefixList property.
        XmlDsigExcC14NTransform canMethod = (XmlDsigExcC14NTransform)signedXml.SignedInfo.CanonicalizationMethodObject;
        canMethod.InclusiveNamespacesPrefixList = "Sign";

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

        // Add an enveloped transformation to the reference.
        XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform();
        reference.AddTransform(env);

        // Add the reference to the SignedXml object.
        signedXml.AddReference(reference);

        // Add an RSAKeyValue KeyInfo (optional; helps recipient find key to validate).
        KeyInfo keyInfo = new KeyInfo();
        keyInfo.AddClause(new RSAKeyValue((RSA)Key));
        signedXml.KeyInfo = keyInfo;

        // Compute the signature.
        signedXml.ComputeSignature();

        // Get the XML representation of the signature and save
        // it to an XmlElement object.
        XmlElement xmlDigitalSignature = signedXml.GetXml();

        // Append the element to the XML document.
        doc.DocumentElement.AppendChild(doc.ImportNode(xmlDigitalSignature, true));

        if (doc.FirstChild is XmlDeclaration)
        {
            doc.RemoveChild(doc.FirstChild);
        }

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

        // Format using white spaces.
        xmlDocument.PreserveWhitespace = true;

        // Load the passed XML file into the document.
        xmlDocument.Load(Name);

        // Create a new SignedXml object and pass it
        // the XML document class.
        SignedXml signedXml = new SignedXml(xmlDocument);

        // Find the "Signature" node and create a new
        // XmlNodeList object.
        XmlNodeList nodeList = xmlDocument.GetElementsByTagName("Signature");

        // Load the signature node.
        signedXml.LoadXml((XmlElement)nodeList[0]);

        // Check the signature and return the result.
        return signedXml.CheckSignature();
    }

    // Create example data to sign.
    public static void CreateSomeXml(string FileName)
    {
        // Create a new XmlDocument object.
        XmlDocument document = new XmlDocument();

        // Create a new XmlNode object.
        XmlNode node = document.CreateNode(XmlNodeType.Element, "", "MyXML", "Don't_Sign");

        // Append the node to the document.
        document.AppendChild(node);

        // Create a new XmlNode object.
        XmlNode subnode = document.CreateNode(XmlNodeType.Element, "", "TempElement", "Sign");

        // Add some text to the node.
        subnode.InnerText = "Here is some data to sign.";

        // Append the node to the document.
        document.DocumentElement.AppendChild(subnode);

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



Module SignVerifyEnvelope


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

            ' Create an XML file to sign.
            CreateSomeXml("Example.xml")
            Console.WriteLine("New XML file created.")

            ' Sign the XML that was just created and save it in a 
            ' new file.
            SignXmlFile("Example.xml", "SignedExample.xml", Key)
            Console.WriteLine("XML file signed.")

            ' Verify the signature of the signed XML.
            Console.WriteLine("Verifying signature...")
            Dim result As Boolean = VerifyXmlFile("SignedExample.xml")

            ' Display the results of the signature verification to 
            ' the console.
            If result Then
                Console.WriteLine("The XML signature is valid.")
            Else
                Console.WriteLine("The XML signature is not valid.")
            End If

        Catch e As CryptographicException
            Console.WriteLine(e.Message)
        End Try

    End Sub


    ' Sign an XML file and save the signature in a new file.
    Sub SignXmlFile(ByVal FileName As String, ByVal SignedFileName As String, ByVal Key As RSA)
        ' Create a new XML document.
        Dim doc As New XmlDocument()

        ' Format the document to ignore white spaces.
        doc.PreserveWhitespace = False

        ' Load the passed XML file using it's name.
        doc.Load(New XmlTextReader(FileName))

        ' Create a SignedXml object.
        Dim signedXml As New SignedXml(doc)

        ' Add the key to the SignedXml document. 
        signedXml.SigningKey = Key

        ' Specify a canonicalization method.
        signedXml.SignedInfo.CanonicalizationMethod = signedXml.XmlDsigExcC14NTransformUrl

        ' Set the InclusiveNamespacesPrefixList property. 
        Dim canMethod As XmlDsigExcC14NTransform = CType(signedXml.SignedInfo.CanonicalizationMethodObject, XmlDsigExcC14NTransform)
        canMethod.InclusiveNamespacesPrefixList = "Sign"

        ' Create a reference to be signed.
        Dim reference As New Reference()
        reference.Uri = ""

        ' Add an enveloped transformation to the reference.
        Dim env As New XmlDsigEnvelopedSignatureTransform()
        reference.AddTransform(env)

        ' Add the reference to the SignedXml object.
        signedXml.AddReference(reference)


        ' Add an RSAKeyValue KeyInfo (optional; helps recipient find key to validate).
        Dim keyInfo As New KeyInfo()
        keyInfo.AddClause(New RSAKeyValue(CType(Key, RSA)))
        signedXml.KeyInfo = keyInfo

        ' Compute the signature.
        signedXml.ComputeSignature()

        ' Get the XML representation of the signature and save
        ' it to an XmlElement object.
        Dim xmlDigitalSignature As XmlElement = signedXml.GetXml()

        ' Append the element to the XML document.
        doc.DocumentElement.AppendChild(doc.ImportNode(xmlDigitalSignature, True))


        If TypeOf doc.FirstChild Is XmlDeclaration Then
            doc.RemoveChild(doc.FirstChild)
        End If

        ' Save the signed XML document to a file specified
        ' using the passed string.
        Dim xmltw As New XmlTextWriter(SignedFileName, New UTF8Encoding(False))
        doc.WriteTo(xmltw)
        xmltw.Close()

    End Sub

    ' Verify the signature of an XML file and return the result.
    Function VerifyXmlFile(ByVal Name As String) As [Boolean]
        ' Create a new XML document.
        Dim xmlDocument As New XmlDocument()

        ' Format using white spaces.
        xmlDocument.PreserveWhitespace = True

        ' Load the passed XML file into the document. 
        xmlDocument.Load(Name)

        ' Create a new SignedXml object and pass it
        ' the XML document class.
        Dim signedXml As New SignedXml(xmlDocument)

        ' Find the "Signature" node and create a new
        ' XmlNodeList object.
        Dim nodeList As XmlNodeList = xmlDocument.GetElementsByTagName("Signature")

        ' Load the signature node.
        signedXml.LoadXml(CType(nodeList(0), XmlElement))

        ' Check the signature and return the result.
        Return signedXml.CheckSignature()

    End Function


    ' Create example data to sign.
    Sub CreateSomeXml(ByVal 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, "", "MyXML", "Don't_Sign")

        ' Append the node to the document.
        document.AppendChild(node)

        ' Create a new XmlNode object.
        Dim subnode As XmlNode = document.CreateNode(XmlNodeType.Element, "", "TempElement", "Sign")

        ' Add some text to the node.
        subnode.InnerText = "Here is some data to sign."

        ' Append the node to the document.
        document.DocumentElement.AppendChild(subnode)

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

설명

클래스는 XmlDsigExcC14NTransform 주석 없이 단독 C14N XML 정식화 변환을 나타냅니다. 이 클래스는 서명자가 XML 문서의 정식 형식을 사용하여 다이제스트를 만들 수 있도록 하는 클래스와 비슷합니다 XmlDsigC14NTransform . 그러나 클래스는 XmlDsigExcC14NTransform 정식화된 하위 문서로부터 상위 컨텍스트를 제외합니다.

XmlDsigC14NTransform XML 하위 문서를 XML 컨텍스트와 독립적이도록 정식화해야 하는 경우 클래스를 사용합니다. 예를 들어, 애플리케이션 웹 서비스를 사용 하는 서명 된 XML 같은 복잡 한 통신 프로토콜 내의 종종 XML 정식화 해야이 방식입니다. 이러한 애플리케이션 대체로 문서를 변경 하 고 실패 XML 서명을 확인할 수 있는 다양 한 동적으로 생성 된 요소 내에서 명의 XML을 포함 하는 경우가 많습니다. 클래스는 XmlDsigExcC14NTransform 정식 하위 문서에서 이러한 상위 컨텍스트를 제외하여 이 문제를 해결합니다.

일반적으로 정식화 변환 클래스의 새 instance 만들지 않습니다. 정식화 변환을 지정하려면 속성에서 SignedInfo 액세스할 수 있는 속성으로의 변환 CanonicalizationMethod 을 설명하는 URI(Uniform Resource Identifier)를 전달합니다. 정식화 변환에 대한 참조를 가져오려면 속성에서 SignedInfo 액세스할 수 있는 속성을 사용합니다CanonicalizationMethodObject.

XML 문서를 수동으로 해시하거나 고유한 정식화 알고리즘을 사용하려는 경우에만 정식화 변환 클래스의 새 instance 만들어야 합니다.

클래스를 XmlDsigExcC14NWithCommentsTransform 설명하는 URI는 필드에 의해 XmlDsigExcC14NWithCommentsTransformUrl 정의됩니다.

클래스를 XmlDsigExcC14NTransform 설명하는 URI는 필드에 의해 XmlDsigExcC14NTransformUrl 정의됩니다.

단독 C14N 변환에 대한 자세한 내용은 W3C XMLDSIG 사양을 참조하세요. 정식화 알고리즘은 W3C 정식 XML 사양에 정의되어 있습니다.

생성자

XmlDsigExcC14NTransform()	XmlDsigExcC14NTransform 클래스의 새 인스턴스를 초기화합니다.
XmlDsigExcC14NTransform(Boolean)	설명의 포함 여부를 결정하는 값을 지정하는 XmlDsigExcC14NTransform 클래스의 새 인스턴스를 초기화합니다.
XmlDsigExcC14NTransform(Boolean, String)	설명의 포함 여부와 네임스페이스 접두사 목록을 지정하는 XmlDsigExcC14NTransform 클래스의 새 인스턴스를 초기화합니다.
XmlDsigExcC14NTransform(String)	표준 정식화 알고리즘을 사용하여 정식화할 네임스페이스 접두사 목록을 지정하는 XmlDsigExcC14NTransform 클래스의 새 인스턴스를 초기화합니다.

속성

Algorithm	현재 변환에서 수행되는 알고리즘을 식별하는 URI(Uniform Resource Identifier)를 가져오거나 설정합니다. (다음에서 상속됨 Transform)
Context	현재 XmlElement 개체가 실행되고 있는 문서 컨텍스트를 나타내는 Transform 개체를 가져오거나 설정합니다. (다음에서 상속됨 Transform)
InclusiveNamespacesPrefixList	표준 정식화 알고리즘을 사용하여 정식화할 네임스페이스 접두사가 들어 있는 문자열을 가져오거나 설정합니다.
InputTypes	현재 LoadInput(Object) 개체의 XmlDsigExcC14NTransform 메서드에 유효한 입력 형식의 배열을 가져옵니다.
OutputTypes	현재 GetOutput() 개체의 XmlDsigExcC14NTransform 메서드에서 가능한 출력 형식의 배열을 가져옵니다.
PropagatedNamespaces	서명으로 전파되는 네임스페이스가 포함된 Hashtable 개체를 가져오거나 설정합니다. (다음에서 상속됨 Transform)
Resolver	현재의 XmlResolver 개체를 설정합니다. (다음에서 상속됨 Transform)

메서드

Equals(Object)	지정된 개체가 현재 개체와 같은지 확인합니다. (다음에서 상속됨 Object)
GetDigestedOutput(HashAlgorithm)	XmlDsigExcC14NTransform 개체와 관련된 다이제스트를 반환합니다.
GetHashCode()	기본 해시 함수로 작동합니다. (다음에서 상속됨 Object)
GetInnerXml()	XMLDSIG <Transform> 요소의 하위 요소로 포함하기에 적합한 XmlDsigExcC14NTransform 개체의 매개 변수에 대한 XML 표현을 반환합니다.
GetOutput()	현재 XmlDsigExcC14NTransform 개체의 출력을 반환합니다.
GetOutput(Type)	지정된 형식의 개체로 반환된 현재 XmlDsigExcC14NTransform 개체의 출력을 반환합니다.
GetType()	현재 인스턴스의 Type을 가져옵니다. (다음에서 상속됨 Object)
GetXml()	현재 Transform 개체의 XML 표현을 반환합니다. (다음에서 상속됨 Transform)
LoadInnerXml(XmlNodeList)	지정된 XmlNodeList 개체를 <Transform> 요소의 변환 관련 내용으로 구문 분석하여 현재 XmlDsigExcC14NTransform 개체의 내부 상태를 <Transform> 요소와 일치하도록 구성합니다.
LoadInput(Object)	파생 클래스에서 재정의된 경우 지정된 입력을 현재 XmlDsigExcC14NTransform 개체로 로드합니다.
MemberwiseClone()	현재 Object의 단순 복사본을 만듭니다. (다음에서 상속됨 Object)
ToString()	현재 개체를 나타내는 문자열을 반환합니다. (다음에서 상속됨 Object)