public void Encrypt(string xmlFileName)
{
TripleDESCryptoServiceProvider encryptionKey = new TripleDESCryptoServiceProvider();
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(xmlFileName);
encryptionKey.Key = UTF8Encoding.UTF8.GetBytes(""); // your salt value
XmlElement orderElem = xmlDoc.SelectSingleNode("Settings") as XmlElement;
EncryptedXml encXml = new EncryptedXml(xmlDoc);
byte[] encryptedOrder = encXml.EncryptData(orderElem, encryptionKey, false);
EncryptedData encryptedData = new EncryptedData();
encryptedData.Type = EncryptedXml.XmlEncElementUrl;
encryptedData.EncryptionMethod = new
EncryptionMethod(EncryptedXml.XmlEncTripleDESUrl);
encryptedData.CipherData = new CipherData();
encryptedData.CipherData.CipherValue = encryptedOrder;
EncryptedXml.ReplaceElement(orderElem, encryptedData, false);
xmlDoc.Save(xmlFileName);
}
public void DecryptEncryptedKey_Null()
{
EncryptedXml ex = new EncryptedXml();
ex.DecryptEncryptedKey(null);
}
/// <summary>
/// Entschlüsselung einer verschlüsselten XML Struktur
/// </summary>
/// <param name="Doc"></param>
/// <param name="keyStore"></param>
/// <param name="keyStorePasswort"></param>
private static void DecryptXML(XmlDocument Doc, Pkcs12Store keyStore, string keyStorePasswort)
{
System.Security.Cryptography.X509Certificates.X509Certificate2 cert =
new System.Security.Cryptography.X509Certificates.X509Certificate2(CertHelper.ConvertPkcs12ToByteArray(keyStore, keyStorePasswort), keyStorePasswort);
//Heranziehen des privaten Schlüssels:
RSACryptoServiceProvider privateKeyProvider = null;
privateKeyProvider = (RSACryptoServiceProvider)(cert.PrivateKey);
//Kompatibilität Java Anfang -->
XmlElement keyNameNode = null;
string keyName = "rsaKeyName";
foreach (string keyNameName in GetNodeKeyNameCollection())
{
keyNameNode = Doc.GetElementsByTagName(keyNameName)[0] as XmlElement;
if (keyNameNode != null)
{
break;
}
}
if (keyNameNode == null)
{
XmlElement encryptedKey = null;
foreach (string encryptionKeyName in GetNodeEncryptionKeyNameCollection())
{
encryptedKey = Doc.GetElementsByTagName(encryptionKeyName)[0] as XmlElement;
if (encryptedKey != null)
{
break;
}
}
if (encryptedKey != null)
{
XmlElement elementKeyMethod = null;
foreach (string elementKeyMethodName in GetNodeEncryptionMethodCollection())
{
elementKeyMethod = encryptedKey.GetElementsByTagName(elementKeyMethodName)[0] as XmlElement;
if (elementKeyMethod != null)
{
break;
}
}
if (elementKeyMethod != null)
{
XmlElement elementKeyInfo = Doc.CreateElement("KeyInfo", SignedXml.XmlDsigNamespaceUrl);
XmlElement elementKeyName = Doc.CreateElement("KeyName", SignedXml.XmlDsigNamespaceUrl);
elementKeyName.InnerText = keyName;
elementKeyInfo.AppendChild(elementKeyName);
encryptedKey.InsertAfter(elementKeyInfo, elementKeyMethod);
}
}
}
else
{
if (!string.IsNullOrEmpty(keyNameNode.InnerText))
{
keyName = keyNameNode.InnerText;
}
else
{
keyName = "";
}
}
// Kompatibilität Java Ende <--
//Entschlüsselung:
EncryptedXml exml = new EncryptedXml(Doc);
exml.AddKeyNameMapping(keyName, privateKeyProvider);
exml.DecryptDocument();
}
public void DecryptData_SymmetricAlgorithmNull()
{
EncryptedXml ex = new EncryptedXml();
ex.DecryptData(new EncryptedData(), null);
}
public void EncryptData_SymmetricAlgorithmNull()
{
EncryptedXml ex = new EncryptedXml();
ex.EncryptData(new byte[16], null);
}
public void GetDecryptionIV_EncryptedDataNull()
{
EncryptedXml ex = new EncryptedXml();
ex.GetDecryptionIV(null, EncryptedXml.XmlEncAES128Url);
}
public void EncryptKey_KeyNull()
{
EncryptedXml.EncryptKey(null, Rijndael.Create());
}
public void DecryptEncryptedKey_Null()
{
EncryptedXml ex = new EncryptedXml();
Assert.Throws <ArgumentNullException>(() => ex.DecryptEncryptedKey(null));
}
/// <summary>
/// An example on how to decrypt an encrypted assertion.
/// </summary>
/// <param name="file">The file.</param>
public static void DecryptAssertion(string file)
{
var doc = new XmlDocument();
doc.Load(file);
var encryptedDataElement = GetElement(Schema.XEnc.EncryptedData.ElementName, Saml20Constants.Xenc, doc);
var encryptedData = new EncryptedData();
encryptedData.LoadXml(encryptedDataElement);
var nodelist = doc.GetElementsByTagName(Schema.XmlDSig.KeyInfo.ElementName, Saml20Constants.Xmldsig);
Assert.That(nodelist.Count > 0);
var key = new KeyInfo();
key.LoadXml((XmlElement)nodelist[0]);
// Review: Is it possible to figure out which certificate to load based on the Token?
/*
* Comment:
* It would be possible to provide a key/certificate identifier in the EncryptedKey element, which contains the "recipient" attribute.
* The implementation (Safewhere.Tokens.Saml20.Saml20EncryptedAssertion) currently just expects an appropriate asymmetric key to be provided,
* and is not not concerned about its origin.
* If the need arises, we can easily extend the Saml20EncryptedAssertion class with a property that allows extraction key info, eg. the "recipient"
* attribute.
*/
var cert = new X509Certificate2(@"Certificates\sts_dev_certificate.pfx", "test1234");
// ms-help://MS.MSDNQTR.v80.en/MS.MSDN.v80/MS.NETDEVFX.v20.en/CPref18/html/T_System_Security_Cryptography_Xml_KeyInfoClause_DerivedTypes.htm
// Look through the list of KeyInfo elements to find the encrypted key.
SymmetricAlgorithm symmetricKey = null;
foreach (KeyInfoClause keyInfoClause in key)
{
if (keyInfoClause is KeyInfoEncryptedKey)
{
var keyInfoEncryptedKey = (KeyInfoEncryptedKey)keyInfoClause;
var encryptedKey = keyInfoEncryptedKey.EncryptedKey;
symmetricKey = new RijndaelManaged
{
Key = EncryptedXml.DecryptKey(encryptedKey.CipherData.CipherValue, (RSA)cert.PrivateKey, false)
};
}
}
// Explode if we didn't manage to find a viable key.
Assert.IsNotNull(symmetricKey);
var encryptedXml = new EncryptedXml();
var plaintext = encryptedXml.DecryptData(encryptedData, symmetricKey);
var assertion = new XmlDocument();
assertion.Load(new StringReader(System.Text.Encoding.UTF8.GetString(plaintext)));
// A very simple test to ensure that there is indeed an assertion in the plaintext.
Assert.AreEqual(Assertion.ElementName, assertion.DocumentElement.LocalName);
Assert.AreEqual(Saml20Constants.Assertion, assertion.DocumentElement.NamespaceURI);
// At this point, assertion will contain a decrypted assertion.
}
public void EncryptKey_RSA_RSANull()
{
Assert.Throws <ArgumentNullException>(() => EncryptedXml.EncryptKey(new byte[16], null, false));
}
public void EncryptData_SymmetricAlgorithmNull()
{
EncryptedXml ex = new EncryptedXml();
Assert.Throws <ArgumentNullException>(() => ex.EncryptData(new byte[16], null));
}
public void EncryptKey_SymmetricAlgorithmNull()
{
Assert.Throws <ArgumentNullException>(() => EncryptedXml.EncryptKey(new byte[16], null));
}
public void GetDecryptionIV_EncryptedDataNull()
{
EncryptedXml ex = new EncryptedXml();
Assert.Throws <ArgumentNullException>(() => ex.GetDecryptionIV(null, EncryptedXml.XmlEncAES128Url));
}
public void GetIdElement_StringNull()
{
EncryptedXml ex = new EncryptedXml();
Assert.Throws <ArgumentNullException>(() => ex.GetIdElement(new XmlDocument(), null));
}
public void ReplaceElement_XmlElementNull()
{
Assert.Throws <ArgumentNullException>(() => EncryptedXml.ReplaceElement(null, new EncryptedData(), true));
}
public static void Encrypt(XmlDocument Doc, string ElementToEncrypt, string EncryptionElementID, RSA Alg, string KeyName)
{
if (Doc == null)
{
throw new ArgumentNullException("Doc");
}
if (ElementToEncrypt == null)
{
throw new ArgumentNullException("ElementToEncrypt");
}
if (EncryptionElementID == null)
{
throw new ArgumentNullException("EncryptionElementID");
}
if (Alg == null)
{
throw new ArgumentNullException("Alg");
}
if (KeyName == null)
{
throw new ArgumentNullException("KeyName");
}
XmlElement elementToEncrypt = Doc.GetElementsByTagName(ElementToEncrypt)[0] as XmlElement;
if (elementToEncrypt == null)
{
throw new XmlException("The specified element was not found");
}
Aes sessionKey = null;
try
{
EncryptedXml eXml = new EncryptedXml();
EncryptedData edElement = new EncryptedData();
EncryptedKey ek = new EncryptedKey();
DataReference dRef = new DataReference();
KeyInfoName kin = new KeyInfoName();
sessionKey = Aes.Create();
byte[] encryptedElement = eXml.EncryptData(elementToEncrypt, sessionKey, false);
edElement.Type = EncryptedXml.XmlEncElementUrl;
edElement.Id = EncryptionElementID;
edElement.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
byte[] encryptedKey = EncryptedXml.EncryptKey(sessionKey.Key, Alg, false);
ek.CipherData = new CipherData(encryptedKey);
ek.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);
dRef.Uri = "#" + EncryptionElementID;
ek.AddReference(dRef);
edElement.KeyInfo.AddClause(new KeyInfoEncryptedKey(ek));
kin.Value = KeyName;
ek.KeyInfo.AddClause(kin);
edElement.CipherData.CipherValue = encryptedElement;
EncryptedXml.ReplaceElement(elementToEncrypt, edElement, false);
}
catch (Exception e)
{
throw e;
}
finally
{
if (sessionKey != null)
{
sessionKey.Clear();
}
}
}
public void GetIdElement_WhenElementNameMustBeNonColonizedAndItContainsColon_ReturnsNull()
{
var sut = new EncryptedXml();
Assert.That(sut.GetIdElement(new XmlDocument(), "t:test"), Is.Null);
}
public static void Encrypt(XmlDocument Doc, string ElementToEncrypt, RSA Alg, string KeyName)
{
// 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
// a new random symmetric key.
//////////////////////////////////////////////////
// Create a 256 bit Rijndael key.
RijndaelManaged sessionKey = new RijndaelManaged();
sessionKey.KeySize = 256;
EncryptedXml eXml = new EncryptedXml();
byte[] encryptedElement = eXml.EncryptData(elementToEncrypt, sessionKey, 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.
edElement.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
// Encrypt the session key and add it to an EncryptedKey element.
EncryptedKey ek = new EncryptedKey();
byte[] encryptedKey = EncryptedXml.EncryptKey(sessionKey.Key, Alg, false);
ek.CipherData = new CipherData(encryptedKey);
ek.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);
// Set the KeyInfo element to specify the
// name of the RSA key.
// Create a new KeyInfo element.
edElement.KeyInfo = new KeyInfo();
// Create a new KeyInfoName element.
KeyInfoName kin = new KeyInfoName();
// Specify a name for the key.
kin.Value = KeyName;
// Add the KeyInfoName element to the
// EncryptedKey object.
ek.KeyInfo.AddClause(kin);
// Add the encrypted key to the
// EncryptedData object.
edElement.KeyInfo.AddClause(new KeyInfoEncryptedKey(ek));
// 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 void GetDecryptionIV_StringNull()
{
EncryptedXml ex = new EncryptedXml();
Assert.IsNull(ex.GetDecryptionIV(new EncryptedData(), null));
}
/// <summary>
/// 加密 XML 文件
/// </summary>
/// <param name="Doc"></param>
/// <param name="ElementToEncrypt"></param>
/// <param name="EncryptionElementID"></param>
/// <param name="Alg"></param>
/// <param name="KeyName"></param>
public static void Encrypt(XmlDocument Doc, string ElementToEncrypt, string EncryptionElementID, RSA Alg, string KeyName)
{
// Check the arguments.
if (Doc == null)
{
throw new ArgumentNullException("Doc");
}
if (ElementToEncrypt == null)
{
throw new ArgumentNullException("ElementToEncrypt");
}
if (EncryptionElementID == null)
{
throw new ArgumentNullException("EncryptionElementID");
}
if (Alg == null)
{
throw new ArgumentNullException("Alg");
}
if (KeyName == null)
{
throw new ArgumentNullException("KeyName");
}
////////////////////////////////////////////////
// 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");
}
RijndaelManaged sessionKey = null;
try
{
//////////////////////////////////////////////////
// Create a new instance of the EncryptedXml class
// and use it to encrypt the XmlElement with the
// a new random symmetric key.
//////////////////////////////////////////////////
// Create a 256 bit Rijndael key.
sessionKey = new RijndaelManaged();
sessionKey.KeySize = 256;
EncryptedXml eXml = new EncryptedXml();
byte[] encryptedElement = eXml.EncryptData(elementToEncrypt, sessionKey, false);
////////////////////////////////////////////////
// Construct an EncryptedData object and populate
// it with the desired encryption information.
////////////////////////////////////////////////
EncryptedData edElement = new EncryptedData();
edElement.Type = EncryptedXml.XmlEncElementUrl;
edElement.Id = EncryptionElementID;
// Create an EncryptionMethod element so that the
// receiver knows which algorithm to use for decryption.
edElement.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
// Encrypt the session key and add it to an EncryptedKey element.
EncryptedKey ek = new EncryptedKey();
byte[] encryptedKey = EncryptedXml.EncryptKey(sessionKey.Key, Alg, false);
ek.CipherData = new CipherData(encryptedKey);
ek.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);
// Create a new DataReference element
// for the KeyInfo element. This optional
// element specifies which EncryptedData
// uses this key. An XML document can have
// multiple EncryptedData elements that use
// different keys.
DataReference dRef = new DataReference();
// Specify the EncryptedData URI.
dRef.Uri = "#" + EncryptionElementID;
// Add the DataReference to the EncryptedKey.
ek.AddReference(dRef);
// Add the encrypted key to the
// EncryptedData object.
edElement.KeyInfo.AddClause(new KeyInfoEncryptedKey(ek));
// Set the KeyInfo element to specify the
// name of the RSA key.
// Create a new KeyInfo element.
edElement.KeyInfo = new KeyInfo();
// Create a new KeyInfoName element.
KeyInfoName kin = new KeyInfoName();
// Specify a name for the key.
kin.Value = KeyName;
// Add the KeyInfoName element to the
// EncryptedKey object.
ek.KeyInfo.AddClause(kin);
edElement.KeyInfo.AddClause(new KeyInfoEncryptedKey(ek));
// 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);
}
catch (Exception e)
{
// re-throw the exception.
throw e;
}
finally
{
if (sessionKey != null)
{
sessionKey.Clear();
}
}
}
public void EncryptKey_SymmetricAlgorithmNull()
{
EncryptedXml.EncryptKey(new byte [16], null);
}
public override XmlNode Encrypt(XmlNode node)
{
XmlDocument xmlDocument;
EncryptedXml exml;
byte[] rgbOutput;
EncryptedData ed;
KeyInfoName kin;
EncryptedKey ek;
KeyInfoEncryptedKey kek;
XmlElement inputElement;
RSACryptoServiceProvider rsa = GetCryptoServiceProvider(false, false);
// Encrypt the node with the new key
xmlDocument = new XmlDocument();
xmlDocument.PreserveWhitespace = true;
xmlDocument.LoadXml("<foo>" + node.OuterXml + "</foo>");
exml = new EncryptedXml(xmlDocument);
inputElement = xmlDocument.DocumentElement;
using (SymmetricAlgorithm symAlg = GetSymAlgorithmProvider()) {
rgbOutput = exml.EncryptData(inputElement, symAlg, true);
ed = new EncryptedData();
ed.Type = EncryptedXml.XmlEncElementUrl;
ed.EncryptionMethod = GetSymEncryptionMethod();
ed.KeyInfo = new KeyInfo();
ek = new EncryptedKey();
ek.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);
ek.KeyInfo = new KeyInfo();
ek.CipherData = new CipherData();
ek.CipherData.CipherValue = EncryptedXml.EncryptKey(symAlg.Key, rsa, UseOAEP);
}
kin = new KeyInfoName();
kin.Value = _KeyName;
ek.KeyInfo.AddClause(kin);
kek = new KeyInfoEncryptedKey(ek);
ed.KeyInfo.AddClause(kek);
ed.CipherData = new CipherData();
ed.CipherData.CipherValue = rgbOutput;
EncryptedXml.ReplaceElement(inputElement, ed, true);
rsa.Clear();
// Get node from the document
foreach (XmlNode node2 in xmlDocument.ChildNodes)
{
if (node2.NodeType == XmlNodeType.Element)
{
foreach (XmlNode node3 in node2.ChildNodes) // node2 is the "foo" node
{
if (node3.NodeType == XmlNodeType.Element)
{
return(node3); // node3 is the "EncryptedData" node
}
}
}
}
return(null);
}
public void EncryptData_DataNull()
{
EncryptedXml ex = new EncryptedXml();
ex.EncryptData(null, Rijndael.Create());
}
public void ReplaceData_XmlElementNull()
{
EncryptedXml ex = new EncryptedXml();
ex.ReplaceData(null, new byte[0]);
}
public void EncryptData_XmlElementNull()
{
EncryptedXml ex = new EncryptedXml();
ex.EncryptData(null, Rijndael.Create(), true);
}
public void ReplaceElement_XmlElementNull()
{
EncryptedXml.ReplaceElement(null, new EncryptedData(), true);
}
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 void ReplaceElement_EncryptedDataNull()
{
XmlDocument doc = new XmlDocument();
EncryptedXml.ReplaceElement(doc.DocumentElement, null, false);
}
public void DecryptKey_NotSupportedAlgorithm()
{
Assert.Throws <CryptographicException>(() => EncryptedXml.DecryptKey(new byte[16], new NotSupportedSymmetricAlgorithm()));
}
public void GetIdElement_XmlDocumentNull()
{
EncryptedXml ex = new EncryptedXml();
Assert.IsNull(ex.GetIdElement(null, "value"));
}
public void Decrypt(string xmlFileName)
{
TripleDESCryptoServiceProvider encryptionKey = new TripleDESCryptoServiceProvider();
encryptionKey.Key = UTF8Encoding.UTF8.GetBytes(""); // your salt value
XmlDocument document = new XmlDocument();
document.Load(xmlFileName);
XmlElement encOrderElem = document.GetElementsByTagName("EncryptedData")[0] as XmlElement;
EncryptedData encData = new EncryptedData();
encData.LoadXml(encOrderElem);
EncryptedXml encryptedXml = new EncryptedXml();
byte[] decryptedOrder = encryptedXml.DecryptData(encData, encryptionKey);
encryptedXml.ReplaceData(encOrderElem, decryptedOrder);
document.Save(xmlFileName);
}
public void ReplaceData_XmlElementNull()
{
EncryptedXml ex = new EncryptedXml();
Assert.Throws <ArgumentNullException>(() => ex.ReplaceData(null, new byte[0]));
}
