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

相关文章推荐

腹黑的鸡蛋面 · RSA加密的使用_rsa使用· 2 周前 ·

坏坏的小熊猫 · 104年度 | 中國醫藥大學公共關係中心· 2 月前 ·

斯文的小狗 · 2021年北京市中小企业发展报告_政府信息公 ...· 4 月前 ·

不拘小节的咖啡豆 · 海贼王封面连载&剧情回顾——第十一回，被熊拍 ...· 1 年前 ·

不拘小节的小蝌蚪 · 聚焦豪华战略初见成效：奔驰2022乘用车利润 ...· 1 年前 ·

帅气的钥匙扣 · 妖精住嘴_百度百科· 1 年前 ·

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

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系列.

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

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

 1             //MD5
 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("-",""); 
 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("-", "");
2. HMAC算法
　　HMAC是具密钥的哈希算法，以一个密钥和一个消息为输入，生成摘要作为输出，消息 + 密钥 + 算法 ==》 输出摘要包括：HMAC-MD5、HMAC-SHA1、HMAC-SHA256、HMAC-SHA384、HMAC-SHA512,使用的程序集：【System.Security.Cryptography.Algorithms】（微软），代码见下，和后面开源库的实现相比多了些 -,可以利用replace去掉。
 1             //HMAC相关
 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("-", "");
3.对称加密算法
　　采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密加密，也称为单密钥加密。 常见的对称加解密算法：AES、DES、RC2、TripleDES 和 Rijndael 算法。
 1   public class DesEncrypt
 3         //8位长度
 4         private static byte[] rgbKey = ASCIIEncoding.ASCII.GetBytes("ioeruwoe");  //密钥（转为byte数组）
 5         private static byte[] rgbIV = ASCIIEncoding.ASCII.GetBytes("ypf00001");   //矢量（配合密钥更加安全）
 7         #region 01-DES加密
 8         /// <summary>
 9         /// DES 加密
10         /// </summary>
11         /// <param name="strValue">需要加密的字符串</param>
12         /// <returns></returns>
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
28         #region 02-DES解密
29         /// <summary>
30         /// DES解密
31         /// </summary>
32         /// <param name="EncValue">加密后的结果</param>
33         /// <returns></returns>
34         public static string Decrypt(string EncValue)
35         {
36             DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
37             byte[] buffer = Convert.FromBase64String(EncValue);
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
View Code
1             //DES算法
3                 //具体实现详见：DesEncrypt 
4                 string msg1 = "mr1";
5                 //密钥写在DesEncrypt类中了
6                 string result1 = DesEncrypt.Encrypt(msg1);
7                 string result2 = DesEncrypt.Decrypt(result1);
4.非对称加密算法




    

　　非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。
　　非对称加密算法实现机密信息交换的基本过程是：甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开；得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方；甲方再用自己保存的另一把专用密钥对加密后的信息进行解密。
常见的非对称加解密算法：DSA 和 RSA
 1     public class RsaEncrypt
 3         #region 01-生成公钥和私钥
 4         /// <summary>
 5         /// 生成公钥和私钥
 6         /// </summary>
 7         /// <returns></returns>
 8         public static KeyValuePair<string, string> GetKeyPair()
10             RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
11             string publicKey = RSA.ToXmlString(false);
12             string privateKey = RSA.ToXmlString(true);
13             return new KeyValuePair<string, string>(publicKey, privateKey);
14         }
15         #endregion
17         #region 02-加密(传入内容和公钥)
18         /// <summary>
19         /// 加密：内容+公钥,事先需要生成公钥和私钥
20         /// </summary>
21         /// <param name="content">加密内容</param>
22         /// <param name="publicKey">公钥</param>
23         /// <returns></returns>
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
35         #region 03-加密(并返回公钥和私钥)
36         /// <summary>
37         /// 加密(并返回公钥和私钥),在该方法中生成了公钥和私钥，并返回
38         /// </summary>
39         /// <param name="content">加密内容</param>
40         /// <param name="publicKey">返还公钥</param>
41         /// <param name="privateKey">返回密钥</param>
42         /// <returns>加密后结果</returns>
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
55         #region 04-解密(内容+私钥)
56         /// <summary>
57         /// 解密-内容+私钥
58         /// </summary>
59         /// <param name="content"></param>
60         /// <param name="privateKey"></param>
61         /// <returns></returns>
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
View Code
 1            //RSA算法
 3                 //具体实现详见 RsaEncrypt
 4                 //方式一：先生成公钥和私钥,然后加密和解密
 5                 //KeyValuePair是一个键值对, myKey.Key 代表的公钥；myKey.Value 代表的私钥
 6                 KeyValuePair<string, 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);
 三. 各种算法开源库(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[] 两种格式。
 推荐使用这个第三方库，已经封装好了，直接调用即可
 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进行解码
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
  1  /// <summary>
  2     /// 各种加密解密算法
  3     /// 依赖程序集【NETCore.Encrypt】
  4     /// </summary>
  5     public class SecurityHelp
  7         /// <summary>
  8         /// Base64编码
  9         /// </summary>
 10         /// <param name="srcString">需要编码的字符串</param>
 11         /// <returns></returns>
 12         public static string Base64Encrypt(string srcString)
 13         {
 14             return EncryptProvider.Base64Encrypt(srcString);  //default encoding is UTF-8
 15         }
 17         /// <summary>
 18         /// Base64编码
 19         /// </summary>
 20         /// <param name="encString">需要解码的字符串</param>
 21         /// <returns></returns>
 22         public static string Base64Decrypt(string encString)
 23         {
 24             return EncryptProvider.Base64Decrypt(encString);  //default encoding is UTF-8
 25         }
 28         /// <summary>
 29         /// MD5加密
 30         /// </summary>
 31         /// <param name="srcString">需要加密的字符串</param>
 32         /// <param name="num">位数，默认为32位，也可以是16位</param>
 33         /// <returns></returns>
 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         }
 47         /// <summary>
 48         /// SHA系列算法
 49         /// </summary>
 50         /// <param name="srcString">需要加密的字符串</param>
 51         /// <param name="kind">类型</param>
 52         /// <returns></returns>
 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         }
 73         /// <summary>
 74         /// HMAC系列算法
 75         /// </summary>
 76         /// <param name="srcString">需要加密的字符串</param>
 77         /// <param name="secretKey">密钥</param>
 78         /// <param name="kind">类型</param>
 79         /// <returns></returns>
 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         }
105         /// <summary>
106         /// 生成AES算法所需的Key和iv
107         /// (当然这里可以自己指定并保存好)
108         /// </summary>
109         /// <param name="key">加密所需的key</param>
110         /// <param name="iv">加密所需的矢量</param>
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         }
119         /// <summary>
120         /// AES加密算法
121         /// </summary>
122         /// <param name="srcString">需要加密的字符串</param>
123         /// <param name="secretKey">密钥</param>
124         /// <param name="iv">矢量（可以不填）</param>
125         /// <returns></returns>
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         }
139         /// <summary>
140         /// AES解密算法
141         /// </summary>
142         /// <param name="encString">需要解密的字符串</param>
143         /// <param name="secretKey">密钥</param>
144         /// <param name="iv">矢量（可以不填）</param>
145         /// <returns></returns>
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);    //表示需要iv矢量的AES解密算法
155             }
156         }
159         /// <summary>
160         /// DES加密算法
161         /// </summary>
162         /// <param name="srcString">需要加密的字符串</param>
163         /// <param name="secretKey">密钥（这里的密钥需要是24位）</param>
164         /// <returns></returns>
165         public static string EDSEncrypt(string srcString, string secretKey)
166         {
167             return EncryptProvider.DESEncrypt(srcString, secretKey);
168         }
171         /// <summary>
172         /// DES解密算法
173         /// </summary>
174         /// <param name="encString">需要解密的字符串</param>
175         /// <param name="secretKey">密钥</param>
176         /// <returns></returns>
177         public static string DESDecrypt(string encString, string secretKey)
178         {
179             return EncryptProvider.DESDecrypt(encString, secretKey);
180         }
184         /// <summary>
185         /// 生成RSA算法所需的Key和iv
186         /// (当然这里可以自己指定并保存好)
187         /// </summary>
188         /// <param name="PublicKey">公钥</param>
189         /// <param name="PrivateKey">私钥</param>
190         public static void CreateRsaKey(ref string PublicKey, ref string PrivateKey)
191         {
192             //利用算法生成公钥和私钥，然后保存；当然这里可以自己指定并保存好
193             var rsaKey = EncryptProvider.CreateRsaKey();    //default is 2048
194                                                             // var rsaKey = EncryptProvider.CreateRsaKey(RsaSize.R3072);
195             PublicKey = rsaKey.PublicKey;
196             PrivateKey = rsaKey.PrivateKey;
197         }
201         /// <summary>
202         /// RSA加密算法
203         /// </summary>
204         /// <param name="srcString">需要加密的字符串</param>
205         /// <param name="publicKey">公钥 加密</param>
206         /// <returns></returns>
207         public static string RSAEncrypt(string srcString, string publicKey)
208         {
209             return EncryptProvider.RSAEncrypt(publicKey, srcString);   //公钥加密
210         }
213         /// <summary>
214         /// RSA解密算法
215         /// </summary>
216         /// <param name="encString">需要解密的字符串</param>
217         /// <param name="privateKey">私钥 解密</param>
218         /// <returns></returns>
219         public static string RSADecrypt(string encString, string privateKey)
220         {
221             return EncryptProvider.RSADecrypt(privateKey, encString);  //私钥解密
222         }
226     }
230     public enum RsaSize
231     {
232         R2048 = 2048,
233         R3072 = 3072,
234         R4096 = 4096
235     }
View Code
作       者 : Yaopengfei(姚鹏飞)
博客地址 : http://www.cnblogs.com/yaopengfei/
声     明1 : 本人才疏学浅，用郭德纲的话说“我是一个小学生”，如有错误，欢迎讨论，请勿谩骂^_^。
声     明2 : 原创博客请在转载时保留原文链接或在文章开头加上本人博客地址，否则保留追究法律责任的权利。