Tutorial :RSA Encryption public key not returned from container?



Question:

I feel like what I am trying to do is very simple. But for some reason it doesn't want to work:

Here is a complete code snippet to test what I am trying to do:

using System;  using System.Xml;  using System.Security.Cryptography;  using System.Security.Cryptography.Xml;    namespace XmlCryptographySendingTest  {      class Program      {          static void Main(string[] args)          {              string fullKeyContainer = "fullKeyContainer";              string publicKeyContainer = "publicKeyContainer";          //create the two providers          RSACryptoServiceProvider serverRSA = GetKeyFromContainer(fullKeyContainer);            //save public and full key pairs          SaveKeyToContainer(fullKeyContainer, serverRSA.ExportParameters(true));          SaveKeyToContainer(publicKeyContainer, serverRSA.ExportParameters(false));            //get rid of them from memory          serverRSA.Clear();          serverRSA = null;          GC.Collect();            //retrieve a full server set and a private client set          serverRSA = GetKeyFromContainer(fullKeyContainer);          RSACryptoServiceProvider clientRSA = GetKeyFromContainer(publicKeyContainer);            //at this point the public key should be the same for both RSA providers          string clientPublicKey = clientRSA.ToXmlString(false);          string serverPublicKey = serverRSA.ToXmlString(false);            if (clientPublicKey.Equals(serverPublicKey))          {//they have the same public key.                // 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);              }                //we can encypt with the clientRSA using the public key              Encrypt(xmlDoc, "Fields", "DataFields", clientRSA, "test");                Console.WriteLine("Encrypted: \r\n" + xmlDoc.OuterXml);                //and should be able to decrypt with the serverRSA using the private key              Decrypt(xmlDoc, serverRSA, "test");                Console.WriteLine("Decrypted : \r\n" + xmlDoc.OuterXml);          }          else          {              Console.WriteLine("The two RSA have different public keys...");          }            Console.ReadLine();      }            private static CspParameters GetCspParameters(string containerName)      {          // Create the CspParameters object and set the key container           // name used to store the RSA key pair.          CspParameters tmpParameters = new CspParameters();          tmpParameters.Flags = CspProviderFlags.UseMachineKeyStore; //use the machine key store--this allows us to use the machine level container when applications run without a logged-in user          tmpParameters.ProviderType = 1;          tmpParameters.KeyNumber = (int)KeyNumber.Exchange;          tmpParameters.KeyContainerName = containerName;          return tmpParameters;      }          public static void SaveKeyToContainer(string containerName, RSAParameters rsaParameters)      {          CspParameters tmpParameters = GetCspParameters(containerName);            // Create a new instance of RSACryptoServiceProvider that accesses          // the key container           RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(tmpParameters);            //set the key information from the text          rsa.ImportParameters(rsaParameters);      }        public static RSACryptoServiceProvider GetKeyFromContainer(string containerName)      {          // Create the CspParameters object and set the key container           // name used to store the RSA key pair.          CspParameters tmpParameters = GetCspParameters(containerName);            // Create a new instance of RSACryptoServiceProvider that accesses          // the key container.          RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(tmpParameters);            return rsa;      }        public static void DeleteKeyFromContainer(string containerName)      {          // Create the CspParameters object and set the key container           // name used to store the RSA key pair.          CspParameters tmpParameters = GetCspParameters(containerName);            // Create a new instance of RSACryptoServiceProvider that accesses          // the key container.          RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(tmpParameters);            // Delete the key entry in the container.          rsa.PersistKeyInCsp = false;            // Call Clear to release resources and delete the key from the container.          rsa.Clear();      }            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 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 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 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();            }        }  }  

This seems to work fine as long as I am saving/getting an RSACryptoServiceProvider with both a private and public key. Once I save a RSACryptoServiceProvider with JUST a public key, the next time I try to retrieve it all I get is a NEW and DIFFERENT RSACryptoServiceProvider!

As you can imagine, you cant encrypt something with one set of keys, and then try to decrypt with a whole new set!

Any ideas on why this is happening? or what the correct way would be to store a public-only key?


Solution:1

I had a very similar question.

I'm now almost certain that the key containers cannot be used to store public keys. Their primary purpose appears to be for storing key pairs. The key container does only store the key that is originally generated, and importing a PublicOnly key affects only the instance and not the storage.

The "How to: Store Asymmetric Keys in a Key Container" page of the .NET Developer's Guide states that

If you need to store a private key, you should use a key container

... which is about as clear a a statement as I've been able to find through MSDN.

The substitute mechanism I used was to store the key in an XML file (since it's a public key it shouldn't matter if it's easily visible), with permissions set using File System Access Rules to prevent unwanted modification.


Solution:2

My understanding is that your call to ImportParameters in SaveKeyToContainer is not affecting the key in the store. Your implementation of SaveKeyToContainer is initializing an instance of RSACryptoServiceProvider using the key in the store (generating a new key pair when the container does not exist) and then importing the parameters, which affects the instance and not the store.

When you retrieve publicKeyContainer later, you are given the new key pair that was generated when you attempted to save it and not the imported public fragment.

Sorry, I can't help with any details about importing the key into the store with the Cryptography API. I believe the store only supports key pairs, i.e. don't expect to be able to import just the public key.


Solution:3

The documentation for the .NET Crypto Classes is very poor.

I have being beating my brains out with the same issue and have come to the same conclusion even though it is not stated for definite in the docs.

When you create an instance of the the RSA provider, you get a new key pair. If you provide a parameter object and name a key container, the new key pair is stored there.

If you import a public key, it does not get persisted!

Dan


Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Previous
Next Post »