aes加密解密文件，以及计算文件的效验值，附带字符串加密解密

 /// <summary>

        /// 调用加密解密

        /// </summary>

        public static void OperationFile()

        {

            // 私钥  

            RijndaelManaged rijndaelCipher = new RijndaelManaged();

            rijndaelCipher.Mode = CipherMode.CBC;

            rijndaelCipher.Padding = PaddingMode.PKCS7;

            rijndaelCipher.KeySize = 128;

            rijndaelCipher.BlockSize = 128;

            byte[] pwdBytes = Hex_16To2("c0a11a74565a32a127dcab773b92a670");

            byte[] keyBytes = new byte[16];

            int len = pwdBytes.Length;

            if (len > keyBytes.Length) len = keyBytes.Length;

            Array.Copy(pwdBytes, keyBytes, len);

            rijndaelCipher.Key = keyBytes;

            byte[] ivBytes = Hex_16To2("37202a7afef1c83706348c9c6600a34d");

            rijndaelCipher.IV = ivBytes;

            string fp = @"C:\Users\20160405\Desktop\abcd.zip";

            string sPhysicalFilePath = @"C:\Users\20160405\Desktop\com_2017-06-16_full_1.zip";

            string fps = @"C:\Users\20160405\Desktop\in.zip";

            Console.WriteLine("Encrypting begin...");

            encryption(rijndaelCipher, fp, sPhysicalFilePath);

            decryption(rijndaelCipher, sPhysicalFilePath, fps);

           

            Console.ReadLine();
        }

  /// <summary>

        /// 用于文件加密的函数

        /// </summary>

        /// <param name="rij">密码和向量</param>

        /// <param name="readfile">要加密的文件</param>

        /// <param name="writefile">加密后的文件</param>

        public static void encryption(RijndaelManaged rij, string readfile, string writefile)

        {

            try

            {

                byte[] key = rij.Key;

                byte[] iv = rij.IV;

                byte[] buffer = new byte[4096];

                Rijndael crypt = Rijndael.Create();

                ICryptoTransform transform = crypt.CreateEncryptor(key, iv);

                //写进文件

                FileStream fswrite = new FileStream(writefile, FileMode.Create);

                CryptoStream cs = new CryptoStream(fswrite, transform, CryptoStreamMode.Write);

                //打开文件

                FileStream fsread = new FileStream(readfile, FileMode.Open);

                int length;

                //while ((length = fsread.ReadByte()) != -1)

                //cs.WriteByte((byte)length);

                while ((length = fsread.Read(buffer, 0, 4096)) > 0)

                    cs.Write(buffer, 0, (int)length);

                fsread.Close();

                cs.Close();

                fswrite.Close();

                Console.WriteLine("Encrypt Success");

            }

            catch (Exception e)

            {

                Console.WriteLine("Encrypt Faile" + e.ToString());

            }

        }

        /// <summary>

        /// 用于解密的函数

        /// </summary>

        /// <param name="rij">密码和向量</param>

        /// <param name="readfile">要解密的文件</param>

        /// <param name="writefile">解密后的文件</param>

        public static void decryption(RijndaelManaged rij, string readfile, string writefile)

        {

            try

            {

                byte[] key = rij.Key;

                byte[] iv = rij.IV;

                byte[] buffer = new byte[4096];

                Rijndael crypt = Rijndael.Create();

                ICryptoTransform transform = crypt.CreateDecryptor(key, iv);

                //读取加密后的文件

                FileStream fsopen = new FileStream(readfile, FileMode.Open);

                CryptoStream cs = new CryptoStream(fsopen, transform, CryptoStreamMode.Read);

                //把解密后的结果写进文件

                FileStream fswrite = new FileStream(writefile, FileMode.OpenOrCreate);

                int length;

                //while ((length = cs.ReadByte()) != -1)

                //fswrite.WriteByte((byte)length);

                while ((length = cs.Read(buffer, 0, 4096)) > 0)

                    fswrite.Write(buffer, 0, (int)length);

                fswrite.Close();

                cs.Close();

                fsopen.Close();

                Console.WriteLine("Decrypt Success");

            }

            catch (Exception e)

            {

                Console.WriteLine("Decrypt Failed" + e.ToString());

            }

        }

 /// <summary>

        /// 计算效验值

        /// </summary>

        /// <param name="fileName">文件路径</param>

        /// <param name="algName">类别md5、sha1</param>

        /// <returns></returns>

        protected static string GetMD5HashFromFile(string fileName,string algName)

        {

            if (!File.Exists(fileName))

                return string.Empty;

            System.IO.FileStream fs = new System.IO.FileStream(fileName, System.IO.FileMode.Open, System.IO.FileAccess.Read);

            byte[] hashBytes = HashData(fs, algName);

            fs.Close();

            return ByteArrayToHexString(hashBytes);

        }

            /// <summary>

        /// 计算哈希值

        /// </summary>

        /// <param name="stream">要计算哈希值的 Stream</param>

        /// <param name="algName">算法:sha1,md5</param>

        /// <returns>哈希值字节数组</returns>

        private static byte[] HashData(Stream stream, string algName)

        {

            HashAlgorithm algorithm;

            if (algName == null)

            {

                throw new ArgumentNullException("algName 不能为 null");

            }

            if (string.Compare(algName, "sha1", true) == 0)

            {

                algorithm = SHA1.Create();

            }

            else

            {

                if (string.Compare(algName, "md5", true) != 0)

                {

                    throw new Exception("algName 只能使用 sha1 或 md5");

                }

                algorithm = MD5.Create();

            }

            return algorithm.ComputeHash(stream);

        }

 /// <summary>

        /// AES解密

        /// </summary>

        /// <param name="text">解密字符串</param>

        /// <param name="password">密钥</param>

        /// <param name="iv">偏移量</param>

        /// <returns></returns>

        public static string AESDecrypt(string text, string password, string iv)

        {

            RijndaelManaged rijndaelCipher = new RijndaelManaged();

            rijndaelCipher.Mode = CipherMode.CBC;

            rijndaelCipher.Padding = PaddingMode.PKCS7;

            rijndaelCipher.KeySize = 128;

            rijndaelCipher.BlockSize = 128;

            byte[] encryptedData = Convert.FromBase64String(text);

            byte[] pwdBytes = Hex_16To2(password);

            byte[] keyBytes = new byte[16];

            int len = pwdBytes.Length;

            if (len > keyBytes.Length) len = keyBytes.Length;

            Array.Copy(pwdBytes, keyBytes, len);

            rijndaelCipher.Key = keyBytes;

            byte[] ivBytes = Hex_16To2(iv);

            rijndaelCipher.IV = ivBytes;

            ICryptoTransform transform = rijndaelCipher.CreateDecryptor();

            byte[] plainText = transform.TransformFinalBlock(encryptedData, 0, encryptedData.Length);

            return Encoding.UTF8.GetString(plainText);

        }

        /// <summary>

        /// AES加密

        /// </summary>

        /// <param name="text">加密字符</param>

        /// <param name="password">密钥</param>

        /// <param name="iv">偏移量</param>

        /// <returns></returns>

        public static string AESEncrypt(string text, string password, string iv)

        {

            RijndaelManaged rijndaelCipher = new RijndaelManaged();

            rijndaelCipher.Mode = CipherMode.CBC;

            rijndaelCipher.Padding = PaddingMode.PKCS7;

            rijndaelCipher.KeySize = 128;

            rijndaelCipher.BlockSize = 128;

            byte[] pwdBytes = Hex_16To2(password);

            byte[] keyBytes = new byte[16];

            int len = pwdBytes.Length;

            if (len > keyBytes.Length) len = keyBytes.Length;

            Array.Copy(pwdBytes, keyBytes, len);

            rijndaelCipher.Key = keyBytes;

            byte[] ivBytes = Hex_16To2(iv);

            rijndaelCipher.IV = ivBytes;

            ICryptoTransform transform = rijndaelCipher.CreateEncryptor();

            byte[] plainText = Encoding.UTF8.GetBytes(text);

            byte[] cipherBytes = transform.TransformFinalBlock(plainText, 0, plainText.Length);

            return Convert.ToBase64String(cipherBytes);

        }

        /// <summary>     

        /// 16进制转2进制     

        /// </summary>     

        public static byte[] Hex_16To2(string hexString)

        {

            if ((hexString.Length % 2) != 0)

            {

                hexString += " ";

            }

            byte[] returnBytes = new byte[hexString.Length / 2];

            for (Int32 i = 0; i < returnBytes.Length; i++)

            {

                returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);

            }

            return returnBytes;

        }