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

2021-01-16 04:15

阅读：739

标签：状态调用 woe memory 链接 SHA256 事先键值对第三方库

原文:第二十四节：编码、解码、加密算法概念及实现（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

1                 string pwd = "123456";
2                 byte[] bytes1 = Encoding.Default.GetBytes(pwd);
3                 string baseString = Convert.ToBase64String(bytes1);
4                 Console.WriteLine($"编码：{baseString}");
5                 byte[] bytes2 = Convert.FromBase64String(baseString);
6                 var str = Encoding.Default.GetString(bytes2);
7                 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 （了解）

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

2. HMAC算法

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

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

3.对称加密算法

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

 1   public class DesEncrypt
 2     {
 3         //8位长度
 4         private static byte[] rgbKey = ASCIIEncoding.ASCII.GetBytes("ioeruwoe");  //密钥（转为byte数组）
 5         private static byte[] rgbIV = ASCIIEncoding.ASCII.GetBytes("ypf00001");   //矢量（配合密钥更加安全）
 6 
 7         #region 01-DES加密
 8         /// 
 9         /// DES 加密
10         /// 
11         /// 需要加密的字符串
12         /// 
13         public static string Encrypt(string strValue)
14         {
15             DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
16             using (MemoryStream memStream = new MemoryStream())
17             {
18                 CryptoStream crypStream = new CryptoStream(memStream, dsp.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
19                 byte[] buffer = Encoding.Default.GetBytes(strValue);
20                 crypStream.Write(buffer, 0, buffer.Length);
21                 crypStream.FlushFinalBlock();
22                 memStream.Flush();
23                 return Convert.ToBase64String(memStream.GetBuffer(), 0, (int)memStream.Length);
24             }
25         }
26         #endregion
27 
28         #region 02-DES解密
29         /// 
30         /// DES解密
31         /// 
32         /// 加密后的结果
33         /// 
34         public static string Decrypt(string EncValue)
35         {
36             DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
37             byte[] buffer = Convert.FromBase64String(EncValue);
38 
39             using (MemoryStream memStream = new MemoryStream())
40             {
41                 CryptoStream crypStream = new CryptoStream(memStream, dsp.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
42                 crypStream.Write(buffer, 0, buffer.Length);
43                 crypStream.FlushFinalBlock();
44                 return ASCIIEncoding.UTF8.GetString(memStream.ToArray());
45             }
46         }
47         #endregion
48     }

View Code

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

4.非对称加密算法

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

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

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

 1     public class RsaEncrypt
 2     {
 3         #region 01-生成公钥和私钥
 4         /// 
 5         /// 生成公钥和私钥
 6         /// 
 7         /// 
 8         public static KeyValuePairstring, string> GetKeyPair()
 9         {
10             RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
11             string publicKey = RSA.ToXmlString(false);
12             string privateKey = RSA.ToXmlString(true);
13             return new KeyValuePairstring, string>(publicKey, privateKey);
14         }
15         #endregion
16 
17         #region 02-加密(传入内容和公钥)
18         /// 
19         /// 加密：内容+公钥,事先需要生成公钥和私钥
20         /// 
21         /// 加密内容
22         /// 公钥
23         /// 
24         public static string Encrypt(string content, string publicKey)
25         {
26             RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
27             rsa.FromXmlString(publicKey);
28             UnicodeEncoding ByteConverter = new UnicodeEncoding();
29             byte[] DataToEncrypt = ByteConverter.GetBytes(content);
30             byte[] resultBytes = rsa.Encrypt(DataToEncrypt, false);
31             return Convert.ToBase64String(resultBytes);
32         }
33         #endregion
34 
35         #region 03-加密(并返回公钥和私钥)
36         /// 
37         /// 加密(并返回公钥和私钥),在该方法中生成了公钥和私钥，并返回
38         /// 
39         /// 加密内容
40         /// 返还公钥
41         /// 返回密钥
42         /// 加密后结果
43         public static string Encrypt(string content, out string publicKey, out string privateKey)
44         {
45             RSACryptoServiceProvider rsaProvider = new RSACryptoServiceProvider();
46             publicKey = rsaProvider.ToXmlString(false);
47             privateKey = rsaProvider.ToXmlString(true);
48             UnicodeEncoding ByteConverter = new UnicodeEncoding();
49             byte[] DataToEncrypt = ByteConverter.GetBytes(content);
50             byte[] resultBytes = rsaProvider.Encrypt(DataToEncrypt, false);
51             return Convert.ToBase64String(resultBytes);
52         }
53         #endregion
54 
55         #region 04-解密(内容+私钥)
56         /// 
57         /// 解密-内容+私钥
58         /// 
59         /// 
60         /// 
61         /// 
62         public static string Decrypt(string content, string privateKey)
63         {
64             byte[] dataToDecrypt = Convert.FromBase64String(content);
65             RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
66             RSA.FromXmlString(privateKey);
67             byte[] resultBytes = RSA.Decrypt(dataToDecrypt, false);
68             UnicodeEncoding ByteConverter = new UnicodeEncoding();
69             return ByteConverter.GetString(resultBytes);
70         }
71         #endregion
72 
73 
74     }

View Code

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

三. 各种算法开源库(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                {
 2                     //1. Base64的编码和解码
 3                     var srcString = "ypf001";
 4                     var hashed1 = EncryptProvider.Base64Encrypt(srcString);  //default encoding is UTF-8
 5                     var hashed2 = EncryptProvider.Base64Encrypt(srcString, Encoding.ASCII); //按照ascii进行编码
 6                     var strValue1 = EncryptProvider.Base64Decrypt(hashed1);   //default encoding is UTF-8
 7                     var strValue2 = EncryptProvider.Base64Decrypt(hashed2, Encoding.ASCII);   //按照ascii进行解码
 8                 }
 9                 {
10                     //2. MD5
11                     var srcString = "ypf001";
12                     var hashed1 = EncryptProvider.Md5(srcString);  //默认32位
13                     var hashed2 = EncryptProvider.Md5(srcString, MD5Length.L16); //16位
14                     Console.WriteLine($"ypf001的MD5加密(32位):{hashed1}");
15                     Console.WriteLine($"ypf002的MD5加密(64位):{hashed2}");
16                     //扩展用法
17                     var hashed3 = srcString.MD5();
18                 }
19                 {
20                     //3. SHA相关
21                     var srcString = "ypf001";
22                     var hashed1 = EncryptProvider.Sha1(srcString);
23                     var hashed2 = EncryptProvider.Sha256(srcString);
24                     var hashed3 = EncryptProvider.Sha384(srcString);
25                     var hashed4 = EncryptProvider.Sha512(srcString);
26                     //扩展用法(如下，其余类似)
27                     var extHash = srcString.SHA1();
28                 }
29                 {
30                     //4. HAMC相关
31                     var secretKey = "sflkasfkksfs";
32                     var srcString = "ypf001";
33                     var hashed1 = EncryptProvider.HMACMD5(srcString, secretKey);
34                     var hashed2 = EncryptProvider.HMACSHA1(srcString, secretKey);
35                     var hashed3 = EncryptProvider.HMACSHA256(srcString, secretKey);
36                     var hashed4 = EncryptProvider.HMACSHA384(srcString, secretKey);
37                     var hashed5 = EncryptProvider.HMACSHA512(srcString, secretKey);
38                     //扩展用法(如下，其余类似)
39                     var extHash = srcString.HMACSHA1(secretKey);
40                 }
41                 {
42                     //5. AES
43                     //利用算法生成key和iv（32位和16位），当然这里可以自己指定并保存好
44                     //var aesKey = EncryptProvider.CreateAesKey();
45                     //var key = aesKey.Key;
46                     //var iv = aesKey.IV;
47                     var secretKey = "asdfjketjnddkkaakkuyerbdsbgrtsaw";  //这里的key得32位
48                     var iv = "ioeruwoeruo2aqwe";  //加密和解密的过程中可以加上iv矢量，使其安全性更高,这里的iv得16位
49                     var srcString = "ypf001";
50                     //加密
51                     var encrypted1 = EncryptProvider.AESEncrypt(srcString, secretKey);
52                     var encrypted2 = EncryptProvider.AESEncrypt(srcString, secretKey, iv);
53                     //解密
54                     var decrypted1 = EncryptProvider.AESDecrypt(encrypted1, secretKey);
55                     var decrypted2 = EncryptProvider.AESDecrypt(encrypted2, secretKey, iv);
56                     //PS：这里除了string加密，还可以对byte数组加密
57                 }
58                 {
59                     //6. DES
60                     //利用算法生成key（24位），当然这里可以自己指定并保存好
61                     //var desKey = EncryptProvider.CreateDesKey();
62                     var secretKey = "asdfjketjnddkkaakkuyerbd";  //这里的key得24位
63                     var srcString = "ypf001";
64                     //加密
65                     var encrypted1 = EncryptProvider.DESEncrypt(srcString, secretKey);
66                     //解密
67                     var decrypted1 = EncryptProvider.DESDecrypt(encrypted1, secretKey);
68                     //PS：这里除了string加密，还可以对byte数组加密
69                 }
70                 {
71                     //7.RSA
72                     //利用算法生成公钥和私钥，然后保存；当然这里可以自己指定并保存好
73                     var rsaKey = EncryptProvider.CreateRsaKey();    //default is 2048
74                     // var rsaKey = EncryptProvider.CreateRsaKey(RsaSize.R3072);
75                     var publicKey = rsaKey.PublicKey;
76                     var privateKey = rsaKey.PrivateKey;
77                     var srcString = "ypf001";
78                     //加密
79                     var encrypted1 = EncryptProvider.RSAEncrypt(publicKey, srcString);   //公钥加密
80                     //解密
81                     var decrypted = EncryptProvider.RSADecrypt(privateKey, encrypted1);  //私钥解密
82                 }
83   public enum RsaSize
84     {
85         R2048 = 2048,
86         R3072 = 3072,
87         R4096 = 4096
88     }

框架封装

  1  /// 
  2     /// 各种加密解密算法
  3     /// 依赖程序集【NETCore.Encrypt】
  4     /// 
  5     public class SecurityHelp
  6     {
  7         /// 
  8         /// Base64编码
  9         /// 
 10         /// 需要编码的字符串
 11         /// 
 12         public static string Base64Encrypt(string srcString)
 13         {
 14             return EncryptProvider.Base64Encrypt(srcString);  //default encoding is UTF-8
 15         }
 16 
 17         /// 
 18         /// Base64编码
 19         /// 
 20         /// 需要解码的字符串
 21         /// 
 22         public static string Base64Decrypt(string encString)
 23         {
 24             return EncryptProvider.Base64Decrypt(encString);  //default encoding is UTF-8
 25         }
 26 
 27 
 28         /// 
 29         /// MD5加密
 30         /// 
 31         /// 需要加密的字符串
 32         /// 位数，默认为32位，也可以是16位
 33         /// 
 34         public static string Md5(string srcString, int num = 32)
 35         {
 36             if (num == 32)
 37             {
 38                 return EncryptProvider.Md5(srcString);  //默认32位
 39             }
 40             else
 41             {
 42                 return EncryptProvider.Md5(srcString, MD5Length.L16);   //16位
 43             }
 44         }
 45 
 46 
 47         /// 
 48         /// SHA系列算法
 49         /// 
 50         /// 需要加密的字符串
 51         /// 类型
 52         /// 
 53         public static string SHA(string srcString, string kind = "Sha512")
 54         {
 55             if (kind.Equals("Sha1"))
 56             {
 57                 return EncryptProvider.Sha1(srcString);
 58             }
 59             else if (kind.Equals("Sha256"))
 60             {
 61                 return EncryptProvider.Sha256(srcString);
 62             }
 63             else if (kind.Equals("Sha384"))
 64             {
 65                 return EncryptProvider.Sha384(srcString);
 66             }
 67             else
 68             {
 69                 return EncryptProvider.Sha512(srcString);
 70             }
 71         }
 72 
 73         /// 
 74         /// HMAC系列算法
 75         /// 
 76         /// 需要加密的字符串
 77         /// 密钥
 78         /// 类型
 79         /// 
 80         public static string HMAC(string srcString, string secretKey, string kind = "HMACSHA512")
 81         {
 82             if (kind.Equals("HMACMD5"))
 83             {
 84                 return EncryptProvider.HMACMD5(srcString, secretKey);
 85             }
 86             else if (kind.Equals("HMACSHA1"))
 87             {
 88                 return EncryptProvider.HMACSHA1(srcString, secretKey);
 89             }
 90             else if (kind.Equals("HMACSHA256"))
 91             {
 92                 return EncryptProvider.HMACSHA256(srcString, secretKey);
 93             }
 94             else if (kind.Equals("HMACSHA384"))
 95             {
 96                 return EncryptProvider.HMACSHA384(srcString, secretKey);
 97             }
 98             else
 99             {
100                 return EncryptProvider.HMACSHA512(srcString, secretKey);
101             }
102         }
103 
104 
105         /// 
106         /// 生成AES算法所需的Key和iv
107         /// (当然这里可以自己指定并保存好)
108         /// 
109         /// 加密所需的key
110         /// 加密所需的矢量
111         public static void CreateAesKey(ref string key, ref string iv)
112         {
113             //利用算法生成key和iv（32位和16位），当然这里可以自己指定并保存好
114             var aesKey = EncryptProvider.CreateAesKey();
115             key = aesKey.Key;
116             iv = aesKey.IV;
117         }
118 
119         /// 
120         /// AES加密算法
121         /// 
122         /// 需要加密的字符串
123         /// 密钥
124         /// 矢量（可以不填）
125         /// 
126         public static string AESEncrypt(string srcString, string secretKey, string iv = "")
127         {
128             if (string.IsNullOrEmpty(iv))
129             {
130                 return EncryptProvider.AESEncrypt(srcString, secretKey);    //表示不需要iv矢量的AES加密算法
131             }
132             else
133             {
134                 return EncryptProvider.AESEncrypt(srcString, secretKey, iv);    //表示需要iv矢量的AES加密算法
135             }
136         }
137 
138 
139         /// 
140         /// AES解密算法
141         /// 
142         /// 需要解密的字符串
143         /// 密钥
144         /// 矢量（可以不填）
145         /// 
146         public static string AESDecrypt(string encString, string secretKey, string iv = "")
147         {
148             if (string.IsNullOrEmpty(iv))
149             {
150                 return EncryptProvider.AESDecrypt(encString, secretKey);    //表示不需要iv矢量的AES解密算法
151             }
152             else
153             {
154                 return EncryptProvider.AESDecrypt(encString, secretKey, iv);

上一篇：springcloud alibaba-服务容错

下一篇：spring boot集成email

文章来自：搜素材网的编程语言模块，转载请注明文章出处。
文章标题：第二十四节：编码、解码、加密算法概念及实现（Base64、MD5、SHA、HMAC、DES、AES、RSA）
文章链接：http://soscw.com/index.php/essay/42543.html

亲，登录后才可以留言！

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

评论

热门文章

推荐文章

最新文章

置顶文章