/// <summary>バイト配列を暗号化する</summary>
        /// <param name="source">暗号化するバイト配列</param>
        /// <param name="publicKey">暗号化に使用する公開鍵</param>
        /// <returns>非対称アルゴリズムで暗号化されたバイト配列</returns>
        public static byte[] EncryptBytes(byte[] source, string publicKey)
        {
            // RSACryptoServiceProviderオブジェクトの作成
            RSACryptoServiceProvider rsa
                = (RSACryptoServiceProvider)RSACryptoServiceProvider.Create(); // devps(1703)

            // 公開鍵
            rsa.FromXmlString(publicKey);

            // 暗号化する
            byte[] temp = rsa.Encrypt(source, false);
            rsa.Clear(); // devps(1725)
            return(temp);
        }
        /// <summary>暗号化されたバイト配列を復号化する</summary>
        /// <param name="source">暗号化されたバイト配列</param>
        /// <param name="privateKey">復号化に使用する秘密鍵</param>
        /// <returns>非対称アルゴリズムで復号化されたバイト配列</returns>
        public static byte[] DecryptBytes(byte[] source, string privateKey)
        {
            // RSACryptoServiceProviderオブジェクトの作成
            RSACryptoServiceProvider rsa
                = (RSACryptoServiceProvider)RSACryptoServiceProvider.Create(); // devps(1703)

            // 秘密鍵
            rsa.FromXmlString(privateKey);

            // 復号化
            byte[] temp = rsa.Decrypt(source, false);
            rsa.Clear(); // devps(1725)
            return(temp);
        }
示例#3
0
        public byte[] UDPRecivedToDecrypt(RSAParameters parametres, byte[] data)
        {
            byte[] dataToEncrypt = data;
            byte[] decryptedData;

            using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
            {
                RSA.Clear();
                RSA.ImportParameters(parametres);
                decryptedData = RSADecrypt(dataToEncrypt, RSA.ExportParameters(true), false);
            }

            return(decryptedData);
        }
示例#4
0
    public static void Main(String[] args)
    {
        // Generate a signing key.
        RSACryptoServiceProvider Key = new RSACryptoServiceProvider();

        string xsl = @"
    <xs:transform xmlns:xs='http://www.w3.org/1999/XSL/Transform' version='1.0'>
        <xs:template match='/'>
            <xs:apply-templates/>
        </xs:template>
        <xs:template match='ElementToTransform'> 
            <transformedElement/>
        </xs:template>
    </xs:transform>";

        try
        {
            // 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", Key, xsl);
            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.");
            }
            else
            {
                Console.WriteLine("The XML signature is not valid.");
            }
        }
        catch (CryptographicException e)
        {
            Console.WriteLine(e.Message);
        }
        finally
        {
            Key.Clear();
        }
    }
        static byte[] EncryptUsingContainer(string value, string containerName)
        {
            CspParameters cspParams = new CspParameters();

            cspParams.KeyContainerName = containerName;
            using (var rsa = new RSACryptoServiceProvider(cspParams))
            {
                byte[] encodedData   = System.Text.Encoding.Default.GetBytes(value);
                byte[] encryptedData = rsa.Encrypt(encodedData, true);

                rsa.Clear();
                return(encryptedData);
            }
        }
        static string DecryptUsingContainer(byte[] encryptedData, string container)
        {
            CspParameters cspParams = new CspParameters();

            cspParams.KeyContainerName = container;
            using (var rsa = new RSACryptoServiceProvider(cspParams))
            {
                byte[] decryptedData  = rsa.Decrypt(encryptedData, true);
                string decryptedValue = Encoding.Default.GetString(decryptedData);

                rsa.Clear();
                return(decryptedValue);
            }
        }
示例#7
0
 /// <summary>
 /// Takes a string and creates a signed hash of it
 /// </summary>
 /// <param name="Input">Input string</param>
 /// <param name="Key">Key to encrypt/sign with</param>
 /// <param name="Hash">This will be filled with the unsigned hash</param>
 /// <param name="EncodingUsing">Encoding that the input is using (defaults to UTF8)</param>
 /// <returns>A signed hash of the input (64bit string)</returns>
 public override string SignHash(string Input, string Key, out string Hash, Encoding EncodingUsing = null)
 {
     Contract.Requires <ArgumentNullException>(!string.IsNullOrEmpty(Key), "Key");
     Contract.Requires <ArgumentNullException>(!string.IsNullOrEmpty(Input), "Input");
     using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
     {
         RSA.FromXmlString(Key);
         var HashBytes  = Input.ToByteArray(EncodingUsing).Hash();
         var SignedHash = RSA.SignHash(HashBytes, CryptoConfig.MapNameToOID("SHA1"));
         RSA.Clear();
         Hash = HashBytes.ToString(Base64FormattingOptions.None);
         return(SignedHash.ToString(Base64FormattingOptions.None));
     }
 }
示例#8
0
        private string Encrypt(out RSAParameters privateKey)
        {
            var textAsBites = Encoding.UTF8.GetBytes(text);

            var rsa = new RSACryptoServiceProvider(keySize);

            privateKey = rsa.ExportParameters(true);

            var encryptedText = rsa.Encrypt(textAsBites, rsaPadding);

            rsa.Clear();

            return(Convert.ToBase64String(encryptedText, 0, encryptedText.Length));
        }
示例#9
0
        public void DeleteKeyFromContainer(string containerName)
        {
            var cp = new CspParameters
            {
                KeyContainerName = containerName
            };

            var rsa = new RSACryptoServiceProvider(cp)
            {
                PersistKeyInCsp = false
            };

            rsa.Clear();
        }
示例#10
0
文件: Rsa.cs 项目: wingahi/CSHive
        /// <summary>
        /// 删除密钥
        /// </summary>
        /// <param name="containerName"></param>
        public void DeleteKeyFromContainer(string containerName)
        {
            var cp = new CspParameters {
                KeyContainerName = containerName
            };
            var rsa = new RSACryptoServiceProvider(cp)
            {
                // Delete the key entry in the container.
                PersistKeyInCsp = false
            };

            // Call Clear to release resources and delete the key from the container.
            rsa.Clear();
        }
示例#11
0
        public void DeleteKeyInCsp()
        {
            var cspParameters = new CspParameters
            {
                KeyContainerName = containerName,
            };

            using var rsaProvider = new RSACryptoServiceProvider(cspParameters)
                  {
                      PersistKeyInCsp = false,
                  };

            rsaProvider.Clear();
        }
示例#12
0
文件: NET45.cs 项目: xhute/Kooboo
        public void GenerateRsa(string privateKeyPath, string publicKeyPath, int size)
        {
            //stream to save the keys
            FileStream   fs = null;
            StreamWriter sw = null;

            //create RSA provider
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(size);

            try
            {
                //save private key
                fs = new FileStream(privateKeyPath, FileMode.Create, FileAccess.Write);
                sw = new StreamWriter(fs);
                sw.Write(rsa.ToXmlString(true));
                sw.Flush();
            }
            finally
            {
                if (sw != null)
                {
                    sw.Close();
                }
                if (fs != null)
                {
                    fs.Close();
                }
            }

            try
            {
                //save public key
                fs = new FileStream(publicKeyPath, FileMode.Create, FileAccess.Write);
                sw = new StreamWriter(fs);
                sw.Write(rsa.ToXmlString(false));
                sw.Flush();
            }
            finally
            {
                if (sw != null)
                {
                    sw.Close();
                }
                if (fs != null)
                {
                    fs.Close();
                }
            }
            rsa.Clear();
        }
示例#13
0
        public void DeleteKeyFromContainer(string ContainerName)
        {
            CspParameters cp = new CspParameters();

            cp.KeyContainerName = ContainerName;

            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(cp);

            rsa.PersistKeyInCsp = false;

            rsa.Clear();

            Console.WriteLine("Key deleted.");
        }
        public override XmlNode Decrypt(XmlNode encryptedNode)
        {
            XmlDocument              xmlDocument = new XmlDocument();
            EncryptedXml             exml        = null;
            RSACryptoServiceProvider rsa         = GetCryptoServiceProvider(false, true);

            xmlDocument.PreserveWhitespace = true;
            ProtectedConfigurationProvider.LoadXml(xmlDocument, encryptedNode.OuterXml);
            exml = new FipsAwareEncryptedXml(xmlDocument);
            exml.AddKeyNameMapping(_KeyName, rsa);
            exml.DecryptDocument();
            rsa.Clear();
            return(xmlDocument.DocumentElement);
        }
示例#15
0
        /// <summary>
        /// 非对称加密字符串数据,返回加密后的数据
        /// </summary>
        /// <param name="publicKey">公钥</param>
        /// <param name="originalString">待加密的字符串</param>
        /// <returns>加密后的数据</returns>
        public static string RSAEncrypt(string publicKey, string originalString)
        {
            //byte[] PlainTextBArray;
            //byte[] CypherTextBArray;
            //string Result;
            //RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            //rsa.FromXmlString(publicKey);
            //PlainTextBArray = (new UnicodeEncoding()).GetBytes(originalString);
            //CypherTextBArray = rsa.Encrypt(PlainTextBArray, false);
            //Result = Convert.ToBase64String(CypherTextBArray);
            //return Result;

            //分段加密方法
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();

            rsa.FromXmlString(publicKey);
            byte[] originalBytes = (new UnicodeEncoding()).GetBytes(originalString);

            //实现分段
            int keySize    = rsa.KeySize / 8;
            int bufferSize = keySize - 11;

            byte[]       buffer   = new byte[bufferSize];
            MemoryStream msInput  = new MemoryStream(originalBytes);
            MemoryStream msOutput = new MemoryStream();

            int readLen = msInput.Read(buffer, 0, bufferSize);

            while (readLen > 0)
            {
                byte[] dataToEnc = new byte[readLen];
                Array.Copy(buffer, 0, dataToEnc, 0, readLen);

                byte[] encData = rsa.Encrypt(dataToEnc, false);
                msOutput.Write(encData, 0, encData.Length);

                readLen = msInput.Read(buffer, 0, bufferSize);
            }

            msInput.Close();
            byte[] result    = msOutput.ToArray();
            var    strResult = Convert.ToBase64String(result);

            //得到加密结果
            msOutput.Close();
            rsa.Clear();

            return(strResult);
        }
        protected override void OnLoad(EventArgs e)
        {
            if (PowerWebPartHelper.IsPowerUser == false)
            {
                throw new SecurityException("Just for Farm Administrators!");
            }

            store = PowerWebPartStore.Current;

            if (IsPostBack == false)
            {
                txtPowerLibraryUrl.Text             = store.PowerLibraryUrl;
                impersonatePowerLibraryUser.Checked = store.PowerLibraryImpersonate;
            }

            btnSave.Click      += new EventHandler(btnSave_Click);
            btnExportKey.Click += new EventHandler(btnExportKey_Click);
            btnCreateKey.Click += new EventHandler(btnCreateKey_Click);

            if (String.IsNullOrEmpty(txtPowerLibraryUrl.Text) == false)
            {
                ValidateDocumentLibrary();
            }
            store.PowerLibraryUrl = txtPowerLibraryUrl.Text;

            if (uploadKey.HasFile)
            {
                RSACryptoServiceProvider rsaAlg = CreateRsa();
                try
                {
                    string fileAsString = Encoding.UTF8.GetString(uploadKey.FileBytes);
                    rsaAlg.FromXmlString(fileAsString);
                    store.SigningKey = fileAsString;
                }
                catch (Exception ex)
                {
                    throw new Exception("Not a valid key file!");
                }
                finally
                {
                    if (rsaAlg != null)
                    {
                        rsaAlg.Clear();
                    }
                }
            }

            base.OnLoad(e);
        }
示例#17
0
        static void Main(string[] args)
        {
            string        KeyContainerName = "MyKeyContainer";//Usamos container para armazenar nossas chaves de texto puro
            string        clearText        = "This is the data we want to encrypt!";
            CspParameters cspParams        = new CspParameters();

            cspParams.KeyContainerName = KeyContainerName;

            RSAParameters publicKey;
            RSAParameters privateKey;
            string        publicKeyXML  = null;
            string        privateKeyXML = null;

            using (var rsa = new RSACryptoServiceProvider(cspParams))
            {
                rsa.PersistKeyInCsp = true;
                publicKey           = rsa.ExportParameters(false); //se for false chave publica
                privateKey          = rsa.ExportParameters(true);  //Se for verdadeiro cria um RSAParamters privado

                publicKeyXML  = rsa.ToXmlString(false);
                privateKeyXML = rsa.ToXmlString(true);
                rsa.Clear();
            }

            byte[] encrypted = EncryptUsingRSAParam(clearText, publicKey);
            string decrypted = DecryptUsingRSAParam(encrypted, privateKey);

            Console.WriteLine("Asymmetric RSA - Using RSA Params");
            Console.WriteLine("Encrypted:{0}", Convert.ToBase64String(encrypted));
            Console.WriteLine("Decrypted:{0}", decrypted);

            Console.WriteLine("\n");
            Console.WriteLine("Asymmetric RSA - Using Persistent Key Container");
            encrypted = EncryptUsingContainer(clearText, cspParams);
            decrypted = DecryptUsingContainer(encrypted, cspParams);

            Console.WriteLine("Encrypted:{0}", Convert.ToBase64String(encrypted));
            Console.WriteLine("Decrypted:{0}", decrypted);

            Console.WriteLine("\n");
            Console.WriteLine("Asymmetric RSA - Using Xml");
            encrypted = EncryptUsingXML(clearText, publicKeyXML);
            decrypted = DecryptUsingXML(encrypted, privateKeyXML);

            Console.WriteLine("Encrypted:{0}", Convert.ToBase64String(encrypted));
            Console.WriteLine("Decrypted:{0}", decrypted);

            Console.ReadLine();
        }
示例#18
0
        static byte[] DecryptData(byte[] ciphertext)
        {
            byte[] plainBytes;

            using (var rsa = new RSACryptoServiceProvider(2048))
            {
                rsa.PersistKeyInCsp = false;
                rsa.ImportParameters(privateKey);

                plainBytes = rsa.Decrypt(ciphertext, true);
                rsa.Clear();
            }

            return(plainBytes);
        }
 /// <summary>
 /// Verifies a signed hash against the unsigned version
 /// </summary>
 /// <param name="Hash">The unsigned hash (should be 64bit string)</param>
 /// <param name="SignedHash">The signed hash (should be 64bit string)</param>
 /// <param name="Key">The key to use in decryption</param>
 /// <returns>True if it is verified, false otherwise</returns>
 public override bool VerifyHash(string Hash, string SignedHash, string Key)
 {
     Contract.Requires <ArgumentNullException>(!string.IsNullOrEmpty(Key), "Key");
     Contract.Requires <ArgumentNullException>(!string.IsNullOrEmpty(Hash), "Hash");
     Contract.Requires <ArgumentNullException>(!string.IsNullOrEmpty(SignedHash), "SignedHash");
     using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
     {
         RSA.FromXmlString(Key);
         var InputArray = SignedHash.FromBase64();
         var HashArray  = Hash.FromBase64();
         var Result     = RSA.VerifyHash(HashArray, CryptoConfig.MapNameToOID("SHA1"), InputArray);
         RSA.Clear();
         return(Result);
     }
 }
示例#20
0
        public static string RSASign(this string plaintext, RSAParameters rsaKey)
        {
            if (string.IsNullOrEmpty(plaintext))
            {
                throw new ArgumentNullException("plaintext", "Cannot sign an empty string.");
            }

            byte[] plainTextBuffer = UTF8Encoding.UTF8.GetBytes(plaintext);
            var    rsaProvider     = new RSACryptoServiceProvider();

            rsaProvider.ImportParameters(rsaKey);
            byte[] signedHashBuffer = rsaProvider.SignData(plainTextBuffer, new SHA1CryptoServiceProvider());
            rsaProvider.Clear();
            return(Convert.ToBase64String(signedHashBuffer));
        }
 public RSAParameters GenerateKey()
 {
     using (var csp = new RSACryptoServiceProvider(AlgorithmConstants.KeySize))
     {
         try
         {
             return(csp.ExportParameters(true));
         }
         finally
         {
             csp.PersistKeyInCsp = false;
             csp.Clear();
         }
     }
 }
示例#22
0
        static string DecryptData(byte[] bCipherText)
        {
            // Initializing the RSA Cryptography Service Provider (CSP)
            RSACryptoServiceProvider objRSAProvider = new RSACryptoServiceProvider();

            //Set the Load the private key
            objRSAProvider.FromXmlString(strPriKey);

            // Encrypting the data recived
            string strRtnData = objUtf8.GetString(objRSAProvider.Decrypt(bCipherText, false));

            objRSAProvider.Clear();

            return(strRtnData);
        }
 /// <summary>
 /// Verifies a signed hash against the unsigned version
 /// </summary>
 /// <param name="Hash">The unsigned hash (should be 64bit string)</param>
 /// <param name="SignedHash">The signed hash (should be 64bit string)</param>
 /// <param name="Key">The key to use in decryption</param>
 /// <returns>True if it is verified, false otherwise</returns>
 public static bool VerifyHash(string Hash, string SignedHash, string Key)
 {
     Hash.ThrowIfNullOrEmpty("Hash");
     SignedHash.ThrowIfNullOrEmpty("SignedHash");
     Key.ThrowIfNullOrEmpty("Key");
     using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
     {
         RSA.FromXmlString(Key);
         byte[] InputArray = SignedHash.FromBase64();
         byte[] HashArray  = Hash.FromBase64();
         bool   Result     = RSA.VerifyHash(HashArray, CryptoConfig.MapNameToOID("SHA1"), InputArray);
         RSA.Clear();
         return(Result);
     }
 }
示例#24
0
 /// <summary>
 ///     Verifies a signed hash against the unsigned version
 /// </summary>
 /// <param name="hash">The unsigned hash (should be 64bit string)</param>
 /// <param name="signedHash">The signed hash (should be 64bit string)</param>
 /// <param name="key">The key to use in decryption</param>
 /// <returns>True if it is verified, false otherwise</returns>
 public static bool VerifyHash(string hash, string signedHash, string key)
 {
     Guard.NotEmpty(hash, "hash");
     Guard.NotEmpty(signedHash, "signedHash");
     Guard.NotEmpty(key, "key");
     using (var rsa = new RSACryptoServiceProvider())
     {
         rsa.FromXmlString(key);
         byte[] inputArray = signedHash.FromBase64();
         byte[] hashArray  = hash.FromBase64();
         bool   result     = rsa.VerifyHash(hashArray, CryptoConfig.MapNameToOID("SHA1"), inputArray);
         rsa.Clear();
         return(result);
     }
 }
示例#25
0
        /// <summary>
        /// Removes a key container from machine keystore.
        /// </summary>
        /// <param name="containerName">container name to remove.</param>
        public static void Delete(string containerName)
        {
            var cspParams = new CspParameters
            {
                KeyContainerName = containerName,
                Flags            = CspProviderFlags.UseMachineKeyStore | CspProviderFlags.UseExistingKey
            };

            var csp = new RSACryptoServiceProvider(cspParams)
            {
                PersistKeyInCsp = false
            };

            csp.Clear();
        }
        public static void DeleteKey(string containerName)
        {
            var parameters = new CspParameters
            {
                KeyContainerName = containerName
            };

            using (var rsa = new RSACryptoServiceProvider(parameters)
            {
                PersistKeyInCsp = false
            })
            {
                rsa.Clear();
            }
        }
        public static void Test()
        {
            var cspParams = new CspParameters
            {
                KeyContainerName = "Machine Level Key",
                Flags            = CspProviderFlags.UseMachineKeyStore
            };

            var rsa = new RSACryptoServiceProvider(cspParams);

            Console.WriteLine(rsa.ToXmlString(false));

            rsa.PersistKeyInCsp = true;
            rsa.Clear();
        }
示例#28
0
        /// <summary>
                /// 形成并保存公开密钥和私有密钥
                /// </summary>
                /// <param name="p_currentBitStrength">密钥大小</param>
        static void SaveKey(int p_currentBitStrength)
        {
            RSACryptoServiceProvider RSAProvider = new RSACryptoServiceProvider(p_currentBitStrength);
            string publicAndPrivateKeys          = "<BitStrength>" + p_currentBitStrength.ToString() + "</BitStrength>" + RSAProvider.ToXmlString(true);
            string justPublicKey = "<BitStrength>" + p_currentBitStrength.ToString() + "</BitStrength>" + RSAProvider.ToXmlString(false);

            RSAProvider.Clear();
            if (saveFile("Save public static/Private Keys As", "public static/Private Keys Document( *.cyh_primarykey )|*.cyh_primarykey", publicAndPrivateKeys))
            {
                while (!saveFile("Save public static Key As", "public static Key Document( *.cyh_publickey )|*.cyh_publickey", justPublicKey))
                {
                    ;
                }
            }
        }
示例#29
0
        private void DeleteKey(string keyContainerName)
        {
            //コンテナー名の指定
            CspParameters parameters = new CspParameters()
            {
                KeyContainerName = keyContainerName
            };

            //キーコンテナーから鍵を削除
            using (RSACryptoServiceProvider csp = new RSACryptoServiceProvider(parameters))
            {
                csp.PersistKeyInCsp = false;
                csp.Clear();
            }
        }
示例#30
0
        /// <summary>
        ///     Genera la clau que conté el parell de clau privada i pública utilitzant 1024 bytes. Guarda el conjunt de claus en els fitxers private.xml i public.xml.
        /// </summary>
        public static void GenerateKeys()
        {
            // Variables d'aces a fitxers.
            FileStream               fs  = null;
            StreamWriter             sw  = null;
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(1024);

            try
            {
                // Guarda la clau privada
                fs = new FileStream(keysPath + privateKey, FileMode.Create, FileAccess.Write);
                sw = new StreamWriter(fs);
                sw.Write(rsa.ToXmlString(true));
                sw.Flush();
            }
            finally
            {
                if (sw != null)
                {
                    sw.Close();
                }
                if (fs != null)
                {
                    fs.Close();
                }
            }

            try
            {
                // Guarda la clau publica
                fs = new FileStream(keysPath + publicKey, FileMode.Create, FileAccess.Write);
                sw = new StreamWriter(fs);
                sw.Write(rsa.ToXmlString(false));
                sw.Flush();
            }
            finally
            {
                if (sw != null)
                {
                    sw.Close();
                }
                if (fs != null)
                {
                    fs.Close();
                }
            }
            rsa.Clear();
        }
	public static string Encrypt(string toEncrypt)
	{
		RSACryptoServiceProvider CSPRSA = null;
		string result;
		try
		{
			CSPRSA = new RSACryptoServiceProvider();
			CSPRSA.FromXmlString(SAFSecurityKeys.loadKeysFromFile());
			byte[] toEncryptArray = Encoding.UTF8.GetBytes(toEncrypt);
			result = Convert.ToBase64String(CSPRSA.Decrypt(toEncryptArray, false));
		}
		catch
		{
			result = null;
		}
		finally
		{
			if (CSPRSA != null)
			{
				CSPRSA.Clear();
			}
		}
		return result;
	}
示例#32
0
    private static void RSATest()
    {
        var publicPrivateRsa = new RSACryptoServiceProvider
            (
                new CspParameters()
                {
                    KeyContainerName = "PublicPrivateKeys",
                    Flags = CspProviderFlags.UseMachineKeyStore
                    //Flags = CspProviderFlags.UseDefaultKeyContainer
                }
            )
        {
            PersistKeyInCsp = true,
        };

        var publicRsa = new RSACryptoServiceProvider(
                new CspParameters()
                {
                    KeyContainerName = "PublicKey",
                    Flags = CspProviderFlags.UseMachineKeyStore
                    //Flags = CspProviderFlags.UseDefaultKeyContainer
                }
            )
        {
            PersistKeyInCsp = true
        };

        //Export the key.
        publicRsa.ImportParameters(publicPrivateRsa.ExportParameters(false));
        Console.WriteLine(publicRsa.ToXmlString(false));
        Console.WriteLine(publicPrivateRsa.ToXmlString(false));
        //Dispose those two CSPs.
        using (publicRsa)
        {
            publicRsa.Clear();
        }
        using (publicPrivateRsa)
        {
            publicRsa.Clear();
        }

        //Retrieve keys
        publicPrivateRsa = new RSACryptoServiceProvider(
                new CspParameters()
                {
                    KeyContainerName = "PublicPrivateKeys",
                    Flags = CspProviderFlags.UseMachineKeyStore
                    //Flags = CspProviderFlags.UseDefaultKeyContainer
                }
            );

        publicRsa = new RSACryptoServiceProvider(
                new CspParameters()
                {
                    KeyContainerName = "PublicKey",
                    Flags = CspProviderFlags.UseMachineKeyStore
                    //Flags = CspProviderFlags.UseDefaultKeyContainer
                }
            );
        Console.WriteLine(publicRsa.ToXmlString(false));
        Console.WriteLine(publicPrivateRsa.ToXmlString(false));
        using (publicRsa)
        {
            publicRsa.Clear();
        }
        using (publicPrivateRsa)
        {
            publicRsa.Clear();
        }
    }