public static string Decrypt(this string stringToDecrypt, string key)
        {
            if (string.IsNullOrEmpty(stringToDecrypt))
            {
                throw new ArgumentException("An empty string value cannot be encrypted.");
            }

            if (string.IsNullOrEmpty(key))
            {
                throw new ArgumentException("Cannot decrypt using an empty key. Please supply a decryption key.");
            }

            //var cspp = new CspParameters { KeyContainerName = key };
            var cspp = new CspParameters { KeyContainerName = key, Flags = CspProviderFlags.UseMachineKeyStore };

            var rsa = new RSACryptoServiceProvider(cspp) { PersistKeyInCsp = true };

            var decryptArray = stringToDecrypt.Split(new[] { "-" }, StringSplitOptions.None);
            var decryptByteArray = Array.ConvertAll(decryptArray, (s => Convert.ToByte(byte.Parse(s, System.Globalization.NumberStyles.HexNumber))));


            byte[] bytes = rsa.Decrypt(decryptByteArray, true);

            string result = System.Text.Encoding.UTF8.GetString(bytes);

            return result;
        }

	// Create an instance using the specified CSP
	public CapiContext (CspParameters csp) 
	{
		providerHandle = IntPtr.Zero;
		if (csp == null) {
			// default parameters
			cspParams = new CspParameters ();
		}
		else {
			// keep of copy of the parameters
			cspParams = new CspParameters (csp.ProviderType, csp.ProviderName, csp.KeyContainerName);
			cspParams.KeyNumber = csp.KeyNumber;
			cspParams.Flags = csp.Flags;
		}
		
		// do not show user interface (CRYPT_SILENT) -  if UI is required then the function fails.
		uint flags = CryptoAPI.CRYPT_SILENT;
		if ((cspParams.Flags & CspProviderFlags.UseMachineKeyStore) == CspProviderFlags.UseMachineKeyStore) {
			flags |= CryptoAPI.CRYPT_MACHINE_KEYSET;
		}

		lastResult = CryptoAPI.CryptAcquireContextA (ref providerHandle, cspParams.KeyContainerName,
			cspParams.ProviderName, cspParams.ProviderType, flags);
		if (!lastResult) {
			// key container may not exist
			flags |= CryptoAPI.CRYPT_NEWKEYSET;
			lastResult = CryptoAPI.CryptAcquireContextA (ref providerHandle, cspParams.KeyContainerName,
				cspParams.ProviderName, cspParams.ProviderType, flags);
		}
	}

 public PasswordDeriveBytes (byte[] password, byte[] salt, String hashName, int iterations, CspParameters cspParams) {
     this.IterationCount = iterations;
     this.Salt = salt;
     this.HashName = hashName;
     _password = password;
     _cspParams = cspParams;
 }

        static void Main(string[] args)
        {
            var cspParam = new CspParameters { Flags = CspProviderFlags.UseMachineKeyStore | CspProviderFlags.UseExistingKey,
            KeyContainerName = "FreeStreamingKeyStore"};
            var keyStore = new RsaKeyStore(cspParam);

                Peer peer1 = new Peer(38412, true, keyStore);
            peer1.ApplicationJoined += new CloudRegistrationEventHandler(OnApplicationJoined);
            peer1.ApplicationDetected += new CloudRegistrationEventHandler(OnApplicationDetected);
            peer1.ApplicationLeaved += new CloudRegistrationEventHandler(OnApplicationLeaved);
            peer1.UserMessageReceived += new UserMessageReceivedEventHandler(OnUserMessageReceived);
            peer1.RegisterInCloud();

                //Peer peer2 = new Peer(10001, true, keyStore);
                //peer2.ApplicationJoined += new CloudRegistrationEventHandler(OnApplication2Joined);
                //peer2.ApplicationDetected += new CloudRegistrationEventHandler(OnApplication2Detected);
                //peer2.ApplicationLeaved += new CloudRegistrationEventHandler(OnApplication2Leaved);
                //peer2.UserMessageReceived += new UserMessageReceivedEventHandler(OnUserMessage2Received);
                //peer2.RegisterInCloud();

            Thread.Sleep(1000);

            //peer1.SendData(new byte[100]);
            //peer1.SendData(new byte[200]);
            //peer1.SendData(new byte[300]);
            //peer1.SendData(new byte[100000]);

            Thread.Sleep(1000);
            peer1.Dispose();
            //peer2.Dispose();

            Console.WriteLine("..");
            Console.ReadLine();
        }

        public void AssignNewKey()
        {
            using (var rsa = new RSACryptoServiceProvider(2048))
            {
                rsa.PersistKeyInCsp = false;
                //in memory
                publicKey = rsa.ExportParameters(false);
                privateKey = rsa.ExportParameters(true);
                return;

                //to file
                File.WriteAllText(@"C:\git\CryptographyDemo\CryptographyDemo\bin\Debug\public.txt", rsa.ToXmlString(false));
                File.WriteAllText(@"C:\git\CryptographyDemo\CryptographyDemo\bin\Debug\private.txt", rsa.ToXmlString(true));
            }

            //To key container, stored for windows user
            const int providerRsaFull = 1;
            CspParameters cspParams = new CspParameters(providerRsaFull);
            cspParams.KeyContainerName = "TomsContainer";
            cspParams.Flags = CspProviderFlags.UseMachineKeyStore;
            cspParams.ProviderName = "Microsoft Strong Cryptographic Provider";
            var rsa2 = new RSACryptoServiceProvider(cspParams);
            rsa2.PersistKeyInCsp = true;

            // SHOULD THEN DELETE KEY
        }

        /// <summary>
        /// Generate keys into specified files.
        /// </summary>
        /// <param name="publicKeyFileName">Name of the file that will contain public key</param>
        /// <param name="privateKeyFileName">Name of the file that will contain private key</param>
        public void GenerateKeys(out byte[] publicKey, out byte[] privateKey)
        {
            // Variables
            CspParameters cspParams = null;
            RSACryptoServiceProvider rsaProvider = null;

            try
            {
                // Create a new key pair on target CSP
                cspParams = new CspParameters()
                {
                    ProviderType = 1,                          // PROV_RSA_FULL
                    Flags = CspProviderFlags.UseArchivableKey, // can be exported
                    KeyNumber = (int)KeyNumber.Exchange        // can be safely stored and exchanged
                };

                rsaProvider = new RSACryptoServiceProvider(cspParams);
                rsaProvider.PersistKeyInCsp = false;

                // Export public key only
                publicKey = rsaProvider.ExportCspBlob(false);
                privateKey = rsaProvider.ExportCspBlob(true);
            }
            catch (Exception ex)
            {
                Debug.Fail(string.Format("Exception occured while generating keys: {0}", ex.Message));
                publicKey = null;
                privateKey = null;
            }
            finally
            {
                if (rsaProvider != null) rsaProvider.PersistKeyInCsp = false;
            }
        }

        public void ProcessRequest(HttpContext context)
        {
            context.Response.ContentType = "text/plain";
            CspParameters csp = new CspParameters();
            csp.Flags = CspProviderFlags.UseMachineKeyStore;

            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(csp);
            RSAParameters para = rsa.ExportParameters(true);
            StringBuilder model = new StringBuilder();
            for (int i = 0; i < para.Modulus.Length; i++)
            {
                model.Append(para.Modulus[i].ToString("X2"));
            }

            StringBuilder exponent = new StringBuilder();
            for (int i = 0; i <para.Exponent.Length; i ++)
            {
                exponent.Append(para.Exponent[i].ToString("X2"));
            }

            XElement list = new XElement("list");
            XElement pri = new XElement("private", new XAttribute("key", rsa.ToXmlString(true)));
            XElement pub = new XElement("public", new XAttribute("model", model.ToString()),new XAttribute("exponent",exponent.ToString()));
            list.Add(pri);
            list.Add(pub);
            context.Response.Write(list.ToString());
        }

 public CryptKeys()
 {
     Container = "ShareXmod";
     cp = new CspParameters();
     cp.KeyContainerName = Container;
     GenerateKey();
 }

        /// <summary>
        ///     Public constructor.
        /// </summary>
        public Encryptor()
        {
            string pass = Esapi.SecurityConfiguration.MasterPassword;
            byte[] salt = Esapi.SecurityConfiguration.MasterSalt;

            try
            {
                // Set up encryption and decryption
                using (SymmetricAlgorithm symmetricAlgorithm = SymmetricAlgorithm.Create(this.encryptAlgorithm))
                {
                    using (Rfc2898DeriveBytes rfc2898 = new Rfc2898DeriveBytes(pass, salt))
                    {
                        this.secretKey = rfc2898.GetBytes(symmetricAlgorithm.KeySize / 8);
                    }
                    // TODO: Hardcoded value 13 is the code for DSA
                    this.asymmetricKeyPair = new CspParameters(13);

                    // The asymmetric key will be stored in the key container using the name ESAPI.
                    this.asymmetricKeyPair.KeyContainerName = "ESAPI";
                }
            }
            catch (Exception e)
            {
                throw new EncryptionException(EM.Encryptor_EncryptionFailure, EM.Encryptor_EncryptorCreateFailed, e);
            }
        }

        public static void RSADeleteKeyInCSP(string ContainerName)
        {
            try
            {
                // Create a new instance of CspParameters.  Pass
                // 13 to specify a DSA container or 1 to specify
                // an RSA container.  The default is 1.
                CspParameters cspParams = new CspParameters();

                // Specify the container name using the passed variable.
                cspParams.KeyContainerName = ContainerName;

                //Create a new instance of RSACryptoServiceProvider.
                //Pass the CspParameters class to use the
                //key in the container.
                RSACryptoServiceProvider RSAalg = new RSACryptoServiceProvider(cspParams);

                //Delete the key entry in the container.
                RSAalg.PersistKeyInCsp = false;

                //Call Clear to release resources and delete the key from the container.
                RSAalg.Clear();

                //Indicate that the key was persisted.
                Console.WriteLine("The RSA key was deleted from the container, \"{0}\".", ContainerName);
            }
            catch (CryptographicException e)
            {
                Console.WriteLine(e.Message);

            }
        }

        public static byte[] DecryptRSA(byte[] data, byte[] key)
        {
            var csp     = new CspParameters();
            csp.Flags   = CspProviderFlags.UseMachineKeyStore;

            using (var rsa  = new RSACryptoServiceProvider(_dwSize, csp))
            using (var ms   = new MemoryStream())
            {
                //Create seed, create RSA blob, replace logic
                rsa.ImportCspBlob(key);

                for (int i = 0; i < data.Length; i += _chunkSize)
                {
                    int amount = Math.Min(_chunkSize, data.Length - i);
                    byte[] buffer = new byte[amount];

                    Buffer.BlockCopy(data, i, buffer, 0, amount);

                    byte[] decrypted = rsa.Decrypt(buffer, false);
                    ms.Write(decrypted, 0, decrypted.Length);
                }

                return ms.ToArray();
            }
        }

        public void Sigcreate(String name)
        {
            try
            {

                CspParameters cspParams = new CspParameters();
                cspParams.KeyContainerName = "XML_DSIG_RSA_KEY";

                RSACryptoServiceProvider rsaKey = new RSACryptoServiceProvider(cspParams);

                XmlDocument xmlDoc = new XmlDocument();

                xmlDoc.PreserveWhitespace = true;
                xmlDoc.Load(name);

                SignXml(xmlDoc, rsaKey);

                xmlDoc.Save(name);

            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }

		private void Common (int dwKeySize, CspParameters p) 
		{
			// Microsoft RSA CSP can do between 384 and 16384 bits keypair
			LegalKeySizesValue = new KeySizes [1];
			LegalKeySizesValue [0] = new KeySizes (384, 16384, 8);
			base.KeySize = dwKeySize;

			rsa = new RSAManaged (KeySize);
			rsa.KeyGenerated += new RSAManaged.KeyGeneratedEventHandler (OnKeyGenerated);

			persistKey = (p != null);
			if (p == null) {
				p = new CspParameters (PROV_RSA_FULL);
#if NET_1_1
				if (useMachineKeyStore)
					p.Flags |= CspProviderFlags.UseMachineKeyStore;
#endif
				store = new KeyPairPersistence (p);
				// no need to load - it cannot exists
			}
			else {
				store = new KeyPairPersistence (p);
				bool exists = store.Load ();
				bool required = (p.Flags & CspProviderFlags.UseExistingKey) != 0;

				if (required && !exists)
					throw new CryptographicException ("Keyset does not exist");

				if (store.KeyValue != null) {
					persisted = true;
					this.FromXmlString (store.KeyValue);
				}
			}
		}

 static Encryption()
 {
     CspParameters CSPParam = new CspParameters();
     CSPParam.Flags = CspProviderFlags.UseMachineKeyStore;
     RsaProvider = new RSACryptoServiceProvider(CSPParam);
     RsaProvider.FromXmlString(xmlKey);
 }

 private static RSACryptoServiceProvider CreateRSACryptoServiceProvider()
 {
     CspParameters RSAParams = new CspParameters();
     RSAParams.Flags = CspProviderFlags.UseMachineKeyStore;
     RSACryptoServiceProvider publicKey = new RSACryptoServiceProvider(RSAParams);
     return publicKey;
 }

        public string SignN3Rsa(string data)
        {
            var cspParams = new CspParameters {KeyContainerName = "XML_DSIG_RSA_KEY"};
            var key = new RSACryptoServiceProvider(cspParams);
            var cspBlob = key.ExportCspBlob(false);
            var base64Blob = Convert.ToBase64String(cspBlob);

            var rsaFormatter = new RSAPKCS1SignatureFormatter(key);
            rsaFormatter.SetHashAlgorithm("MD5");

            var hash = Md5Helper.GetMd5Hash(data);
            var base64Hash = Convert.ToBase64String(hash);
            var sign = rsaFormatter.CreateSignature(hash);
            var base64Sign = Convert.ToBase64String(sign);

            var signData = new SignData
                           {
                               data = data,
                               public_key = base64Blob,
                               hash = base64Hash,
                               sign = base64Sign
                           };

            return new SerializationHelper<SignData>().Serialize(signData);
        }

        //
        // Returns the private key referenced by a store certificate. Note that despite the return type being declared "CspParameters",
        // the key can actually be a CNG key. To distinguish, examine the ProviderType property. If it is 0, this key is a CNG key with
        // the various properties of CspParameters being "repurposed" into storing CNG info. 
        // 
        // This is a behavior this method inherits directly from the Crypt32 CRYPT_KEY_PROV_INFO semantics.
        //
        // It would have been nice not to let this ugliness escape out of this helper method. But X509Certificate2.ToString() calls this 
        // method too so we cannot just change it without breaking its output.
        // 
        private CspParameters GetPrivateKey()
        {
            int cbData = 0;
            if (!Interop.crypt32.CertGetCertificateContextProperty(_certContext, CertContextPropId.CERT_KEY_PROV_INFO_PROP_ID, null, ref cbData))
            {
                int dwErrorCode = Marshal.GetLastWin32Error();
                if (dwErrorCode == ErrorCode.CRYPT_E_NOT_FOUND)
                    return null;
                throw new CryptographicException(dwErrorCode);
            }

            unsafe
            {
                byte[] privateKey = new byte[cbData];
                fixed (byte* pPrivateKey = privateKey)
                {
                    if (!Interop.crypt32.CertGetCertificateContextProperty(_certContext, CertContextPropId.CERT_KEY_PROV_INFO_PROP_ID, privateKey, ref cbData))
                        throw new CryptographicException(Marshal.GetLastWin32Error());
                    CRYPT_KEY_PROV_INFO* pKeyProvInfo = (CRYPT_KEY_PROV_INFO*)pPrivateKey;

                    CspParameters cspParameters = new CspParameters();
                    cspParameters.ProviderName = Marshal.PtrToStringUni((IntPtr)(pKeyProvInfo->pwszProvName));
                    cspParameters.KeyContainerName = Marshal.PtrToStringUni((IntPtr)(pKeyProvInfo->pwszContainerName));
                    cspParameters.ProviderType = pKeyProvInfo->dwProvType;
                    cspParameters.KeyNumber = pKeyProvInfo->dwKeySpec;
                    cspParameters.Flags = (CspProviderFlags)((pKeyProvInfo->dwFlags & CryptAcquireContextFlags.CRYPT_MACHINE_KEYSET) == CryptAcquireContextFlags.CRYPT_MACHINE_KEYSET ? CspProviderFlags.UseMachineKeyStore : 0);
                    return cspParameters;
                }
            }
        }

 public CryptKeys()
 {
     Container = Application.ProductName;
     cp = new CspParameters();
     cp.KeyContainerName = Container;
     GenerateKey();
 }

		private void GrabarClaveCompleta(CspParameters cp, RSACryptoServiceProvider rsa)
		{
			StreamWriter s = new StreamWriter(cp.KeyContainerName + ".pubpriv.rsa");
			rsa.PersistKeyInCsp = false;
			s.WriteLine(rsa.ToXmlString(true));
			s.Close();
		}

        void sign()
        {
            try
            {
                // Create a new CspParameters object to specify 
                // a key container.
                CspParameters cspParams = new CspParameters();
                cspParams.KeyContainerName = "XML_DSIG_RSA_KEY";

                // Create a new RSA signing key and save it in the container. 
                RSACryptoServiceProvider rsaKey = new RSACryptoServiceProvider(cspParams);

                // Create a new XML document.
                XmlDocument xmlDoc = new XmlDocument();

                // Load an XML file into the XmlDocument object.
                xmlDoc.PreserveWhitespace = true;
                xmlDoc.Load("test.xml");

                // Sign the XML document. 
                SignXml(xmlDoc, rsaKey);

                Console.WriteLine("XML file signed.");

                // Save the document.
                xmlDoc.Save("test.xml");
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }