SignedXml.AddObject(DataObject) Method


Adds a DataObject object to the list of objects to be signed.

 void AddObject(System::Security::Cryptography::Xml::DataObject ^ dataObject);
public void AddObject (System.Security.Cryptography.Xml.DataObject dataObject);
member this.AddObject : System.Security.Cryptography.Xml.DataObject -> unit
Public Sub AddObject (dataObject As DataObject)



The DataObject object to add to the list of objects to be signed.


The following code example computes and XML 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::Xml;
using namespace System::Text;
using namespace System::Xml;

// Sign an XML file and save the signature in a new file.
void SignXmlFile( String^ FileName, String^ SignedFileName, RSA^ RSAKey )
   // 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 its name.
   doc->Load( gcnew XmlTextReader( FileName ) );
   // Create a SignedXml object.
   SignedXml^ signedXml = gcnew SignedXml( doc );
   // Add the RSA key to the SignedXml document. 
   signedXml->SigningKey = RSAKey;
   // Create a reference to be signed.
   Reference^ reference = gcnew Reference;
   reference->Uri = "";
   // Add a transformation to the reference.
   Transform^ trns = gcnew XmlDsigC14NTransform;
   reference->AddTransform( trns );
   // 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 to the KeyInfo (optional; helps recipient find key to validate).
   KeyInfo^ keyInfo = gcnew KeyInfo;
   keyInfo->AddClause( gcnew RSAKeyValue( safe_cast<RSA^>(RSAKey) ) );
   signedXml->KeyInfo = keyInfo;
   // Compute the signature.
   // 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 );

// Verify the signature of an XML file and return the result.
Boolean VerifyXmlFile( String^ Name )
   // Create a new XML document.
   XmlDocument^ xmlDocument = gcnew XmlDocument;
   // Format using white spaces.
   xmlDocument->PreserveWhitespace = true;
   // Load the passed XML file into the document. 
   xmlDocument->Load( Name );
   // Create a new SignedXml object and pass it
   // the XML document class.
   SignedXml^ signedXml = gcnew SignedXml( xmlDocument );
   // Find the "Signature" node and create a new
   // XmlNodeList object.
   XmlNodeList^ nodeList = xmlDocument->GetElementsByTagName( "Signature" );
   // Load the signature node.
   signedXml->LoadXml( safe_cast<XmlElement^>(nodeList->Item( 0 )) );
   // Check the signature and return the result.
   return signedXml->CheckSignature();

// Create example data to sign.
void CreateSomeXml( String^ FileName )
   // Create a new XmlDocument object.
   XmlDocument^ document = gcnew XmlDocument;
   // Create a new XmlNode object.
   XmlNode^ node = document->CreateNode( XmlNodeType::Element, "", "MyElement", "samples" );
   // Add some text to the node.
   node->InnerText = "Example text to be signed.";
   // Append the node to the document.
   document->AppendChild( node );
   // Save the XML document to the file name specified.
   XmlTextWriter^ xmltw = gcnew XmlTextWriter( FileName,gcnew UTF8Encoding( false ) );
   document->WriteTo( xmltw );

int main()
      // Generate an RSA signing key.
      RSA^ RSAKey = 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", RSAKey );
      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." );
         Console::WriteLine( "The XML signature is not valid." );
   catch ( CryptographicException^ e ) 
      Console::WriteLine( e->Message );


using System;
using System.IO;
using System.Security.Cryptography;
using System.Security.Cryptography.Xml;
using System.Xml;

public class XMLdsigsample1 

    static void Main(String[] args)
            // Create example data to sign.
            XmlDocument document = new XmlDocument();
            XmlNode node = document.CreateNode(XmlNodeType.Element, "", "MyElement", "samples");
            node.InnerText = "This is some text";
            Console.WriteLine("Data to sign:\n" + document.OuterXml + "\n");
            // Create the SignedXml message.
            SignedXml signedXml = new SignedXml();
            RSA key = RSA.Create();
            signedXml.SigningKey = key;
            // Create a data object to hold the data to sign.
            DataObject dataObject = new DataObject();
            dataObject.Data = document.ChildNodes;
            dataObject.Id = "MyObjectId";

            // Add the data object to the signature.
            // Create a reference to be able to package everything into the
            // message.
            Reference reference = new Reference();
            reference.Uri = "#MyObjectId";
            // Add the reference to the message.

            // Add a KeyInfo.
            KeyInfo keyInfo = new KeyInfo();
            keyInfo.AddClause(new RSAKeyValue(key));
            signedXml.KeyInfo = keyInfo;

            // Compute the signature.

            Console.WriteLine("The data was signed.");
        catch(CryptographicException e)
Imports System.IO
Imports System.Security.Cryptography
Imports System.Security.Cryptography.Xml
Imports System.Xml

Public Class XMLdsigsample1
   Overloads Shared Sub Main(args() As [String])
         ' Create example data to sign.
         Dim document As New XmlDocument()
         Dim node As XmlNode = document.CreateNode(XmlNodeType.Element, "", "MyElement", "samples")
         node.InnerText = "This is some text"
         Console.WriteLine(("Data to sign:" + ControlChars.Lf + document.OuterXml + ControlChars.Lf))
         ' Create the SignedXml message.
         Dim signedXml As New SignedXml()
         Dim key As RSA = RSA.Create()
         signedXml.SigningKey = key
         ' Create a data object to hold the data to sign.
         Dim dataObject As New DataObject()
         dataObject.Data = document.ChildNodes
         dataObject.Id = "MyObjectId"
         ' Add the data object to the signature.
         ' Create a reference to be able to package everything into the
         ' message.
         Dim reference As New Reference()
         reference.Uri = "#MyObjectId"
         ' Add the reference to the message.
         ' Add a KeyInfo.
         Dim keyInfo As New KeyInfo()
         keyInfo.AddClause(New RSAKeyValue(key))
         signedXml.KeyInfo = keyInfo
         ' Compute the signature.
         Console.WriteLine("The data was signed.")
      Catch e As CryptographicException
      End Try
   End Sub 
End Class 


The AddObject method adds an <Object> element that represents an object to be signed to the <Signature> element of an XML digital signature.

The AddObject method internally calls the AddObject method of the Signature object encapsulated by the SignedXml object. You can also add a DataObject object by directly calling the AddObject method from the Signature property.

For more information about XML digital signatures, see the XMLDSIG specification.

Applies to