C# 常用的加密算法

懒得看，直接拿来用的。
https://download.csdn.net/download/weixin_44347839/88618785?spm=1001.2014.3001.5501
先上总结：MD5、DES和SHA-1存在安全性问题，不推荐在安全敏感的应用中使用。AES和HMAC-SHA256提供较高的安全性，适用于数据加密和认证。RSA是一种强大的非对称加密算法，适用于加密和数字签名。Base64是一种数据编码方式，用于将二进制数据转换为可打印字符。

一、Sha1

SHA-1（Secure Hash Algorithm 1）是一种哈希函数，用于将任意长度的数据转换为固定长度的哈希值。
特点：固定长度输出，较快的计算速度。
缺点：安全性问题，容易受到碰撞攻击。

/// <summary>
        /// SHA1 加密 
        /// </summary>
        /// <param name="str">需要加密字符串</param>
        /// <param name="encode">指定加密编码</param>
        /// <param name="upperOrLower">大小写格式（大写：X2;小写:x2）默认小写</param> 
        public static string SHA1Encrypt(string str, Encoding encode, string upperOrLower = "x2")
        {
    
    
            try
            {
    
    
                var buffer = encode.GetBytes(str);//用指定编码转为bytes数组
                var data = SHA1.Create().ComputeHash(buffer);
                var sb = new StringBuilder();
                foreach (var t in data)
                {
    
    
                    sb.Append(t.ToString(upperOrLower));
                }

                return sb.ToString();
            }
            catch (Exception ex)
            {
    
    
                return "SHA1加密出错：" + ex.Message;
            }
        }

        /// <summary>
        /// SHA256加密
        /// </summary>
        /// <param name="strIN">要加密的string字符串</param>
        /// <returns>SHA256加密之后的密文</returns>
        public static string SHA256Encrypt(string strIN)
        {
    
    
            byte[] tmpByte;
            SHA256 sha256 = new SHA256Managed();
            tmpByte = sha256.ComputeHash(GetKeyByteArray(strIN));

            StringBuilder rst = new StringBuilder();
            for (int i = 0; i < tmpByte.Length; i++)
            {
    
    
                rst.Append(tmpByte[i].ToString("x2"));
            }
            sha256.Clear();
            return rst.ToString();
        }

        /// <summary>
        /// 获取要加密的string字符串字节数组
        /// </summary>
        /// <param name="strKey">待加密字符串</param>
        /// <returns>加密数组</returns>
        private static byte[] GetKeyByteArray(string strKey)
        {
    
    
            UTF8Encoding Asc = new UTF8Encoding();
            int tmpStrLen = strKey.Length;
            byte[] tmpByte = new byte[tmpStrLen - 1];
            tmpByte = Asc.GetBytes(strKey);
            return tmpByte;
        }

二、HMAC-SHA256

HMAC-SHA256（是一种基于SHA-256哈希函数的消息认证码算法。它使用一个密钥对消息进行哈希计算，以提供消息完整性和认证。
HMAC-SHA256是一种消息认证码算法，使用SHA-256哈希函数和密钥进行计算。
特点：提供消息完整性和认证，防止篡改和伪造消息。
缺点：HMAC-SHA256需要更多的计算和额外的密钥管理。会导致一些性能消耗。

        /// <summary>
        /// HmacSHA256 Base64算法,返回的结果始终是32位
        /// </summary>
        /// <param name="str">待加密的明文字符串</param>
        /// <param name="secret">密钥</param>
        /// <param name="encode">编码</param>
        /// <returns>HmacSHA256算法加密之后的密文</returns>
        public static string HmacSHA256(string str, string secret, Encoding encode)
        {
    
    
            byte[] keyByte = encode.GetBytes(secret);
            byte[] messageBytes = encode.GetBytes(str);
            using (var hmacsha256 = new HMACSHA256(keyByte))
            {
    
    
                byte[] hashmessage = hmacsha256.ComputeHash(messageBytes);
                return Convert.ToBase64String(hashmessage);
            }
        }

三、Base

Base加密是一种简单的编码方式，用于将二进制数据转换为可打印字符。它并不是一种加密算法，而是一种编码方案。
特点：：Base加密是可逆的，大多数编程语言都提供了Base加密和解密的函数或库。加密后在文本环境中进行传输和显示，不会出现乱码问题。
缺点：安全性较低：Base加密不提供任何加密安全性，会导致数据体积的增加。

        /// <summary>
        /// base16编码
        /// </summary>
        /// <param name="str"></param>
        /// <param name="autoCode"></param>
        /// <returns></returns>
        public static string Base16Encrypt(string str, string[] autoCode = null)
        {
    
    
            string innerStr = string.Empty;
            StringBuilder strEn = new StringBuilder();
            if (autoCode == null || autoCode.Length < 16)
                autoCode = new string[] {
    
     "a", "2", "B", "g", "E", "5", "f", "6", "C", "8", "o", "9", "Z", "p", "k", "M" };
            System.Collections.ArrayList arr = new System.Collections.ArrayList(System.Text.Encoding.Default.GetBytes(str));
            for (int i = 0; i < arr.Count; i++)
            {
    
    
                byte data = (byte)arr[i];
                int v1 = data >> 4;
                strEn.Append(autoCode[v1]);
                int v2 = ((data & 0x0f) << 4) >> 4;
                strEn.Append(autoCode[v2]);
            }
            return strEn.ToString();
        }

        /// <summary>
        /// base64编码
        /// </summary>
        /// <param name="str"></param>
        /// <param name="encode"></param>
        /// <returns></returns>
        public static string Base64Encode(string str, Encoding encode)
        {
    
    
            var bytes = encode.GetBytes(str);
            return Convert.ToBase64String(bytes);
        }

        /// <summary>
        /// base64解码
        /// </summary>
        /// <param name="str"></param>
        /// <param name="encode"></param>
        /// <returns></returns>
        public static string Base64Decode(string str, Encoding encode)
        {
    
    
            var bytes = Convert.FromBase64String(str);
            return encode.GetString(bytes);
        }

四、MD5

MD5信息摘要算法，可以产生出一个128位（16字节）的散列值哈希值，用于确保信息传输完整一致。

        /// <summary>
        /// 计算字符串的MD5值
        /// </summary>
        public static string md5Encrypt(string str, Encoding encode)
        {
    
    
            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
            byte[] data = encode.GetBytes(str);
            byte[] md5Data = md5.ComputeHash(data, 0, data.Length);
            md5.Clear();

            string destString = "";
            for (int i = 0; i < md5Data.Length; i++)
            {
    
    
                destString += System.Convert.ToString(md5Data[i], 16).PadLeft(2, '0');
            }
            destString = destString.PadLeft(32, '0');
            return destString;
        }

        /// <summary>
        /// 计算文件的MD5值
        /// </summary>
        public static string md5fileEncrypt(string file)
        {
    
    
            try
            {
    
    
                FileStream fs = new FileStream(file, FileMode.Open);
                System.Security.Cryptography.MD5 md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
                byte[] retVal = md5.ComputeHash(fs);
                fs.Close();

                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < retVal.Length; i++)
                {
    
    
                    sb.Append(retVal[i].ToString("x2"));
                }
                return sb.ToString();
            }
            catch (Exception ex)
            {
    
    
                throw new Exception("md5file() fail, error:" + ex.Message);
            }
        }

五、DES

DES是一种对称加密算法，广泛应用于数据加密和保护领域。
特点：对称加密，分组加密，密钥长度较短。
缺点：密钥长度短，安全性相对较低，已经不推荐使用。

   /// <summary>
        /// 8位的加密秘钥
        /// </summary>
        private static string KEY = "CSharpKE";

        /// <summary>
        /// 8位以上的默认向量
        /// </summary>
        private static string IV = "CSharpIV";

        /// <summary>
        /// DES加密操作
        /// </summary>
        /// <param name="normalTxt"></param>
        /// <returns></returns>
        public static string DESEncrypt(string normalTxt)
        {
    
    
            byte[] _KEY = System.Text.ASCIIEncoding.ASCII.GetBytes(KEY);
            byte[] _IV = System.Text.ASCIIEncoding.ASCII.GetBytes(IV);

            DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
            int i = cryptoProvider.KeySize;
            MemoryStream ms = new MemoryStream();
            CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateEncryptor(_KEY, _IV), CryptoStreamMode.Write);

            StreamWriter sw = new StreamWriter(cst);
            sw.Write(normalTxt);
            sw.Flush();
            cst.FlushFinalBlock();
            sw.Flush();

            string strRet = Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
            return strRet;
        }

        /// <summary>
        /// DES解密操作
        /// </summary>
        /// <param name="securityTxt">加密字符串</param>
        /// <returns></returns>
        public static string DESDecrypt(string securityTxt)//解密  
        {
    
    
            byte[] _KEY = System.Text.ASCIIEncoding.ASCII.GetBytes(KEY);
            byte[] _IV = System.Text.ASCIIEncoding.ASCII.GetBytes(IV);
            byte[] byEnc;
            try
            {
    
    
                securityTxt.Replace("_%_", "/");
                securityTxt.Replace("-%-", "#");
                byEnc = Convert.FromBase64String(securityTxt);
            }
            catch
            {
    
    
                return null;
            }
            DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
            MemoryStream ms = new MemoryStream(byEnc);
            CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateDecryptor(_KEY, _IV), CryptoStreamMode.Read);
            StreamReader sr = new StreamReader(cst);
            return sr.ReadToEnd();
        }

六、RSA

RSA是一种非对称加密算法，使用公钥加密、私钥解密。
特点：非对称加密，安全性较高，可用于加密和数字签名。
缺点：计算速度较慢，适用于加密较小的数据。

  private const int RsaKeySize = 2048;
        private const string publicKeyFileName = "RSA.Pub";
        private const string privateKeyFileName = "RSA.Private";

        /// <summary>
        ///在给定路径中生成XML格式的私钥和公钥。
        /// </summary>
        public void GenerateKeys(string path)
        {
    
    
            using (var rsa = new RSACryptoServiceProvider(RsaKeySize))
            {
    
    
                try
                {
    
    
                    // 获取私钥和公钥。
                    var publicKey = rsa.ToXmlString(false);
                    var privateKey = rsa.ToXmlString(true);

                    // 保存到磁盘
                    File.WriteAllText(Path.Combine(path, publicKeyFileName), publicKey);
                    File.WriteAllText(Path.Combine(path, privateKeyFileName), privateKey);

                }
                finally
                {
    
    
                    rsa.PersistKeyInCsp = false;
                }
            }
        }

        /// <summary>
        /// 用给定路径的RSA公钥文件加密纯文本。
        /// </summary>
        /// <param name="plainText">要加密的文本</param>
        /// <param name="pathToPublicKey">用于加密的公钥路径.</param>
        /// <returns>表示加密数据的64位编码字符串.</returns>
        public string RSAEncrypt(string plainText, string pathToPublicKey)
        {
    
    
            using (var rsa = new RSACryptoServiceProvider(RsaKeySize))
            {
    
    
                try
                {
    
    
                    //加载公钥
                    var publicXmlKey = File.ReadAllText(pathToPublicKey);
                    rsa.FromXmlString(publicXmlKey);

                    var bytesToEncrypt = System.Text.Encoding.Unicode.GetBytes(plainText);

                    var bytesEncrypted = rsa.Encrypt(bytesToEncrypt, false);

                    return Convert.ToBase64String(bytesEncrypted);
                }
                finally
                {
    
    
                    rsa.PersistKeyInCsp = false;
                }
            }
        }

        /// <summary>
        /// 给定路径的RSA私钥文件解密 加密文本
        /// </summary>
        /// <param name="encryptedText">加密的密文</param>
        /// <param name="pathToPrivateKey">用于加密的私钥路径.</param>
        /// <returns>未加密数据的字符串</returns>
        public string RSADecrypt(string encryptedText, string pathToPrivateKey)
        {
    
    
            using (var rsa = new RSACryptoServiceProvider(RsaKeySize))
            {
    
    
                try
                {
    
    
                    var privateXmlKey = File.ReadAllText(pathToPrivateKey);
                    rsa.FromXmlString(privateXmlKey);

                    var bytesEncrypted = Convert.FromBase64String(encryptedText);

                    var bytesPlainText = rsa.Decrypt(bytesEncrypted, false);

                    return System.Text.Encoding.Unicode.GetString(bytesPlainText);
                }
                finally
                {
    
    
                    rsa.PersistKeyInCsp = false;
                }
            }
        }

七、AES

AES是一种对称加密算法，使用相同的密钥进行加密和解密。
特点：对称加密，安全性强，计算速度较快。
缺点：无明显缺点，被广泛应用于数据加密。

 /// <summary>
        /// AES 算法加密
        /// </summary>
        /// <param name="content">明文</param>
        /// <param name="Key">密钥</param>
        /// <returns>加密后的密文</returns>
        public static string AESEncrypt(string encryptStr, string key = "12345678987654321234567890987654")
        {
    
    
            byte[] keyArray = Encoding.UTF8.GetBytes(key);
            byte[] toEncryptArray = Encoding.UTF8.GetBytes(encryptStr);
            RijndaelManaged rDel = new RijndaelManaged
            {
    
    
                Key = keyArray,
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            };
            ICryptoTransform cTransform = rDel.CreateEncryptor();
            byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
            return Convert.ToBase64String(resultArray, 0, resultArray.Length);
        }

        public static string AESDecrypt(string decryptStr, string key = "12345678987654321234567890987654")
        {
    
    
            byte[] keyArray = Encoding.UTF8.GetBytes(key);
            byte[] toEncryptArray = Convert.FromBase64String(decryptStr);
            RijndaelManaged rDel = new RijndaelManaged
            {
    
    
                Key = keyArray,
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            };
            ICryptoTransform cTransform = rDel.CreateDecryptor();
            byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
            return Encoding.UTF8.GetString(resultArray);
        }