C# 加密解密大全

using System;
using System.Text;
using System.Globalization;
using System.Security.Cryptography;
using System.IO;
namespace LiDong.Command
{
    public class Secret
    {
        /// <summary>
        /// 创建对称算法的默认实例
        /// </summary>
        private SymmetricAlgorithm mobjCryptoService;
        /// <summary>
        /// DES加密默认密钥向量
        /// </summary>
        private byte[] _desIV = { 0xEF, 0x34, 0xAB, 0x34, 0x90, 0xAB, 0x34, 0xEF };
        /// <summary>
        /// DES加密Key
        /// </summary>
        private string _desKey;
        /// <summary>
        /// 对称加密KEY
        /// </summary>
        private string _symmetricKey;

        #region 构造函数
        /// <summary>
        /// 默认构造函数
        /// </summary>
        public Secret()
        {
            mobjCryptoService = new RijndaelManaged();
            _desKey = "&@%^$cDl";
            _symmetricKey = "Guz(%&hj7x89H$yuBI0456FtmaT5&fvHUFCy76*h%(HilJ$lhj!y6&(*jkP87jH7";
        }

        /// <summary>
        /// 默认构造函数
        /// </summary>
        public Secret(string desKey, string symmetricKey)
        {
            mobjCryptoService = new RijndaelManaged();
            _desKey = desKey;
            _symmetricKey = symmetricKey;
        }
        #endregion

        #region MD5加密
        /// <summary>
        /// 给一个字符串进行32位的MD5加密
        /// 注:不可逆
        /// </summary>
        /// <param name="content">待加密字符串</param>
        /// <returns>加密后的字符串</returns>
        public static string MD5Encrypt32(string content)
        {
            MD5 md5 = new MD5CryptoServiceProvider();
            byte[] result = md5.ComputeHash(System.Text.Encoding.Default.GetBytes(content));
            return System.Text.Encoding.Default.GetString(result);

        }

        /// <summary>
        /// 给一个字符串进行16位的MD5加密
        /// 注:不可逆
        /// </summary>
        /// <param name="content">待加密字符串</param>
        /// <returns>加密后的字符串</returns>
        public static string MD5Encrypt16(string content)
        {
            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
            string t2 = BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes(content)), 4, 8);
            t2 = t2.Replace("-", "");
            return t2;
        }
        #endregion

        #region DES加密/解密
        /// <summary>
        /// 给一个字符串进行DES加密
        /// </summary>
        /// <param name="content">输入字符串</param>
        /// <param name="key">密钥</param>
        /// <returns>加密后字符串</returns>
        public string DESEncrypt(string content)
        {
            byte[] data = Encoding.UTF8.GetBytes(content);
            DESCryptoServiceProvider des = new DESCryptoServiceProvider();
            des.Key = ASCIIEncoding.ASCII.GetBytes(_desKey);
            des.IV = _desIV;
            ICryptoTransform desencrypt = des.CreateEncryptor();
            byte[] result = desencrypt.TransformFinalBlock(data, 0, data.Length);
            return BitConverter.ToString(result);
        }

        /// <summary>
        /// 给一个字符串进行DES加密
        /// </summary>
        /// <param name="content">已加密的字符串</param>
        /// <param name="key">密钥</param>
        /// <returns>加密后字符串</returns>
        public string DESDecrypt(string content)
        {
            string[] sInput = content.Split("-".ToCharArray());
            byte[] data = new byte[sInput.Length];
            for (int i = 0; i < sInput.Length; i++)
            {
                data[i] = byte.Parse(sInput[i], NumberStyles.HexNumber);
            }
            DESCryptoServiceProvider des = new DESCryptoServiceProvider();
            des.Key = ASCIIEncoding.ASCII.GetBytes(_desKey);
            des.IV = _desIV;
            ICryptoTransform desencrypt = des.CreateDecryptor();
            byte[] result = desencrypt.TransformFinalBlock(data, 0, data.Length);
            return Encoding.UTF8.GetString(result);
        }
        #endregion

        #region Base64加密/解密
        /// <summary>
        /// 给一个字符串进行Base64加密
        /// </summary>
        /// <param name="encoding">编码类型</param>
        /// <param name="content">待加密字符串</param>
        /// <returns>base64算法加密的字符串</returns>
        public string Base64Encrypt(Encoding encoding, string content)
        {
            string encode = "";
            //将一组字符编码为一个字节序列. 
            byte[] bytes = encoding.GetBytes(content);
            try
            {
                //将8位无符号整数数组的子集转换为其等效的,以64为基的数字编码的字符串形式. 
                encode = Convert.ToBase64String(bytes);
            }
            catch
            {
                encode = content;
            }
            return encode;
        }

        /// <summary> 
        /// 将字符串使用base64算法解密 
        /// </summary> 
        /// <param name="encoding">编码类型</param> 
        /// <param name="content">已用base64算法加密的字符串</param> 
        /// <returns>解密后的字符串</returns> 
        public string Base64Decrypt(Encoding encoding, string content)
        {
            string decode = "";
            //将2进制编码转换为8位无符号整数数组. 
            byte[] bytes = Convert.FromBase64String(content);
            try
            {
                //将指定字节数组中的一个字节序列解码为一个字符串。
                decode = encoding.GetString(bytes);
            }
            catch
            {
                decode = content;
            }
            return decode;
        }
        #endregion

        #region 对称加密/解密

        /// <summary>   
        /// 获得密钥   
        /// </summary>   
        /// <returns>密钥</returns>   
        private byte[] GetLegalKey()
        {
            string sTemp = _symmetricKey;
            mobjCryptoService.GenerateKey();
            byte[] bytTemp = mobjCryptoService.Key;
            int KeyLength = bytTemp.Length;
            if (sTemp.Length > KeyLength)
                sTemp = sTemp.Substring(0, KeyLength);
            else if (sTemp.Length < KeyLength)
                sTemp = sTemp.PadRight(KeyLength, ' ');
            return ASCIIEncoding.ASCII.GetBytes(sTemp);
        }
        /// <summary>   
        /// 获得初始向量IV   
        /// </summary>   
        /// <returns>初试向量IV</returns>   
        private byte[] GetLegalIV()
        {
            string sTemp = "E4ghj*Ghg7!rNIfb&95GUY86GfghUb#er57HBh(u%g6HJ($jhWk7&!hg4ui%$hjk";
            mobjCryptoService.GenerateIV();
            byte[] bytTemp = mobjCryptoService.IV;
            int IVLength = bytTemp.Length;
            if (sTemp.Length > IVLength)
                sTemp = sTemp.Substring(0, IVLength);
            else if (sTemp.Length < IVLength)
                sTemp = sTemp.PadRight(IVLength, ' ');
            return ASCIIEncoding.ASCII.GetBytes(sTemp);
        }
        /// <summary>   
        /// 对称加密方法   
        /// </summary>   
        /// <param name="content">待加密的字符串串</param>   
        /// <returns>已加密的字符串</returns>   
        public string SymmetricEncrypt(string content)
        {
            byte[] bytIn = UTF8Encoding.UTF8.GetBytes(content);
            MemoryStream ms = new MemoryStream();
            mobjCryptoService.Key = GetLegalKey();
            mobjCryptoService.IV = GetLegalIV();
            ICryptoTransform encrypto = mobjCryptoService.CreateEncryptor();
            CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);
            cs.Write(bytIn, 0, bytIn.Length);
            cs.FlushFinalBlock();
            ms.Close();
            byte[] bytOut = ms.ToArray();
            return Convert.ToBase64String(bytOut);
        }
        /// <summary>   
        /// 对称解密方法   
        /// </summary>   
        /// <param name="content">已加密的字符串</param>   
        /// <returns>解密后的字符串</returns>   
        public string SymmetricDecrypt(string content)
        {
            byte[] bytIn = Convert.FromBase64String(content);
            MemoryStream ms = new MemoryStream(bytIn, 0, bytIn.Length);
            mobjCryptoService.Key = GetLegalKey();
            mobjCryptoService.IV = GetLegalIV();
            ICryptoTransform encrypto = mobjCryptoService.CreateDecryptor();
            CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);
            StreamReader sr = new StreamReader(cs);
            return sr.ReadToEnd();
        }

        #endregion

        #region 文件加密/解密
        //
        /// <summary>
        /// DES加密文件
        /// </summary>
        /// <param name="inFile">待加密文件完整路径</param>
        /// <param name="outFile">加密后文件完整路径</param>
        private void FileEncrypt(String inFile, String outFile)
        {
            //创建文件流来处理输入和输出文件
            FileStream fin = new FileStream(inFile, FileMode.Open, FileAccess.Read);
            FileStream fout = new FileStream(outFile, FileMode.OpenOrCreate, FileAccess.Write);
            fout.SetLength(0);

            //创建变量帮助阅读和写字。
            byte[] bin = new byte[100]; //中间的加密存储。
            long rdlen = 0;             //写入的总字节数。
            long totlen = fin.Length;   //输入文件的总长度。
            int len;                    //字节数写在一个时间。

            DES des = new DESCryptoServiceProvider();
            des.Key = ASCIIEncoding.ASCII.GetBytes(_desKey);
            des.IV = _desIV;
            CryptoStream encStream = new CryptoStream(fout, des.CreateEncryptor(), CryptoStreamMode.Write);

            //从输入文件中读取，然后加密和写入输出文件。
            while (rdlen < totlen)
            {
                len = fin.Read(bin, 0, 100);
                encStream.Write(bin, 0, len);
                rdlen = rdlen + len;
            }

            encStream.Close();
            fout.Close();
            fin.Close();
        }

        /// <summary>
        /// DES解密文件
        /// </summary>
        /// <param name="inFile">已加密文件完整路径</param>
        /// <param name="outFile">解密后文件完整路径</param>
        private void FileDecrypt(String inFile, String outFile)
        {
            //创建文件流来处理输入和输出文件
            FileStream fin = new FileStream(inFile, FileMode.Open, FileAccess.Read);
            FileStream fout = new FileStream(outFile, FileMode.OpenOrCreate, FileAccess.Write);
            fout.SetLength(0);

            //创建变量帮助阅读和写字。
            byte[] bin = new byte[100]; //中间的加密存储。
            long rdlen = 0;             //写入的总字节数。
            long totlen = fin.Length;   //输入文件的总长度。
            int len;                    //字节数写在一个时间。

            DES des = new DESCryptoServiceProvider();
            des.Key = ASCIIEncoding.ASCII.GetBytes(_desKey);
            des.IV = _desIV;
            CryptoStream encStream = new CryptoStream(fout, des.CreateEncryptor(), CryptoStreamMode.Write);

            //从输入文件中读取，然后加密和写入输出文件。
            while (rdlen < totlen)
            {
                len = fin.Read(bin, 0, 100);
                encStream.Write(bin, 0, len);
                rdlen = rdlen + len;
            }

            encStream.Close();
            fout.Close();
            fin.Close();
        }
        #endregion
    }
}