第二十四節：編碼、解碼、加密算法概念及實現（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 : 原創博客請在轉載時保留原文鏈接或在文章開頭加上本人博客地址，否則保留追究法律責任的權利。