EncryptData Method (XmlElement, SymmetricAlgorithm, Boolean)
Collapse the table of content
Expand the table of content

EncryptedXml.EncryptData Method (XmlElement, SymmetricAlgorithm, Boolean)

Note: This method is new in the .NET Framework version 2.0.

Encrypts the specified element or its contents using the specified symmetric algorithm.

Namespace: System.Security.Cryptography.Xml
Assembly: System.Security (in system.security.dll)

public byte[] EncryptData (
	XmlElement inputElement,
	SymmetricAlgorithm symmetricAlgorithm,
	bool content
)
public byte[] EncryptData (
	XmlElement inputElement, 
	SymmetricAlgorithm symmetricAlgorithm, 
	boolean content
)
public function EncryptData (
	inputElement : XmlElement, 
	symmetricAlgorithm : SymmetricAlgorithm, 
	content : boolean
) : byte[]

Parameters

inputElement

The element or its contents to encrypt.

symmetricAlgorithm

The symmetric algorithm to use for encryption.

content

true to encrypt only the contents of the element; false to encrypt the entire element.

Return Value

A byte array that contains the encrypted data.

Exception typeCondition

ArgumentNullException

The value of the inputElement parameter is a null reference (Nothing in Visual Basic).

-or-

The value of the symmetricAlgorithm parameter is a null reference (Nothing in Visual Basic).

The returned byte array data is the value of the <CipherValue> element.

The following code example demonstrates how to encrypt an XML document using a symmetric key. This example does not include any key information in the encrypted XML document.

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

class Program
{
    static void Main(string[] args)
    {

        // Create an XmlDocument object.
        XmlDocument xmlDoc = new XmlDocument();

        // Load an XML file into the XmlDocument object.
        try
        {
            xmlDoc.PreserveWhitespace = true;
            xmlDoc.Load("test.xml");
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }

        // Create a new TripleDES key. 
        TripleDESCryptoServiceProvider tDESkey = new TripleDESCryptoServiceProvider();


        try
        {
            // Encrypt the "creditcard" element.
            Encrypt(xmlDoc, "creditcard", tDESkey);

            // Display the encrypted XML to the console.
            Console.WriteLine("Encrypted XML:");
            Console.WriteLine();
            Console.WriteLine(xmlDoc.OuterXml);

            // Decrypt the "creditcard" element.
            Decrypt(xmlDoc, tDESkey);

            // Display the encrypted XML to the console.
            Console.WriteLine();
            Console.WriteLine("Decrypted XML:");
            Console.WriteLine();
            Console.WriteLine(xmlDoc.OuterXml);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        finally
        {
            // Clear the TripleDES key.
            tDESkey.Clear();
        }

    }

    public static void Encrypt(XmlDocument Doc, string ElementToEncrypt, SymmetricAlgorithm Alg)
    {
        // Check the arguments.  
        if (Doc == null)
            throw new ArgumentNullException("Doc");
        if (ElementToEncrypt == null)
            throw new ArgumentNullException("ElementToEncrypt");
        if (Alg == null)
            throw new ArgumentNullException("Alg");

        ////////////////////////////////////////////////
        // Find the specified element in the XmlDocument
        // object and create a new XmlElemnt object.
        ////////////////////////////////////////////////

        XmlElement elementToEncrypt = Doc.GetElementsByTagName(ElementToEncrypt)[0] as XmlElement;

        // Throw an XmlException if the element was not found.
        if (elementToEncrypt == null)
        {
            throw new XmlException("The specified element was not found");

        }

        //////////////////////////////////////////////////
        // Create a new instance of the EncryptedXml class 
        // and use it to encrypt the XmlElement with the 
        // symmetric key.
        //////////////////////////////////////////////////

        EncryptedXml eXml = new EncryptedXml();

        byte[] encryptedElement = eXml.EncryptData(elementToEncrypt, Alg, false);

        ////////////////////////////////////////////////
        // Construct an EncryptedData object and populate
        // it with the desired encryption information.
        ////////////////////////////////////////////////


        EncryptedData edElement = new EncryptedData();
        edElement.Type = EncryptedXml.XmlEncElementUrl;

        // Create an EncryptionMethod element so that the 
        // receiver knows which algorithm to use for decryption.
        // Determine what kind of algorithm is being used and
        // supply the appropriate URL to the EncryptionMethod element.

        string encryptionMethod = null;

        if (Alg is TripleDES)
        {
            encryptionMethod = EncryptedXml.XmlEncTripleDESUrl;
        }
        else if (Alg is DES)
        {
            encryptionMethod = EncryptedXml.XmlEncDESUrl;
        }
        else if (Alg is Rijndael)
        {
            switch (Alg.KeySize)
            {
                case 128:
                    encryptionMethod = EncryptedXml.XmlEncAES128Url;
                    break;
                case 192:
                    encryptionMethod = EncryptedXml.XmlEncAES192Url;
                    break;
                case 256:
                    encryptionMethod = EncryptedXml.XmlEncAES256Url;
                    break;
            }
        }
        else
        {
            // Throw an exception if the transform is not in the previous categories
            throw new CryptographicException("The specified algorithm is not supported for XML Encryption.");
        }

        edElement.EncryptionMethod = new EncryptionMethod(encryptionMethod);

        // Add the encrypted element data to the 
        // EncryptedData object.
        edElement.CipherData.CipherValue = encryptedElement;

        ////////////////////////////////////////////////////
        // Replace the element from the original XmlDocument
        // object with the EncryptedData element.
        ////////////////////////////////////////////////////

        EncryptedXml.ReplaceElement(elementToEncrypt, edElement, false);

    }

    public static void Decrypt(XmlDocument Doc, SymmetricAlgorithm Alg)
    {
        // Check the arguments.  
        if (Doc == null)
            throw new ArgumentNullException("Doc");
        if (Alg == null)
            throw new ArgumentNullException("Alg");

        // Find the EncryptedData element in the XmlDocument.
        XmlElement encryptedElement = Doc.GetElementsByTagName("EncryptedData")[0] as XmlElement;

        // If the EncryptedData element was not found, throw an exception.
        if (encryptedElement == null)
        {
            throw new XmlException("The EncryptedData element was not found.");
        }

        // Create an EncryptedData object and populate it.
        EncryptedData edElement = new EncryptedData();
        edElement.LoadXml(encryptedElement);

        // Create a new EncryptedXml object.
        EncryptedXml exml = new EncryptedXml();

        // Decrypt the element using the symmetric key.
        byte[] rgbOutput = exml.DecryptData(edElement, Alg);

        // Replace the encryptedData element with the plaintext XML element.
        exml.ReplaceData(encryptedElement, rgbOutput);

    }


}

import System.*;
import System.Xml.*;
import System.Security.Cryptography.*;
import System.Security.Cryptography.Xml.*;

class Program
{
    public static void main(String[] args)
    {
        // Create an XmlDocument object.
        XmlDocument xmlDoc = new XmlDocument();
        // Load an XML file into the XmlDocument object.
        try {
            xmlDoc.set_PreserveWhitespace(true);
            xmlDoc.Load("test.xml");
        }
        catch (System.Exception e) {
            Console.WriteLine(e.get_Message());
        }
        // Create a new TripleDES key. 
        TripleDESCryptoServiceProvider tDESkey = 
            new TripleDESCryptoServiceProvider();

        try {
            // Encrypt the "creditcard" element.
            Encrypt(xmlDoc, "creditcard", tDESkey);

            // Display the encrypted XML to the console.
            Console.WriteLine("Encrypted XML:");
            Console.WriteLine();
            Console.WriteLine(xmlDoc.get_OuterXml());

            // Decrypt the "creditcard" element.
            Decrypt(xmlDoc, tDESkey);

            // Display the encrypted XML to the console.
            Console.WriteLine();
            Console.WriteLine("Decrypted XML:");
            Console.WriteLine();
            Console.WriteLine(xmlDoc.get_OuterXml());
        }
        catch (System.Exception e) {
            Console.WriteLine(e.get_Message());
        }
        finally {
            // Clear the TripleDES key.
            tDESkey.Clear();
        }
    } //main

    public static void Encrypt(XmlDocument doc, String elementToEncrypt,
        SymmetricAlgorithm alg) throws XmlException,CryptographicException
    {
        // Check the arguments.  
        if (doc == null) {
            throw new ArgumentNullException("doc");
        }
        if (elementToEncrypt == null) {
            throw new ArgumentNullException("elementToEncrypt");
        }
        if (alg == null) {
            throw new ArgumentNullException("alg");
        }
        ////////////////////////////////////////////////
        // Find the specified element in the XmlDocument
        // object and create a new XmlElemnt object.
        ////////////////////////////////////////////////
        XmlElement elementToEncrypt1 = (XmlElement)doc.GetElementsByTagName(
            elementToEncrypt).get_ItemOf(0);

        // Throw an XmlException if the element was not found.
        if (elementToEncrypt1 == null) {
            throw new XmlException("The specified element was not found");
        }
        //////////////////////////////////////////////////
        // Create a new instance of the EncryptedXml class 
        // and use it to encrypt the XmlElement with the 
        // symmetric key.
        //////////////////////////////////////////////////
        EncryptedXml eXml = new EncryptedXml();

        ubyte encryptedElement[] = eXml.EncryptData(elementToEncrypt1, alg,
            false);
        ////////////////////////////////////////////////
        // Construct an EncryptedData object and populate
        // it with the desired encryption information.
        ////////////////////////////////////////////////
        EncryptedData edElement = new EncryptedData();
        edElement.set_Type(EncryptedXml.XmlEncElementUrl);
        // Create an EncryptionMethod element so that the 
        // receiver knows which algorithm to use for decryption.
        // Determine what kind of algorithm is being used and
        // supply the appropriate URL to the EncryptionMethod element.
        String encryptionMethod = null;

        if (alg instanceof TripleDES) {
            encryptionMethod = EncryptedXml.XmlEncTripleDESUrl;
        }
        else {
            if (alg instanceof DES) {
                encryptionMethod = EncryptedXml.XmlEncDESUrl;
            }
            else {
                if (alg instanceof Rijndael) {
                    switch (alg.get_KeySize()) {
                        case 128:
                            encryptionMethod = EncryptedXml.XmlEncAES128Url;
                            break;

                        case 192:
                            encryptionMethod = EncryptedXml.XmlEncAES192Url;
                            break;

                        case 256:
                            encryptionMethod = EncryptedXml.XmlEncAES256Url;
                            break;
                    }
                }
                else {
                    // Throw an exception if the transform is not in the
                    // previous categories
                    throw new CryptographicException("The specified algorithm"
                        +" is not supported for XML Encryption.");
                }
            }
        }
        edElement.set_EncryptionMethod(new EncryptionMethod(encryptionMethod));

        // Add the encrypted element data to the 
        // EncryptedData object.
        edElement.get_CipherData().set_CipherValue(encryptedElement);

        ////////////////////////////////////////////////////
        // Replace the element from the original XmlDocument
        // object with the EncryptedData element.
        ////////////////////////////////////////////////////
        EncryptedXml.ReplaceElement(elementToEncrypt1, edElement, false);
    } //Encrypt

    public static void Decrypt(XmlDocument doc, SymmetricAlgorithm alg) 
        throws XmlException
    {
        // Check the arguments.  
        if (doc == null) {
            throw new ArgumentNullException("doc");
        }
        if (alg == null) {
            throw new ArgumentNullException("alg");
        }
        // Find the EncryptedData element in the XmlDocument.
        XmlElement encryptedElement = (XmlElement)doc.GetElementsByTagName(
            "EncryptedData").get_ItemOf(0);

        // If the EncryptedData element was not found, throw an exception.
        if (encryptedElement == null) {
            throw new XmlException("The EncryptedData element was not found.");
        }
        // Create an EncryptedData object and populate it.
        EncryptedData edElement = new EncryptedData();
        edElement.LoadXml(encryptedElement);

        // Create a new EncryptedXml object.
        EncryptedXml eXml = new EncryptedXml();

        // Decrypt the element using the symmetric key.
        ubyte rgbOutput[] = eXml.DecryptData(edElement, alg);
        // Replace the encryptedData element with the plaintext XML element.
        eXml.ReplaceData(encryptedElement, rgbOutput);
    } //Decrypt 
} //Program

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see System Requirements.

.NET Framework

Supported in: 2.0

Community Additions

ADD
Show:
© 2016 Microsoft