第二十四节：编码、解码、加密算法概念及实现（Base64、MD5、SHA、HMAC、DES、AES、RSA）

一. 编码解码

1.编码

　　将信息从一种格式(人能识别)转换成另一种形式(计算机能识别)的过程。 常见的编码：Base64

2.解码

　　计算机能识别的形式转换成人能识别的形式。

3.字符集和字符编码

(1).字符集（Charset）：是一个系统支持的所有抽象字符的集合。字符是各种文字和符号的总称，包括各国家文字、标点符号、图形符号、数字等。

(2).字符编码（Character Encoding）：是一套法则，使用该法则能够对自然语言的字符的一个集合（如字母表或音节表），与其他东西的一个集合（如号码或电脉冲）进行配对。 即在符号集合与数字系统之间建立对应关系，它是信息处理的一项基本技术。通常人们用符号集合（一般情况下就是文字）来表达信息。而以计算机为基础的信息处理系统则是 利用元件（硬件）不同状态的组合来存储和处理信息的。元件不同状态的组合能代表数字系统的数字，因此字符编码就是将符号转换为计算机可以接受的数字系统的数，称为数字代码。

常见的字符集：ASCII、GB2312、BIG5、GB18030 和 Unicode(UTF-32/ UTF-16/ UTF-8) 字符集

详见参考：https://www.cnblogs.com/skynet/archive/2011/05/03/2035105.html

                string pwd = "123456";
                byte[] bytes1 = Encoding.Default.GetBytes(pwd);
                string baseString = Convert.ToBase64String(bytes1);
                Console.WriteLine($"编码：{baseString}");
                byte[] bytes2 = Convert.FromBase64String(baseString);
                var str = Encoding.Default.GetString(bytes2);
                Console.WriteLine($"解码：{str}");    

二. 各种算法及其实现(微软的实现)

下面的各种算法微软都有实现，都是基于 【System.Security.Cryptography.Algorithms】这个程序集实现的。

文档地址：https://docs.microsoft.com/zh-cn/dotnet/api/system.security.cryptography?view=netcore-3.1

源码地址：https://github.com/dotnet/corefx/tree/master/src/System.Security.Cryptography.Algorithms

1.哈希(散列摘要)算法

　　Hash，一般翻译做散列，音译为哈希，是把任意长度的输入通过散列算法变换成固定长度的输出，该输出就是散列值。 简单的说就是一种将任意长度的消息压缩到某一

固定长度的消息摘要的算法或者函数，有时也叫摘要算法。

　　主流的 Hash 算法有：MD4、MD5 和 SHA系列，其中SHA家族有5个算法：SHA-1，SHA-224，SHA-256，SHA-384 和 SHA-512，其中后 4 者总称 SHA2 算法。 使用的程序集：【System.Security.Cryptography.Algorithms】（微软），代码见下，和后面开源库的实现相比多了些 -,可以利用replace去掉

用途：文件校验、数字签名 和 鉴权协议，建议以后用SHA系列.

PS.

哈希函数的理解：https://www.jianshu.com/p/bba9b61b80e7

哈希一致性算法理解：https://www.jianshu.com/p/6f13156573f4 （了解）

            //MD5
            {
                var srcString = "ypf001";
                //（和后面开源库的实现相比多了些 -,可以利用replace去掉）
                var md5 = MD5.Create();
                byte[] result = md5.ComputeHash(Encoding.UTF8.GetBytes(srcString));
                string md5String= BitConverter.ToString(result).Replace("-",""); 
            }
            //SHA系列
            {
                var srcString = "ypf001";
                //SHA-256，SHA-384 和 SHA-512 用法类似（和后面开源库的实现相比多了些-,可以利用replace去掉）
                var sha1 = SHA1.Create();
                byte[] result = sha1.ComputeHash(Encoding.UTF8.GetBytes(srcString));
                string sha1HashString = BitConverter.ToString(result).Replace("-", "");
            }

2. HMAC算法

　　HMAC是具密钥的哈希算法，以一个密钥和一个消息为输入，生成摘要作为输出，消息 + 密钥 + 算法 ==》 输出摘要包括：HMAC-MD5、HMAC-SHA1、HMAC-SHA256、HMAC-SHA384、HMAC-SHA512,使用的程序集：【System.Security.Cryptography.Algorithms】（微软），代码见下，和后面开源库的实现相比多了些 -,可以利用replace去掉。

            //HMAC相关
            {
                var secretKey = "sflkasfkksfs";
                var srcString = "ypf001";
                //HMAC-SHA384、HMAC-SHA512的用法类似 （和后面开源库的实现相比多了些-，可以利用replace去掉）
                HMACSHA1 hmacsha1 = new HMACSHA1(Encoding.UTF8.GetBytes(secretKey));
                HMACSHA256 hmacsha2 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
                byte[] bytes1 = hmacsha1.ComputeHash(Encoding.UTF8.GetBytes(srcString));
                byte[] bytes2 = hmacsha2.ComputeHash(Encoding.UTF8.GetBytes(srcString));
                string hmacSha1String = BitConverter.ToString(bytes1).Replace("-", ""); 
                string hmacSha2String = BitConverter.ToString(bytes2).Replace("-", "");
            }

3.对称加密算法

　　采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密加密，也称为单密钥加密。 常见的对称加解密算法：AES、DES、RC2、TripleDES 和 Rijndael 算法。

  public class DesEncrypt
    {
        //8位长度
        private static byte[] rgbKey = ASCIIEncoding.ASCII.GetBytes("ioeruwoe");  //密钥（转为byte数组）
        private static byte[] rgbIV = ASCIIEncoding.ASCII.GetBytes("ypf00001");   //矢量（配合密钥更加安全）

        #region 01-DES加密
        /// <summary>
        /// DES 加密
        /// </summary>
        /// <param name="strValue">需要加密的字符串</param>
        /// <returns></returns>
        public static string Encrypt(string strValue)
        {
            DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
            using (MemoryStream memStream = new MemoryStream())
            {
                CryptoStream crypStream = new CryptoStream(memStream, dsp.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
                byte[] buffer = Encoding.Default.GetBytes(strValue);
                crypStream.Write(buffer, 0, buffer.Length);
                crypStream.FlushFinalBlock();
                memStream.Flush();
                return Convert.ToBase64String(memStream.GetBuffer(), 0, (int)memStream.Length);
            }
        }
        #endregion

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

            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());
            }
        }
        #endregion
    }

            //DES算法
            {
                //具体实现详见：DesEncrypt 
                string msg1 = "mr1";
                //密钥写在DesEncrypt类中了
                string result1 = DesEncrypt.Encrypt(msg1);
                string result2 = DesEncrypt.Decrypt(result1);
            }

4.非对称加密算法

　　非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。

　　非对称加密算法实现机密信息交换的基本过程是：甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开；得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方；甲方再用自己保存的另一把专用密钥对加密后的信息进行解密。

常见的非对称加解密算法：DSA 和 RSA

    public class RsaEncrypt
    {
        #region 01-生成公钥和私钥
        /// <summary>
        /// 生成公钥和私钥
        /// </summary>
        /// <returns></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);
        }
        #endregion

        #region 02-加密(传入内容和公钥)
        /// <summary>
        /// 加密：内容+公钥,事先需要生成公钥和私钥
        /// </summary>
        /// <param name="content">加密内容</param>
        /// <param name="publicKey">公钥</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);
        }
        #endregion

        #region 03-加密(并返回公钥和私钥)
        /// <summary>
        /// 加密(并返回公钥和私钥),在该方法中生成了公钥和私钥，并返回
        /// </summary>
        /// <param name="content">加密内容</param>
        /// <param name="publicKey">返还公钥</param>
        /// <param name="privateKey">返回密钥</param>
        /// <returns>加密后结果</returns>
        public 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);
        }
        #endregion

        #region 04-解密(内容+私钥)
        /// <summary>
        /// 解密-内容+私钥
        /// </summary>
        /// <param name="content"></param>
        /// <param name="privateKey"></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);
        }
        #endregion


    }

           //RSA算法
            {
                //具体实现详见 RsaEncrypt
                //方式一：先生成公钥和私钥,然后加密和解密
                //KeyValuePair是一个键值对, myKey.Key 代表的公钥；myKey.Value 代表的私钥
                KeyValuePair<string, string> myKey = RsaEncrypt.GetKeyPair();
                string msg1 = "mr1";
                //加密
                string result1 = RsaEncrypt.Encrypt(msg1, myKey.Key);
                //解密
                string result2 = RsaEncrypt.Decrypt(result1, myKey.Value);
            }

 三. 各种算法开源库(NETCore.Encrypt)

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

开源地址：https://github.com/myloveCc/NETCore.Encrypt

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
    }

!

• 作       者 : Yaopengfei(姚鹏飞)
• 博客地址 : http://www.cnblogs.com/yaopengfei/
• 声     明1 : 本人才疏学浅，用郭德纲的话说“我是一个小学生”，如有错误，欢迎讨论，请勿谩骂^_^。
• 声     明2 : 原创博客请在转载时保留原文链接或在文章开头加上本人博客地址，否则保留追究法律责任的权利。