C# AesManaged.CreateDecryptor方法代码示例

        public static string Decrypt(byte[] encryptedData, string password, byte[] salt = null)
        {
            if (encryptedData == null) throw new ArgumentNullException("encryptedData");
            if (string.IsNullOrEmpty(password)) throw new ArgumentNullException("password");

            if (salt == null) salt = DefaultSalt;
            var aes = new AesManaged();

            string text;

            try
            {
                aes.SetKey(password, salt);
                using (var ms = new MemoryStream(encryptedData))
                {
                    aes.IV = ms.GetIV();
                    var decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
                    using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
                    using (var sr = new StreamReader(cs))
                        text = sr.ReadToEnd();
                }
            }
            finally
            {
                aes.Clear();
            }

            return text;
        }

 public static void DecryptFile(string inputFile, string outputFile, string keyIV)
 {
     byte[] array = new byte[0x20];
     byte[] buffer2 = new byte[0x10];
     HexStringToByteArray(keyIV, array, 0);
     HexStringToByteArray(keyIV, buffer2, 0x40);
     FileStream stream = File.Open(inputFile, System.IO.FileMode.Open);
     FileStream stream2 = File.Open(outputFile, System.IO.FileMode.CreateNew);
     AesManaged managed = new AesManaged {
         Key = array,
         IV = buffer2
     };
     CryptoStream stream3 = new CryptoStream(stream, managed.CreateDecryptor(managed.Key, managed.IV), CryptoStreamMode.Read);
     try
     {
         int num;
         byte[] buffer = new byte[0xa000];
         while ((num = stream3.Read(buffer, 0, buffer.Length)) > 0)
         {
             stream2.Write(buffer, 0, num);
         }
     }
     finally
     {
         stream3.Close();
         stream.Close();
         stream2.Close();
     }
 }

        public static bool DecryptBase64(string cliperText, string key, out string originText)
        {
            byte[] inputData = Convert.FromBase64String(cliperText);

            var aes = new AesManaged()
            {
                Padding = _padding,
                Mode = _cipherMode,
                IV = ORIGIN_IV,
                Key = Encoding.UTF8.GetBytes(key.PadRight(KEY_LENGTH, PADDING_CHAR).Substring(0, KEY_LENGTH))
            };

            var decryptor = aes.CreateDecryptor();
            bool decryptSuccess = true;
            try
            {
                byte[] decryptedData = decryptor.TransformFinalBlock(inputData, 0, inputData.Length);
                originText = Encoding.UTF8.GetString(decryptedData);
            }
            catch
            {
                decryptSuccess = false;
                originText = string.Empty;
            }
            finally
            {
                decryptor.Dispose();
                if (aes != null)
                {
                    aes.Clear();
                }
            }
            return decryptSuccess;
        }

        public string Decrypt(Secret secret)
        {
            string plainText = null;
            using (MemoryStream msDecrypt = new MemoryStream(secret.Data))
            {
                // Create an AesManaged object with the specified key and IV.
                using (Aes aesAlg = new AesManaged())
                {
                    aesAlg.Key = _key;
                    aesAlg.IV = secret.IV;

                    // Create a decrytor to perform the stream transform.
                    ICryptoTransform decryptor = aesAlg.CreateDecryptor();

                    using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (StreamReader srDecrypt = new StreamReader(csDecrypt, Encoding.Unicode))
                        {
                            // Read the decrypted bytes from the decrypting stream
                            // and place them in a string.
                            plainText = srDecrypt.ReadToEnd();
                        }
                    }
                }
            }

            return plainText;
        }

        public static string decrypt(string valueToDecrypt)
        {
            using (Aes aes = new AesManaged())
            {
                aes.Padding = PaddingMode.PKCS7;
                aes.KeySize = 128;          // in bits
                aes.Key = new byte[128 / 8];  // 16 bytes for 128 bit encryption
                aes.IV = new byte[128 / 8];   // AES needs a 16-byte IV

                // Should set Key and IV here.  Good approach: derive them from 
                // a password via Cryptography.Rfc2898DeriveBytes 
                byte[] cipherText = Convert.FromBase64String(valueToDecrypt);
                byte[] plainText = null;
                using (MemoryStream ms = new MemoryStream())
                {
                    using (CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Write))
                    {
                        cs.Write(cipherText, 0, cipherText.Length);
                    }

                    plainText = ms.ToArray();
                }

                return UTF8Encoding.UTF8.GetString(plainText);
            }
        }

        /// <summary>
        /// this algorithm uses the AES algorithm to decrypt the given cipherText
        /// </summary>
        /// <param name="cipherText"></param>
        /// <param name="sharedSecret"></param>
        /// <returns></returns>
        public static string DecryptCipherAES(string cipherText, string sharedSecret)
        {
            if (string.IsNullOrEmpty(cipherText))
            {
                return cipherText;
            }

            AesManaged aesAlg = null;
            string plaintext = null;
            // generate the key from the shared secret and the salt
            Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, salt);

            // Create the streams used for decryption.
            byte[] bytes = Convert.FromBase64String(cipherText);
            using (MemoryStream memoryDecrypt = new MemoryStream(bytes))
            {
                aesAlg = new AesManaged();
                aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
                // Get the initialization vector from the encrypted stream
                aesAlg.IV = ReadByteArray(memoryDecrypt);
                // Create a decrytor to perform the stream transform.
                ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
                using (CryptoStream cryptoDecrypt =
                    new CryptoStream(memoryDecrypt, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader streamDecrypt = new StreamReader(cryptoDecrypt))
                    {
                        plaintext = streamDecrypt.ReadToEnd();
                    }
                }
            }
            return plaintext;
        }

 internal static byte[] Decrypt(byte[] data)
 {
     byte[] output = null;
     using (var aes = new AesManaged())
     {
         using (var decryptor = aes.CreateDecryptor(Configuration.Default.EncryptionKey, Configuration.Default.EncryptionIV))
         {
             using (var dataStream = new MemoryStream())
             {
                 using (var encryptionStream = new CryptoStream(dataStream, decryptor, CryptoStreamMode.Write))
                 {
                     encryptionStream.Write(data, 0, data.Length);
                     encryptionStream.FlushFinalBlock();
                     dataStream.Position = 0;
                     byte[] transformedBytes = new byte[dataStream.Length];
                     dataStream.Read(transformedBytes, 0, transformedBytes.Length);
                     encryptionStream.Close();
                     dataStream.Close();
                     output = transformedBytes;
                 }
             }
         }
     }
     return output;
 }

        //Decrypts the 16 bytes block @cipherText using @key in ECB mode
        public static byte[] AES_DecryptBlock(byte[] cipherText, byte[] key)
        {
            // Check arguments.
            if (cipherText == null || cipherText.Length != 16)
                throw new ArgumentException ("cipherText must be a 16 byte array");
            if (key == null || key.Length <= 0)
                throw new ArgumentNullException ("Key");

            // Declare the string used to hold the decrypted text.
            byte[] output_buffer = new byte[cipherText.Length];

            using (AesManaged aesAlg = new AesManaged()) {
                aesAlg.Mode = CipherMode.ECB;

                aesAlg.BlockSize = 128;
                aesAlg.KeySize = 128;
                aesAlg.Padding = PaddingMode.None;
                aesAlg.Key = key;

                // Create a decrytor to perform the stream transform.
                ICryptoTransform decryptor = aesAlg.CreateDecryptor (aesAlg.Key, aesAlg.IV);
                decryptor.TransformBlock (cipherText, 0, cipherText.Length, output_buffer, 0);
            }

            return output_buffer;
        }

        public byte[] Decrypt(byte[] cipher, byte[] key, byte[] IV)
        {
            System.Collections.Generic.List<byte> bytes = new List<byte>();

            using (AesManaged _aesAlgorithm = new AesManaged())
            {
                _aesAlgorithm.Key = key;
                _aesAlgorithm.IV = IV;

                using (ICryptoTransform decryptor = _aesAlgorithm.CreateDecryptor(_aesAlgorithm.Key, _aesAlgorithm.IV))
                {
                    using (System.IO.MemoryStream str = new System.IO.MemoryStream(cipher))
                    {
                        using (CryptoStream crypto = new CryptoStream(str, decryptor, CryptoStreamMode.Read))
                        {
                            int b = crypto.ReadByte();

                            while (b > -1)
                            {
                                b = crypto.ReadByte();
                                bytes.Add((byte)b);
                            }
                        }
                    }
                    _aesAlgorithm.Clear();
                }
            }

            return bytes.ToArray();
        }

		public string Decryption() {
			try {
				byte[] encrypted=Convert.FromBase64String(textInput.Text);
				MemoryStream ms=null;
				CryptoStream cs=null;
				StreamReader sr=null;
				Aes aes=new AesManaged();
				aes.Key=key;
				aes.IV=new byte[16];
				ICryptoTransform decryptor=aes.CreateDecryptor(aes.Key,aes.IV);
				ms=new MemoryStream(encrypted);
				cs=new CryptoStream(ms,decryptor,CryptoStreamMode.Read);
				sr=new StreamReader(cs);
				string decrypted=sr.ReadToEnd();
				ms.Dispose();
				cs.Dispose();
				sr.Dispose();
				if(aes!=null) {
					aes.Clear();
				}
				return decrypted;
			}
			catch { 
				MessageBox.Show("Text entered was not valid encrypted text.");
				return"";
			}
		}

    public static string Decrypt(this string text, string lKey)
    {
        try
        {
            using (Aes aes = new AesManaged())
            {
                Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(Encoding.UTF8.GetString(IVa, 0, IVa.Length), Encoding.UTF8.GetBytes(lKey));
                aes.Key = deriveBytes.GetBytes(128 / 8);
                aes.IV = aes.Key;

                using (MemoryStream decryptionStream = new MemoryStream())
                {
                    using (CryptoStream decrypt = new CryptoStream(decryptionStream, aes.CreateDecryptor(), CryptoStreamMode.Write))
                    {
                        byte[] encryptedData = Convert.FromBase64String(text);


                        decrypt.Write(encryptedData, 0, encryptedData.Length);
                        decrypt.Flush();
                    }

                    byte[] decryptedData = decryptionStream.ToArray();
                    string decryptedText = Encoding.UTF8.GetString(decryptedData, 0, decryptedData.Length);


                    return decryptedText;
                }
            }
        }
        catch
        {
            return String.Empty;
        }
    }

 public static string Decrypt(string str,byte[] key)
 {
     //No need to check RemotingRole; no call to db.
     if(str==""){
         return "";
     }
     try {
         byte[] encrypted=Convert.FromBase64String(str);
         MemoryStream ms=null;
         CryptoStream cs=null;
         StreamReader sr=null;
         Aes aes=new AesManaged();
         aes.Key=key;
         aes.IV=new byte[16];
         ICryptoTransform decryptor=aes.CreateDecryptor(aes.Key,aes.IV);
         ms=new MemoryStream(encrypted);
         cs=new CryptoStream(ms,decryptor,CryptoStreamMode.Read);
         sr=new StreamReader(cs);
         string decrypted=sr.ReadToEnd();
         ms.Dispose();
         cs.Dispose();
         sr.Dispose();
         if(aes!=null) {
             aes.Clear();
         }
         return decrypted;
     }
     catch {
         //MessageBox.Show("Text entered was not valid encrypted text.");
         return"";
     }
 }

 public static void DecryptFile(string inputFile, string outputFile, string keyIV)
 {
   byte[] array1 = new byte[32];
   byte[] array2 = new byte[16];
   AssetStoreUtils.HexStringToByteArray(keyIV, array1, 0);
   AssetStoreUtils.HexStringToByteArray(keyIV, array2, 64);
   EditorUtility.DisplayProgressBar("Decrypting", "Decrypting package", 0.0f);
   FileStream fileStream1 = File.Open(inputFile, System.IO.FileMode.Open);
   FileStream fileStream2 = File.Open(outputFile, System.IO.FileMode.CreateNew);
   long length = fileStream1.Length;
   long num = 0;
   AesManaged aesManaged = new AesManaged();
   aesManaged.Key = array1;
   aesManaged.IV = array2;
   CryptoStream cryptoStream = new CryptoStream((Stream) fileStream1, aesManaged.CreateDecryptor(aesManaged.Key, aesManaged.IV), CryptoStreamMode.Read);
   try
   {
     byte[] numArray = new byte[40960];
     int count;
     while ((count = cryptoStream.Read(numArray, 0, numArray.Length)) > 0)
     {
       fileStream2.Write(numArray, 0, count);
       num += (long) count;
       if (EditorUtility.DisplayCancelableProgressBar("Decrypting", "Decrypting package", (float) num / (float) length))
         throw new Exception("User cancelled decryption");
     }
   }
   finally
   {
     cryptoStream.Close();
     fileStream1.Close();
     fileStream2.Close();
     EditorUtility.ClearProgressBar();
   }
 }

        public static byte[] Decrypt(byte[] input)
        {
            if (_key == null || _key.Length == 0) throw new Exception("Key can not be empty.");
            if (input == null || input.Length == 0) throw new ArgumentException("Input can not be empty.");

            byte[] data = new byte[0];

            try
            {
                using (var ms = new MemoryStream(input))
                {
                    using (var rd = new AesManaged { Key = _key })
                    {
                        byte[] iv = new byte[IVLENGTH];
                        ms.Read(iv, 0, IVLENGTH); // read first 16 bytes for IV, followed by encrypted message
                        rd.IV = iv;

                        using (var cs = new CryptoStream(ms, rd.CreateDecryptor(), CryptoStreamMode.Read))
                        {
                            byte[] temp = new byte[ms.Length - IVLENGTH + 1];
                            data = new byte[cs.Read(temp, 0, temp.Length)];
                            Buffer.BlockCopy(temp, 0, data, 0, data.Length);
                        }
                    }
                }
            }
            catch
            {
            }
            return data;
        }

		public static void Register()
		{
			using (var manifestResourceStream = typeof(SettingsRegister).Assembly.GetManifestResourceStream("Raven.Studio.Settings.dat"))
			{
				if (manifestResourceStream == null || manifestResourceStream.Length == 0)
				{
					return;
				}

				using (var reader = new BinaryReader(manifestResourceStream))
				using (var aes = new AesManaged())
				{
					aes.Key = reader.ReadBytes(32);
					aes.IV = reader.ReadBytes(16);

					using (var cryptoStream = new CryptoStream(manifestResourceStream, aes.CreateDecryptor(), CryptoStreamMode.Read))
					using (var cryptoReader = new BinaryReader(cryptoStream))
					{
						var licensee = cryptoReader.ReadString();
						var licenseKey = cryptoReader.ReadString();
						ActiproSoftware.Products.ActiproLicenseManager.RegisterLicense(licensee, licenseKey);
					}
				}
			}
		}