C#中常用的加密算法的封装

前言：

一、DES加密

DES加密是对称加密算法，
对称加密算法的优点是速度快，缺点是密钥管理不方便，要求共享密钥

    public class DesEncrypt
    {
        private readonly byte[] _rgbKey;

        private readonly byte[] _rgbIV;

        /// <summary>
        /// Ctor
        /// </summary>
        /// <param name="rgbKey">用于对称算法的密钥</param>
        /// <param name="rgbIV">用于对称算法的初始化向量</param>
        public DesEncrypt(string rgbKey, string rgbIV)
        {
            _rgbKey = Encoding.ASCII.GetBytes(rgbKey.Substring(0, 8));
            _rgbIV = Encoding.ASCII.GetBytes(rgbIV.Insert(0, "w").Substring(0, 8));
        }

        /// <summary>
        /// DES加密
        /// </summary>
        /// <param name="text">需要加密的值</param>
        /// <returns>加密后的结果</returns>
        public string Encrypt(string text)
        {
            var desCrypto = new DESCryptoServiceProvider();
            using (var memoryStream = new MemoryStream())
            {
                var crypStream = new CryptoStream(
                    memoryStream,
                    desCrypto.CreateEncryptor(_rgbKey, _rgbIV),
                    CryptoStreamMode.Write);
                var sWriter = new StreamWriter(crypStream);
                sWriter.Write(text);
                sWriter.Flush();
                crypStream.FlushFinalBlock();
                memoryStream.Flush();
                return Convert.ToBase64String(memoryStream.GetBuffer(), 0, (int)memoryStream.Length);
            }
        }

        /// <summary>
        /// DES解密
        /// </summary>
        /// <param name="encryptText">需要解密的值</param>
        /// <returns>解密后的结果</returns>
        public string Decrypt(string encryptText)
        {
            var desCrypto = new DESCryptoServiceProvider();
            var buffer = Convert.FromBase64String(encryptText);
            using (var memoryStream = new MemoryStream())
            {
                var crypStream = new CryptoStream(
                    memoryStream,
                    desCrypto.CreateDecryptor(_rgbKey, _rgbIV),
                    CryptoStreamMode.Write);
                crypStream.Write(buffer, 0, buffer.Length);
                crypStream.FlushFinalBlock();
                return Encoding.UTF8.GetString(memoryStream.ToArray());
            }
        }
    }

二、MD5加密

MD5加密是不可逆加密
防止被篡改 防止明文存储 防止抵赖，数字签名

    public class MD5Encrypt
    {
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="source">需要加密的字符串</param>
        /// <param name="length">密文长度</param>
        /// <returns>密文</returns>
        public string Encrypt(string source, int length = 32)
        {
            if (string.IsNullOrEmpty(source))
                return string.Empty;

            var provider = CryptoConfig.CreateFromName("MD5") as HashAlgorithm;
            // 这里需要区别编码的
            var sourceBytes = Encoding.UTF8.GetBytes(source);
            var hashValue = provider.ComputeHash(sourceBytes);
            var cipher = new StringBuilder();
            switch (length)
            {
                case 16:
                    for (int i = 4; i < 12; i++)
                    {
                        cipher.Append(hashValue[i].ToString("x2"));
                    }
                    break;
                case 32:
                    for (int i = 0; i < 16; i++)
                    {
                        cipher.Append(hashValue[i].ToString("x2"));
                    }
                    break;
                default:
                    for (int i = 0; i < hashValue.Length; i++)
                    {
                        cipher.Append(hashValue[i].ToString("x2"));
                    }
                    break;
            }

            return cipher.ToString();
        }
	}

也可以对文件进行加密，获得文件的MD5密文
根据MD5密码，可以判断文件是否被篡改，例如百度网盘的急速秒传。

        /// <summary>
        /// 获取文件的MD5摘要
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public string AbstractFile(string fileName)
        {
            using (var file = new FileStream(fileName, FileMode.Open))
            {
                return AbstractFile(file);
            }
        }

        /// <summary>
        /// 根据stream获取文件摘要
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        public static string AbstractFile(Stream stream)
        {
            var md5 = new MD5CryptoServiceProvider();
            var computeHash = md5.ComputeHash(stream);

            var cipher = new StringBuilder();
            for (int i = 0; i < computeHash.Length; i++)
            {
                cipher.Append(computeHash[i].ToString("x2"));
            }
            return cipher.ToString();
        }
    }

三、RSA加密

RSA加密是可逆非对称加密
非对称加密算法的优点是密钥管理很方便，缺点是速度慢。

    /// <summary>
    /// 可逆非对称加密
    /// 非对称加密算法的优点是密钥管理很方便，缺点是速度慢。
    /// </summary>
    public class RsaEncrypt
    {
        /// <summary>
        /// 获取密钥对
        /// </summary>
        /// <returns></returns>
        public KeyValuePair<string, string> GetKeyPair()
        {
            var rsaCryptoService = new RSACryptoServiceProvider();
            var publicKey = rsaCryptoService.ToXmlString(false);
            var privateKey = rsaCryptoService.ToXmlString(true);
            return new KeyValuePair<string, string>(publicKey, privateKey);
        }

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="content">需要加密的内容</param>
        /// <param name="encryptKey">加密的密钥</param>
        /// <returns></returns>
        public string Encrypt(string content, string encryptKey)
        {
            var rsaCryptoService = new RSACryptoServiceProvider();
            rsaCryptoService.FromXmlString(encryptKey);
            byte[] dataToEncrypt = Encoding.UTF8.GetBytes(content);
            byte[] resultBytes = rsaCryptoService.Encrypt(dataToEncrypt, false);
            return Convert.ToBase64String(resultBytes);
        }

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="content">需要解密的内容</param>
        /// <param name="decryptKey">解密的密钥</param>
        /// <returns></returns>
        public string Decrypt(string content, string decryptKey)
        {
            var rsaCryptoService = new RSACryptoServiceProvider();
            rsaCryptoService.FromXmlString(decryptKey);
            byte[] dataToDecrypt = Convert.FromBase64String(content);
            byte[] resultBytes = rsaCryptoService.Decrypt(dataToDecrypt, false);
            return Encoding.UTF8.GetString(resultBytes);
        }
    }