加解密总结（附助手类）

编码、加密、哈希的区别：

编码：是信息从一种形式或格式转换成另一种的过程，是可逆的。如：url编码、base64、utf-8

加密：是可逆的，通过特定的秘钥加解密，加解密算法算法有两种：对称加密、非对称加密

哈希：也叫散列，把任意长度的数据转换成固定长度的指纹，过程不可逆

Hash算法：MD5、SHA（1、224、256、384、512）……

无论消息有多长，计算出的摘要长度都是固定的

用途：文件校验、数字签名(防篡改)，建议用SHA系列

HMAC算法：

HMAC是具密钥的哈希算法，以一个密钥和一个消息为输入，生成摘要作为输出，消息 + 密钥 + 算法 ==》 输出摘要包括：HMAC-MD5、HMAC-SHA1、HMAC-SHA256、HMAC-SHA384、

HMAC-SHA512

对称加密算法：DES、AES、IDEA、RC2、RC4、SKIPJACK……

加解密使用相同密钥,这个是对称加密。对称加密相比非对称加密优点是速度快

非对称加密算法：RSA、DSA、DH、ECC、EL GAMAL……

公钥加密数据,然后私钥解密的情况被称为加密解密；

因为公钥加密的数据只有它相对应的私钥可以解开,所以你可以把公钥给人和人,让他加密他想要传送给你的数据,这个数据只有到了有私钥的你这里,才可以解开成有用的数据,其他人就是得到了,也看懂内容

实际应用中,一般都是和对方交换公钥,然后你要发给对方的数据,用他的公钥加密,他得到后用他的私钥解密,他要发给你的数据,用你的公钥加密,你得到后用你的私钥解密,这样最大程度保证了安全性.

缺点速度慢

数字签名：
私钥签名和公钥验证签名；RSA可以用来做签名、验签
如果你用你的私钥对数据进行签名,那这个数据就只有配对的公钥可以解开,有这个私钥的只有你,所以如果配对的公钥解开了数据,就说明这数据是你发的,相反,则不是.这个被称为签名。数字签名的意义就是这些数据与原文数据比对是否修改过。

 

DES助手类：

    /// <summary>
    /// 可逆对称加密  密钥长度8
    /// </summary>
    public class DesEncrypt
    {
        private static string _key = "fanfanfanfanfan";
        private static byte[] _rgbKey = ASCIIEncoding.ASCII.GetBytes(_key.Substring(0, 8));
        private static byte[] _rgbIV = ASCIIEncoding.ASCII.GetBytes(_key.Insert(0, "w").Substring(0, 8));

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

        /// <summary>
        /// DES 解密
        /// </summary>
        /// <param name="encryptText"></param>
        /// <returns>解密后的结果</returns>
        public static string Decrypt(string encryptText)
        {
            DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
            byte[] buffer = Convert.FromBase64String(encryptText);

            using (MemoryStream memStream = new MemoryStream())
            {
                CryptoStream crypStream = new CryptoStream(memStream, dsp.CreateDecryptor(_rgbKey, _rgbIV), CryptoStreamMode.Write);
                crypStream.Write(buffer, 0, buffer.Length);
                crypStream.FlushFinalBlock();
                return ASCIIEncoding.UTF8.GetString(memStream.ToArray());
            }
        }
    }

 

AES助手类：

    /// <summary>
    /// AES加密解密
    /// 密码必须是16位，否则会报错哈
    /// </summary>
    public class AESCryptoHelper
    {
        /// <summary>
        /// APP默认加密Key
        /// </summary>
        public static string Default_AESKey = "1111111111111111";//必须是十六位

        /// <summary>
        ///  AES 加密
        /// </summary>
        /// <param name="plainText">明文</param>
        /// <param name="key">密码必须是16位，否则会报错哈</param>
        /// <returns>密文</returns>
        public static string Encrypt(string plainText, string key)
        {
            string result = null;
            if (string.IsNullOrEmpty(plainText))
            {
                return result;
            }
            byte[] plainTextArray = Encoding.UTF8.GetBytes(plainText);
            using (RijndaelManaged rijndaelManaged = new RijndaelManaged
            {
                Key = Encoding.UTF8.GetBytes(key),
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            })
            {
                using (ICryptoTransform cryptoTransform = rijndaelManaged.CreateEncryptor())
                {
                    byte[] resultArray = cryptoTransform.TransformFinalBlock(plainTextArray, 0, plainTextArray.Length);
                    result = Convert.ToBase64String(resultArray, 0, resultArray.Length);
                    Array.Clear(resultArray, 0, resultArray.Length);
                    resultArray = null;
                }
            }
            Array.Clear(plainTextArray, 0, plainTextArray.Length);
            plainTextArray = null;
            return result;
        }

        /// <summary>
        ///  AES 解密
        /// </summary>
        /// <param name="encryptText">密文</param>
        /// <param name="key">密码必须是16位，否则会报错哈</param>
        /// <returns>明文</returns>
        public static string Decrypt(string encryptText, string key)
        {
            string result = null;
            if (string.IsNullOrEmpty(encryptText))
            {
                return result;
            }
            byte[] encryptTextArray = Convert.FromBase64String(encryptText);
            using (RijndaelManaged rijndaelManaged = new RijndaelManaged
            {
                Key = Encoding.UTF8.GetBytes(key),
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            })
            {
                using (ICryptoTransform cryptoTransform = rijndaelManaged.CreateDecryptor())
                {
                    byte[] resultArray = cryptoTransform.TransformFinalBlock(encryptTextArray, 0, encryptTextArray.Length);
                    result = Encoding.UTF8.GetString(resultArray);
                    Array.Clear(resultArray, 0, resultArray.Length);
                    resultArray = null;
                }
            }
            Array.Clear(encryptTextArray, 0, encryptTextArray.Length);
            encryptTextArray = null;
            return result;
        }

        /// <summary>
        /// AES 加密(URL传参数加密)
        /// </summary>
        /// <param name="plainText">明文</param>
        /// <param name="key"></param>
        /// <returns>加密之后URL编码</returns>
        public static string UrlEncrypt(string plainText, string key)
        {
            string encryptText = Encrypt(plainText, key);
            return HttpUtilityHelper.UrlEncode(encryptText);
        }

        /// <summary>
        /// AES 解密(URL传参数解密)
        /// </summary>
        /// <param name="encodeEncryptText">URL编码之后的密文</param>
        /// <param name="key"></param>
        /// <returns>明文</returns>
        public static string UrlDecrypt(string encodeEncryptText, string key)
        {
            if (!string.IsNullOrEmpty(encodeEncryptText))
            {
                string encodeText = HttpUtilityHelper.UrlDecode(encodeEncryptText);
                return Decrypt(encodeText, key);
            }
            return "";
        }
    }

 

MD5助手类：

    /// <summary>
    /// MD5
    /// </summary>
    public class MD5Encrypt
    {
        #region MD5
        /// <summary>
        /// MD5加密,和动网上的16/32位MD5加密结果相同,
        /// 使用的UTF8编码
        /// </summary>
        /// <param name="source">待加密字串</param>
        /// <param name="length">16或32值之一,其它则采用.net默认MD5加密算法</param>
        /// <returns>加密后的字串</returns>
        public static string Encrypt(string source, int length = 32)//默认参数
        {
            if (string.IsNullOrEmpty(source)) return string.Empty;
            HashAlgorithm provider = CryptoConfig.CreateFromName("MD5") as HashAlgorithm;
            byte[] bytes = Encoding.UTF8.GetBytes(source);//这里需要区别编码的
            byte[] hashValue = provider.ComputeHash(bytes);
            StringBuilder sb = new StringBuilder();
            switch (length)
            {
                case 16://16位密文是32位密文的9到24位字符
                    for (int i = 4; i < 12; i++)
                    {
                        sb.Append(hashValue[i].ToString("x2"));
                    }
                    break;
                case 32:
                    for (int i = 0; i < 16; i++)
                    {
                        sb.Append(hashValue[i].ToString("x2"));
                    }
                    break;
                default:
                    for (int i = 0; i < hashValue.Length; i++)
                    {
                        sb.Append(hashValue[i].ToString("x2"));
                    }
                    break;
            }
            return sb.ToString();
        }
        #endregion MD5

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

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

            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < retVal.Length; i++)
            {
                sb.Append(retVal[i].ToString("x2"));
            }
            return sb.ToString();
        }
        #endregion
    }

 

RSA助手类：

    /// <summary>
    /// RSA
    /// </summary>
    public class RsaEncrypt
    {
        /// <summary>
        /// 生成公钥、私钥
        /// </summary>
        /// <returns>Encrypt   Decrypt</returns>
        public static KeyValuePair<string, string> GetKeyPair()
        {
            RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
            string publicKey = RSA.ToXmlString(false);
            string privateKey = RSA.ToXmlString(true);
            return new KeyValuePair<string, string>(publicKey, privateKey);
        }

        /// <summary>
        /// 加密：内容+加密key
        /// </summary>
        /// <param name="content"></param>
        /// <param name="publicKey">加密key</param>
        /// <returns></returns>
        public static string Encrypt(string content, string publicKey)
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(publicKey);
            UnicodeEncoding ByteConverter = new UnicodeEncoding();
            byte[] DataToEncrypt = ByteConverter.GetBytes(content);
            byte[] resultBytes = rsa.Encrypt(DataToEncrypt, false);
            return Convert.ToBase64String(resultBytes);
        }

        /// <summary>
        /// 解密  内容+解密key
        /// </summary>
        /// <param name="content"></param>
        /// <param name="privateKey">解密key</param>
        /// <returns></returns>
        public static string Decrypt(string content, string privateKey)
        {
            byte[] dataToDecrypt = Convert.FromBase64String(content);
            RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
            RSA.FromXmlString(privateKey);
            byte[] resultBytes = RSA.Decrypt(dataToDecrypt, false);
            UnicodeEncoding ByteConverter = new UnicodeEncoding();
            return ByteConverter.GetString(resultBytes);
        }


        /// <summary>
        /// 可以合并在一起的，，每次产生一组新的密钥
        /// </summary>
        /// <param name="content"></param>
        /// <param name="encryptKey">加密key</param>
        /// <param name="decryptKey">解密key</param>
        /// <returns>加密后结果</returns>
        private static string Encrypt(string content, out string publicKey, out string privateKey)
        {
            RSACryptoServiceProvider rsaProvider = new RSACryptoServiceProvider();
            publicKey = rsaProvider.ToXmlString(false);
            privateKey = rsaProvider.ToXmlString(true);

            UnicodeEncoding ByteConverter = new UnicodeEncoding();
            byte[] DataToEncrypt = ByteConverter.GetBytes(content);
            byte[] resultBytes = rsaProvider.Encrypt(DataToEncrypt, false);
            return Convert.ToBase64String(resultBytes);
        }
    }

 

Core版算法开源库

说明：通过Nuget安装：【NETCore.Encrypt】，版本为【2.0.8】,需要依赖Newtonsoft.json的版本 大于等于：12.0.1，包括的算法有：Base64、MD5、SHA系列、HAMC系列、AES、DES、RSA。

PS：还支持MD5、SHA系列、HMAC系列 对于String类型的扩展，如：var hashed3 = "ypf".MD5(); 大部分算法支持 string和byte[] 两种格式。

{
                    //1. Base64的编码和解码
                    var srcString = "ypf001";
                    var hashed1 = EncryptProvider.Base64Encrypt(srcString);  //default encoding is UTF-8
                    var hashed2 = EncryptProvider.Base64Encrypt(srcString, Encoding.ASCII); //按照ascii进行编码
                    var strValue1 = EncryptProvider.Base64Decrypt(hashed1);   //default encoding is UTF-8
                    var strValue2 = EncryptProvider.Base64Decrypt(hashed2, Encoding.ASCII);   //按照ascii进行解码
                }
                {
                    //2. MD5
                    var srcString = "ypf001";
                    var hashed1 = EncryptProvider.Md5(srcString);  //默认32位
                    var hashed2 = EncryptProvider.Md5(srcString, MD5Length.L16); //16位
                    Console.WriteLine($"ypf001的MD5加密(32位):{hashed1}");
                    Console.WriteLine($"ypf002的MD5加密(64位):{hashed2}");
                    //扩展用法
                    var hashed3 = srcString.MD5();
                }
                {
                    //3. SHA相关
                    var srcString = "ypf001";
                    var hashed1 = EncryptProvider.Sha1(srcString);
                    var hashed2 = EncryptProvider.Sha256(srcString);
                    var hashed3 = EncryptProvider.Sha384(srcString);
                    var hashed4 = EncryptProvider.Sha512(srcString);
                    //扩展用法(如下，其余类似)
                    var extHash = srcString.SHA1();
                }
                {
                    //4. HAMC相关
                    var secretKey = "sflkasfkksfs";
                    var srcString = "ypf001";
                    var hashed1 = EncryptProvider.HMACMD5(srcString, secretKey);
                    var hashed2 = EncryptProvider.HMACSHA1(srcString, secretKey);
                    var hashed3 = EncryptProvider.HMACSHA256(srcString, secretKey);
                    var hashed4 = EncryptProvider.HMACSHA384(srcString, secretKey);
                    var hashed5 = EncryptProvider.HMACSHA512(srcString, secretKey);
                    //扩展用法(如下，其余类似)
                    var extHash = srcString.HMACSHA1(secretKey);
                }
                {
                    //5. AES
                    //利用算法生成key和iv（32位和16位），当然这里可以自己指定并保存好
                    //var aesKey = EncryptProvider.CreateAesKey();
                    //var key = aesKey.Key;
                    //var iv = aesKey.IV;
                    var secretKey = "asdfjketjnddkkaakkuyerbdsbgrtsaw";  //这里的key得32位
                    var iv = "ioeruwoeruo2aqwe";  //加密和解密的过程中可以加上iv矢量，使其安全性更高,这里的iv得16位
                    var srcString = "ypf001";
                    //加密
                    var encrypted1 = EncryptProvider.AESEncrypt(srcString, secretKey);
                    var encrypted2 = EncryptProvider.AESEncrypt(srcString, secretKey, iv);
                    //解密
                    var decrypted1 = EncryptProvider.AESDecrypt(encrypted1, secretKey);
                    var decrypted2 = EncryptProvider.AESDecrypt(encrypted2, secretKey, iv);
                    //PS：这里除了string加密，还可以对byte数组加密
                }
                {
                    //6. DES
                    //利用算法生成key（24位），当然这里可以自己指定并保存好
                    //var desKey = EncryptProvider.CreateDesKey();
                    var secretKey = "asdfjketjnddkkaakkuyerbd";  //这里的key得24位
                    var srcString = "ypf001";
                    //加密
                    var encrypted1 = EncryptProvider.DESEncrypt(srcString, secretKey);
                    //解密
                    var decrypted1 = EncryptProvider.DESDecrypt(encrypted1, secretKey);
                    //PS：这里除了string加密，还可以对byte数组加密
                }
                {
                    //7.RSA
                    //利用算法生成公钥和私钥，然后保存；当然这里可以自己指定并保存好
                    var rsaKey = EncryptProvider.CreateRsaKey();    //default is 2048
                    // var rsaKey = EncryptProvider.CreateRsaKey(RsaSize.R3072);
                    var publicKey = rsaKey.PublicKey;
                    var privateKey = rsaKey.PrivateKey;
                    var srcString = "ypf001";
                    //加密
                    var encrypted1 = EncryptProvider.RSAEncrypt(publicKey, srcString);   //公钥加密
                    //解密
                    var decrypted = EncryptProvider.RSADecrypt(privateKey, encrypted1);  //私钥解密
                }
  public enum RsaSize
    {
        R2048 = 2048,
        R3072 = 3072,
        R4096 = 4096
    }

助手类封装：

/// <summary>
    /// 各种加密解密算法
    /// 依赖程序集【NETCore.Encrypt】
    /// </summary>
    public class SecurityHelp
    {
        /// <summary>
        /// Base64编码
        /// </summary>
        /// <param name="srcString">需要编码的字符串</param>
        /// <returns></returns>
        public static string Base64Encrypt(string srcString)
        {
            return EncryptProvider.Base64Encrypt(srcString);  //default encoding is UTF-8
        }

        /// <summary>
        /// Base64编码
        /// </summary>
        /// <param name="encString">需要解码的字符串</param>
        /// <returns></returns>
        public static string Base64Decrypt(string encString)
        {
            return EncryptProvider.Base64Decrypt(encString);  //default encoding is UTF-8
        }


        /// <summary>
        /// MD5加密
        /// </summary>
        /// <param name="srcString">需要加密的字符串</param>
        /// <param name="num">位数，默认为32位，也可以是16位</param>
        /// <returns></returns>
        public static string Md5(string srcString, int num = 32)
        {
            if (num == 32)
            {
                return EncryptProvider.Md5(srcString);  //默认32位
            }
            else
            {
                return EncryptProvider.Md5(srcString, MD5Length.L16);   //16位
            }
        }


        /// <summary>
        /// SHA系列算法
        /// </summary>
        /// <param name="srcString">需要加密的字符串</param>
        /// <param name="kind">类型</param>
        /// <returns></returns>
        public static string SHA(string srcString, string kind = "Sha512")
        {
            if (kind.Equals("Sha1"))
            {
                return EncryptProvider.Sha1(srcString);
            }
            else if (kind.Equals("Sha256"))
            {
                return EncryptProvider.Sha256(srcString);
            }
            else if (kind.Equals("Sha384"))
            {
                return EncryptProvider.Sha384(srcString);
            }
            else
            {
                return EncryptProvider.Sha512(srcString);
            }
        }

        /// <summary>
        /// HMAC系列算法
        /// </summary>
        /// <param name="srcString">需要加密的字符串</param>
        /// <param name="secretKey">密钥</param>
        /// <param name="kind">类型</param>
        /// <returns></returns>
        public static string HMAC(string srcString, string secretKey, string kind = "HMACSHA512")
        {
            if (kind.Equals("HMACMD5"))
            {
                return EncryptProvider.HMACMD5(srcString, secretKey);
            }
            else if (kind.Equals("HMACSHA1"))
            {
                return EncryptProvider.HMACSHA1(srcString, secretKey);
            }
            else if (kind.Equals("HMACSHA256"))
            {
                return EncryptProvider.HMACSHA256(srcString, secretKey);
            }
            else if (kind.Equals("HMACSHA384"))
            {
                return EncryptProvider.HMACSHA384(srcString, secretKey);
            }
            else
            {
                return EncryptProvider.HMACSHA512(srcString, secretKey);
            }
        }


        /// <summary>
        /// 生成AES算法所需的Key和iv
        /// (当然这里可以自己指定并保存好)
        /// </summary>
        /// <param name="key">加密所需的key</param>
        /// <param name="iv">加密所需的矢量</param>
        public static void CreateAesKey(ref string key, ref string iv)
        {
            //利用算法生成key和iv（32位和16位），当然这里可以自己指定并保存好
            var aesKey = EncryptProvider.CreateAesKey();
            key = aesKey.Key;
            iv = aesKey.IV;
        }

        /// <summary>
        /// AES加密算法
        /// </summary>
        /// <param name="srcString">需要加密的字符串</param>
        /// <param name="secretKey">密钥</param>
        /// <param name="iv">矢量（可以不填）</param>
        /// <returns></returns>
        public static string AESEncrypt(string srcString, string secretKey, string iv = "")
        {
            if (string.IsNullOrEmpty(iv))
            {
                return EncryptProvider.AESEncrypt(srcString, secretKey);    //表示不需要iv矢量的AES加密算法
            }
            else
            {
                return EncryptProvider.AESEncrypt(srcString, secretKey, iv);    //表示需要iv矢量的AES加密算法
            }
        }


        /// <summary>
        /// AES解密算法
        /// </summary>
        /// <param name="encString">需要解密的字符串</param>
        /// <param name="secretKey">密钥</param>
        /// <param name="iv">矢量（可以不填）</param>
        /// <returns></returns>
        public static string AESDecrypt(string encString, string secretKey, string iv = "")
        {
            if (string.IsNullOrEmpty(iv))
            {
                return EncryptProvider.AESDecrypt(encString, secretKey);    //表示不需要iv矢量的AES解密算法
            }
            else
            {
                return EncryptProvider.AESDecrypt(encString, secretKey, iv);    //表示需要iv矢量的AES解密算法
            }
        }


        /// <summary>
        /// DES加密算法
        /// </summary>
        /// <param name="srcString">需要加密的字符串</param>
        /// <param name="secretKey">密钥（这里的密钥需要是24位）</param>
        /// <returns></returns>
        public static string EDSEncrypt(string srcString, string secretKey)
        {
            return EncryptProvider.DESEncrypt(srcString, secretKey);
        }


        /// <summary>
        /// DES解密算法
        /// </summary>
        /// <param name="encString">需要解密的字符串</param>
        /// <param name="secretKey">密钥</param>
        /// <returns></returns>
        public static string DESDecrypt(string encString, string secretKey)
        {
            return EncryptProvider.DESDecrypt(encString, secretKey);
        }



        /// <summary>
        /// 生成RSA算法所需的Key和iv
        /// (当然这里可以自己指定并保存好)
        /// </summary>
        /// <param name="PublicKey">公钥</param>
        /// <param name="PrivateKey">私钥</param>
        public static void CreateRsaKey(ref string PublicKey, ref string PrivateKey)
        {
            //利用算法生成公钥和私钥，然后保存；当然这里可以自己指定并保存好
            var rsaKey = EncryptProvider.CreateRsaKey();    //default is 2048
                                                            // var rsaKey = EncryptProvider.CreateRsaKey(RsaSize.R3072);
            PublicKey = rsaKey.PublicKey;
            PrivateKey = rsaKey.PrivateKey;
        }



        /// <summary>
        /// RSA加密算法
        /// </summary>
        /// <param name="srcString">需要加密的字符串</param>
        /// <param name="publicKey">公钥 加密</param>
        /// <returns></returns>
        public static string RSAEncrypt(string srcString, string publicKey)
        {
            return EncryptProvider.RSAEncrypt(publicKey, srcString);   //公钥加密
        }


        /// <summary>
        /// RSA解密算法
        /// </summary>
        /// <param name="encString">需要解密的字符串</param>
        /// <param name="privateKey">私钥 解密</param>
        /// <returns></returns>
        public static string RSADecrypt(string encString, string privateKey)
        {
            return EncryptProvider.RSADecrypt(privateKey, encString);  //私钥解密
        }



    }



    public enum RsaSize
    {
        R2048 = 2048,
        R3072 = 3072,
        R4096 = 4096
    }

未完待续...