/// <summary> /// Decrypts the specified XML element. /// </summary> /// <param name="encryptedElement">An encrypted XML element.</param> /// <returns>The decrypted form of <paramref name="encryptedElement"/>.</returns> /// <remarks> public XElement Decrypt(XElement encryptedElement) { if (encryptedElement == null) { throw new ArgumentNullException(nameof(encryptedElement)); } // <EncryptedData Type="http://www.w3.org/2001/04/xmlenc#Element" xmlns="http://www.w3.org/2001/04/xmlenc#"> // ... // </EncryptedData> // EncryptedXml works with XmlDocument, not XLinq. When we perform the conversion // we'll wrap the incoming element in a dummy <root /> element since encrypted XML // doesn't handle encrypting the root element all that well. var xmlDocument = new XmlDocument(); xmlDocument.Load(new XElement("root", encryptedElement).CreateReader()); var elementToDecrypt = (XmlElement)xmlDocument.DocumentElement.FirstChild; // Perform the decryption and update the document in-place. var encryptedXml = new EncryptedXml(xmlDocument); _decryptor.PerformPreDecryptionSetup(encryptedXml); encryptedXml.DecryptDocument(); // Strip the <root /> element back off and convert the XmlDocument to an XElement. return XElement.Load(xmlDocument.DocumentElement.FirstChild.CreateNavigator().ReadSubtree()); }
/// <summary> /// Decrypt data with X509 certificate /// </summary> /// <param name="encryptedNode"></param> /// <returns></returns> public override System.Xml.XmlNode Decrypt(System.Xml.XmlNode encryptedNode) { XmlDocument doc = encryptedNode.OwnerDocument; EncryptedXml eXml = new EncryptedXml(doc); eXml.DecryptDocument(); return doc.DocumentElement; }
/// <summary> /// 解密Xml。 /// </summary> /// <param name="doc"></param> public static void DecryptorXml(XmlDocument doc) { if (doc != null) { EncryptedXml encXml = new EncryptedXml(doc); encXml.AddKeyNameMapping("session", keyAlgorithm); encXml.DecryptDocument(); } }
public override XmlNode Decrypt(XmlNode encryptedNode) { // Load config section to encrypt into xmlDocument instance XmlDocument doc = encryptedNode.OwnerDocument; EncryptedXml eXml = new EncryptedXml(doc); // Add a key-name mapping. This method can only decrypt documents that present the specified key name. eXml.AddKeyNameMapping(this.keyName, this.rsaKey); eXml.DecryptDocument(); return doc.DocumentElement; }
public override XmlNode Decrypt(XmlNode encryptedNode) { XmlDocument document = new XmlDocument(); EncryptedXml xml = null; RSACryptoServiceProvider cryptoServiceProvider = this.GetCryptoServiceProvider(false, true); document.PreserveWhitespace = true; document.LoadXml(encryptedNode.OuterXml); xml = new EncryptedXml(document); xml.AddKeyNameMapping(this._KeyName, cryptoServiceProvider); xml.DecryptDocument(); cryptoServiceProvider.Clear(); return document.DocumentElement; }
public override XmlNode Decrypt (XmlNode encrypted_node) { XmlDocument doc = new ConfigurationXmlDocument (); doc.Load (new StringReader (encrypted_node.OuterXml)); EncryptedXml ex = new EncryptedXml (doc); ex.AddKeyNameMapping ("Rsa Key", GetProvider ()); ex.DecryptDocument (); return doc.DocumentElement; }
public override XmlNode Decrypt(XmlNode encryptedNode) { XmlDocument xmlDocument = new XmlDocument(); EncryptedXml exml = null; RSACryptoServiceProvider rsa = GetCryptoServiceProvider(false, true); xmlDocument.PreserveWhitespace = true; xmlDocument.LoadXml(encryptedNode.OuterXml); exml = new EncryptedXml(xmlDocument); exml.AddKeyNameMapping(_KeyName, rsa); exml.DecryptDocument(); rsa.Clear(); return xmlDocument.DocumentElement; }
/// <summary> /// Permite desencriptar con una llave privada un documento XML encriptado con una clave pública /// </summary> /// <param name="xmlIn"></param> /// <param name="privateKey"></param> /// <returns></returns> public static XmlDocument DecryptXml(XmlDocument xmlIn, RSA privateKey) { const string keyName = "Llave"; if ((xmlIn == null)) { throw new ArgumentNullException("xmlIn"); } if ((privateKey == null)) { throw new ArgumentNullException("privateKey"); } var exml = new EncryptedXml(xmlIn); exml.AddKeyNameMapping(keyName, privateKey); exml.DecryptDocument(); return xmlIn; }
public static void Decrypt(XmlDocument Doc, RSA Alg, string KeyName) { // Check the arguments. if (Doc == null) throw new ArgumentNullException("Doc"); if (Alg == null) throw new ArgumentNullException("Alg"); if (KeyName == null) throw new ArgumentNullException("KeyName"); // Create a new EncryptedXml object. EncryptedXml exml = new EncryptedXml(Doc); // Add a key-name mapping. // This method can only decrypt documents // that present the specified key name. exml.AddKeyNameMapping(KeyName, Alg); // Decrypt the element. exml.DecryptDocument(); }
public static void DecryptXmlDocument( Stream sourceXmlFile, Stream destinationXmlFile, X509Certificate2 certificate) { // Apro il documento XmlDocument doc = new XmlDocument(); doc.Load(sourceXmlFile); // Decifro il nodo di tipo elemento EncryptedXml enc = new EncryptedXml(doc); enc.DecryptDocument(); // Salvo il risultato doc.Save(destinationXmlFile); }
public ActionResult Index(XmlModel model) { if (model.Action == "encrypt") { var recipientCertificate = LoadCertificate(model.RecipientThumbprint); var signingCertificate = LoadCertificate(model.SenderThumbprint); var xmlDocument = new XmlDocument(); xmlDocument.LoadXml(model.PlainText); var elementToEncrypt = xmlDocument.GetElementsByTagName("message")[0] as XmlElement; var encryptedXml = new EncryptedXml(); // Encrypt the element. var encryptedElement = encryptedXml.Encrypt(elementToEncrypt, recipientCertificate); EncryptedXml.ReplaceElement(elementToEncrypt, encryptedElement, false); // Sign the document var signedXml = new SignedXml(xmlDocument) { SigningKey = signingCertificate.PrivateKey }; var reference = new Reference { Uri = string.Empty }; var transform = new XmlDsigC14NTransform(); reference.AddTransform(transform); var envelope = new XmlDsigEnvelopedSignatureTransform(); reference.AddTransform(envelope); signedXml.AddReference(reference); var keyInfo = new KeyInfo(); keyInfo.AddClause(new KeyInfoX509Data(signingCertificate)); signedXml.KeyInfo = keyInfo; signedXml.ComputeSignature(); var xmlDigitalSignature = signedXml.GetXml(); xmlDocument.DocumentElement.AppendChild(xmlDocument.ImportNode(xmlDigitalSignature, true)); model.PlainText = ""; model.Envelope = XmlToString(xmlDocument); } else if (model.Action == "decrypt") { var xmlDocument = new XmlDocument(); xmlDocument.LoadXml(model.Envelope); // Validate the signature var signedXml = new SignedXml(xmlDocument); var nodeList = xmlDocument.GetElementsByTagName("Signature"); if (nodeList.Count <= 0) { throw new Exception("No signature found."); } signedXml.LoadXml((XmlElement)nodeList[0]); AsymmetricAlgorithm signingKey; if (!signedXml.CheckSignatureReturningKey(out signingKey)) { throw new Exception("Invalid Signature"); } else { IEnumerable<X509Certificate2> keyInfoCertificates = signedXml.KeyInfo.OfType<KeyInfoX509Data>() .SelectMany(x => x.Certificates.Cast<X509Certificate2>()); var signingCertificate = keyInfoCertificates.FirstOrDefault(x => x.PublicKey.Key == signingKey); if (signingCertificate == null) { throw new Exception("Signing certificate not found in KeyInfo."); } model.SenderSubject = signingCertificate.Subject; } var encryptedXml = new EncryptedXml(xmlDocument); encryptedXml.DecryptDocument(); model.Envelope = ""; model.PlainText = XmlToString(xmlDocument); } ModelState.Clear(); model.RecipientThumbprint = RecipientThumbprint; model.SenderThumbprint = SenderThumbprint; return View(model); }
public static void Decrypt(XmlDocument Doc,AsymmetricAlgorithm privateKey) { EncryptedXml exml = new EncryptedXml(Doc); exml.AddKeyNameMapping("encKey", privateKey); exml.DecryptDocument(); }
//解密 private void btn2Open_Click(object sender, EventArgs e) { try { RSACryptoServiceProvider rsaKey = new RSACryptoServiceProvider(); rsaKey.FromXmlString(privateK); XmlDocument xmlDoc = new XmlDocument(); xmlDoc.PreserveWhitespace = true; xmlDoc.Load(this.label2.Text); EncryptedXml exml = new EncryptedXml(xmlDoc); exml.AddKeyNameMapping(keyName, rsaKey); exml.DecryptDocument(); xmlDoc.Save(this.label2.Text); succes(); } catch (Exception) { fail(); } }
public XmlDocument DecryptEncriptedXmlfile(string txtEncryptedXml) { XmlDocument xmlEncDoc = new XmlDocument(); xmlEncDoc.LoadXml(txtEncryptedXml); var rsa = new RSACryptoServiceProvider(); EncryptedXml encXml = new EncryptedXml(xmlEncDoc); encXml.AddKeyNameMapping("asyncKey", rsa); encXml.DecryptDocument(); return xmlEncDoc; }
public static void Decrypt(string xmlEncrypted, SymmetricAlgorithm Alg, string KeyName) { XmlDocument xmlDoc = new XmlDocument(); xmlDoc.PreserveWhitespace = true; xmlDoc.LoadXml(xmlEncrypted); // Create a new EncryptedXml object. EncryptedXml exml = new EncryptedXml(xmlDoc); // Add a key-name mapping. // This method can only decrypt documents // that present the specified key name. exml.AddKeyNameMapping(KeyName, Alg); // Decrypt the element. exml.DecryptDocument(); }
public static string Decrypt(string xmlEncrypted, string elementPath, SymmetricAlgorithm symmetricAlgorithm) { // Check the arguments. if (string.IsNullOrEmpty(xmlEncrypted)) throw new ArgumentNullException("xml"); if (string.IsNullOrEmpty(elementPath)) throw new ArgumentNullException("elementPath"); if (symmetricAlgorithm == null) throw new ArgumentNullException("SymmetricAlgorithm "); XmlDocument xmlDoc = new XmlDocument(); xmlDoc.PreserveWhitespace = true; xmlDoc.LoadXml(xmlEncrypted); // Find the EncryptedData element in the XmlDocument. XmlNodeList encryptedElementxmlDoc = xmlDoc.GetElementsByTagName("EncryptedData"); // If the EncryptedData element was not found, throw an exception. if (encryptedElementxmlDoc == null) { throw new XmlException("The EncryptedData element was not found."); } EncryptedData edElement; EncryptedXml exml = new EncryptedXml(xmlDoc); // Add a key-name mapping. // This method can only decrypt documents // that present the specified key name. exml.AddKeyNameMapping("", symmetricAlgorithm); exml.DecryptDocument(); //foreach (XmlNode node in encryptedElementxmlDoc) //{ // // Create an EncryptedData object and populate it. // edElement = new EncryptedData(); // edElement.LoadXml(node as XmlElement); // exml = new EncryptedXml(); // exml.DecryptDocument(); // //// Decrypt the element using the symmetric key. // //byte[] rgbOutput = exml.DecryptData(edElement, symmetricAlgorithm); // //// Replace the encryptedData element with the plaintext XML element. // //exml.ReplaceData(node as XmlElement, rgbOutput); //} symmetricAlgorithm.Clear(); xmlEncrypted = xmlDoc.InnerXml; xmlDoc = null; return xmlEncrypted; }