发帖
翼度科技»论坛 › 编程开发 › .net › 查看内容

前端请求参数加密、.NET 后端解密

黎正贤

9

主题

9

帖子

27

积分

新手上路

Rank: 1

积分
27
显示全部楼层
本文详细介绍了前端请求参数加密、.NET 后端解密，文章较长，请各位看官耐心看完。

目录

一、前端使用“CryptoJS”，前端AES加密，.NET后端AES解密

1.1、加密解密效果图


1.2、CryptoJS介绍

CryptoJS是一个JavaScript的加解密的工具包。它支持多种的算法：MD5、SHA1、SHA2、SHA3、RIPEMD-160 哈希散列，进行 AES、DES、Rabbit、RC4、Triple DES 加解密。
1.3、准备工作：安装“CryptoJS”

1.3.1、使用npm进行安装

npm安装命令如下：
  1. npm install crypto-js --save-dev
复制代码
1.3.2、Visual Studio中安装

1.3.2.1、选择“客户端库”


1.3.2.2、安装下载“CryptoJS”

在“添加客户端库”界面：

  • 提供程序：选择“unpkg”；
  • 库：输入“crypto-js@”，进行版本的选择；
  • 可选择：1、包括所有库文件；2、选择特定文件；
确认无误之后，点击“安装”即可。

1.4、H5页面代码中引用“crypto-js”

1.5、前端页面代码

1.5.1、Html代码

H5代码使用了Layui开原框架
  1. <!DOCTYPE html>
  3. <html>
  4. <head>
  5.     <meta name="viewport" content="width=device-width" />
  6.     <title>sometext</title>
  7.     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  8.    
  9.    
  10.    
  11.        
  12.     <link href="/lib/layui/dist/css/layui.css" rel="stylesheet" />
  13.     <link href="/lib/bootstrap/dist/css/bootstrap.css" rel="stylesheet" />
  14.    
  15. </head>
  16. <body>
  17.    
  18.         
  19.             
  20.                 脱敏/加密前的内容：
  21.             
  22.             <input type="password"  id="sourctText" placeholder="脱敏/加密前的内容" aria-label="sourctText" aria-describedby="basic-addon1">
  23.         
  24.         <br />
  25.         
  26.             
  27.                 加密后的内容：
  28.             
  29.             <input type="text"  id="encryptText" placeholder="加密后的内容" readonly="readonly" aria-label="encryptText" aria-describedby="basic-addon1">
  30.         
  31.         <br />
  32.         
  33.             
  34.                 脱敏/加密后的内容：
  35.             
  36.             <input type="text"  id="resText" placeholder="脱敏/加密后的内容" readonly="readonly" aria-label="resText" aria-describedby="basic-addon1">
  37.         
  39.         
  40.             <button id="submit" type="button" >提交</button>
  41.         
  42.    
  43. </body>
  44. </html>
复制代码
1.5.2、javascript代码

说明：CBC模式前、后端需要确定偏移量的值，并且保持一致，这样才能确保后端解密成功。
  1. [/code][size=5]1.6、.NET 后端代码[/size]
  3. [size=4]1.6.1、定义公共的密匙字段[/size]
  5. [code]/// <summary>
  6. /// //AES加密所需16位密匙
  7. /// </summary>
  8. private static readonly String strAesKey = "lucasnetLUCASNET";
  10. /// <summary>
  11. /// AES加密所需16位密匙向量
  12. /// </summary>
  13. private static readonly String strAesIv = "lucasnetLUCASNET";
复制代码
1.6.2、封装AES解密方法
  1. /// <summary>
  2. ///  AES 解密
  3. /// </summary>
  4. /// <param name="str">密文（待解密）</param>
  5. /// <returns></returns>
  6. public string AesDecrypt(string str)
  7. {
  8.     if (string.IsNullOrEmpty(str)) return null;
  9.     Byte[] toEncryptArray = Convert.FromBase64String(str);
  10.     using (RijndaelManaged rm = new RijndaelManaged())
  11.     {
  12.         rm.Key = Encoding.UTF8.GetBytes(strAesKey);
  13.         rm.IV = Encoding.UTF8.GetBytes(strAesIv);
  14.         rm.Mode = CipherMode.CBC;
  15.         rm.Padding = PaddingMode.PKCS7;
  16.         rm.FeedbackSize = 128;
  17.         ICryptoTransform encryptor = rm.CreateDecryptor(rm.Key, rm.IV);
  18.         Byte[] resultArray = encryptor.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
  19.         return Encoding.UTF8.GetString(resultArray);
  20.     }
  21. }
复制代码
1.6.3、编写API接口
  1. /// <summary>
  2. /// 解密接口
  3. /// </summary>
  4. /// <param name="ciphertextpwd">密码密文（待解密）</param>
  5. /// <param name="publicKey">公钥</param>
  6. /// <param name="privateKey">私钥</param>
  7. /// <returns></returns>
  8. [HttpPost]
  9. public IActionResult word_Encrypt(string ciphertextpwd)
  10. {
  11.     string resPwd = "";
  12.     try
  13.     {
  14.         resPwd = AesDecrypt(ciphertextpwd);
  15.         return Json(new { code = 200, msg = resPwd });
  16.     }
  17.     catch (Exception ex)
  18.     {
  19.         return Json(new { code = 220, msg = "AES解密时出现错误！！！" });
  20.     }
  21. }
复制代码
二、前端使用“JSEncrypt”，进行非对称RSA加密，.NET后端解密

2.1、加密解密效果图


2.2、非对称加密

所谓的非对称，即加密和解密用的不是同一个秘钥。比如用公钥加密，就要用私钥解密。非对称加密的安全性是要好于对称加密的，但是性能就比较差了。
2.3、RSA

非对称加密算法中常用的就是 RSA 了。它是由在 MIT 工作的 3 个人于 1977 年提出，RSA 这个名字的由来便是取自他们 3 人的姓氏首字母。我们在访问 github 等远程 git 仓库时，如果是使用 SSH 协议，需要生成一对公私秘钥，就可以使用 RSA 算法。
2.4、准备工作：安装“jsencrypt”

2.4.1、使用npm进行安装

npm安装命令如下：
  1. npm install jsencrypt
复制代码
2.4.2、Visual Studio中安装

2.4.2.1、选择“客户端库”


2.4.2.2、安装下载“jsencrypt”

在“添加客户端库”界面：

  • 提供程序：选择“unpkg”；
  • 库：输入“jsencrypt@”，进行版本的选择；
  • 可选择：1、包括所有库文件；2、选择特定文件；
确认无误之后，点击“安装”即可。

2.5、安装组件“BouncyCastle”

在菜单栏找到 工具 —> NuGet 包管理器 —> 管理解决方案的NuGet程序包 —> 浏览 —> 搜索 “BouncyCastle” —> 安装。

2.5.1、新建帮助类

2.5.1.1、添加C# RAS生成.NET公钥与私钥以及.NET公钥与私钥转Java公钥私钥类“RASKeyConversion”

可根据自己需求删除生成Java的
  1. using Org.BouncyCastle.Asn1.Pkcs;
  2. using Org.BouncyCastle.Asn1.X509;
  3. using Org.BouncyCastle.Crypto;
  4. using Org.BouncyCastle.Crypto.Parameters;
  5. using Org.BouncyCastle.Math;
  6. using Org.BouncyCastle.OpenSsl;
  7. using Org.BouncyCastle.Pkcs;
  8. using Org.BouncyCastle.Security;
  9. using Org.BouncyCastle.X509;
  10. using System;
  11. using System.Security.Cryptography;
  12. using System.Xml;
  14. namespace WebApplication1
  15. {
  16.     /// <summary>
  17.     /// C# RAS生成.NET公钥与私钥以及.NET公钥与私钥转Java公钥私钥类
  18.     /// </summary>
  19.     public class RASKeyConversion
  20.     {
  21.         /// <summary>
  22.         /// 第一个：C# 私钥；第二个：C# 公钥；第三个：JAVA私钥；第四个：JAVA公钥
  23.         /// </summary>
  24.         private static string[] sKeys = new String[4];
  26.         /// <summary>
  27.         /// 生成公钥与私钥方法
  28.         /// </summary>
  29.         /// <returns>第一个：C# 私钥；第二个：C# 公钥；第三个：JAVA私钥；第四个：JAVA公钥</returns>
  30.         public static string[] createPulbicKey(int size = 1024)
  31.         {
  32.             try
  33.             {
  34.                 //密钥格式要生成pkcs#1格式的  而不是pkcs#8格式的
  35.                 using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(size))
  36.                 {
  37.                     //C# 私钥
  38.                     sKeys[0] = rsa.ToXmlString(true);
  39.                     //C# 公钥
  40.                     sKeys[1] = rsa.ToXmlString(false);
  41.                     //JAVA私钥
  42.                     sKeys[2] = RSAPrivateKeyDotNet2Java(sKeys[0]);
  43.                     //JAVA公钥
  44.                     sKeys[3] = RSAPublicKeyDotNet2Java(sKeys[1]);
  45.                     return sKeys;
  46.                 }
  47.             }
  48.             catch (Exception)
  49.             {
  50.                 return null;
  51.             }
  52.         }
  54.         /// <summary>   
  55.         /// RSA私钥格式转换，.net->java   
  56.         /// </summary>   
  57.         /// <param name="privateKey">.net生成的私钥</param>   
  58.         /// <returns></returns>   
  59.         public static string RSAPrivateKeyDotNet2Java(string privateKey)
  60.         {
  61.             XmlDocument doc = new XmlDocument();
  62.             doc.LoadXml(privateKey);
  63.             BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
  64.             BigInteger exp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
  65.             BigInteger d = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("D")[0].InnerText));
  66.             BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("P")[0].InnerText));
  67.             BigInteger q = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Q")[0].InnerText));
  68.             BigInteger dp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DP")[0].InnerText));
  69.             BigInteger dq = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DQ")[0].InnerText));
  70.             BigInteger qinv = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("InverseQ")[0].InnerText));
  71.             RsaPrivateCrtKeyParameters privateKeyParam = new RsaPrivateCrtKeyParameters(m, exp, d, p, q, dp, dq, qinv);
  73.             PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParam);
  74.             byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetEncoded();
  75.             return Convert.ToBase64String(serializedPrivateBytes);
  76.         }
  78.         /// <summary>   
  79.         /// RSA公钥格式转换，.net->java   
  80.         /// </summary>   
  81.         /// <param name="publicKey">.net生成的公钥</param>   
  82.         /// <returns></returns>   
  83.         public static string RSAPublicKeyDotNet2Java(string publicKey)
  84.         {
  85.             XmlDocument doc = new XmlDocument();
  86.             doc.LoadXml(publicKey);
  87.             BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
  88.             BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
  89.             RsaKeyParameters pub = new RsaKeyParameters(false, m, p);
  91.             SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pub);
  92.             byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded();
  93.             return Convert.ToBase64String(serializedPublicBytes);
  94.         }
  95.     }
  96. }
复制代码
2.5.1.2、添加RSA秘钥转换帮助类“RsaKeyConvert”
  1. using Org.BouncyCastle.Crypto.Parameters;
  2. using Org.BouncyCastle.Crypto;
  3. using Org.BouncyCastle.Pkcs;
  4. using Org.BouncyCastle.Security;
  5. using System.Xml.Linq;
  6. using Org.BouncyCastle.OpenSsl;
  7. using Org.BouncyCastle.Math;
  9. namespace WebApplication1 //命名空间依据自己的项目进行修改
  10. {
  11.     /// <summary>
  12.     /// RSA秘钥转换帮助类
  13.     /// </summary>
  14.     public class RsaKeyConvert
  15.     {
  17.         #region 其他格式的RSA秘钥转XML格式秘钥
  19.         /// <summary>
  20.         /// pem格式的RSA公钥字符串转XML格式公钥 Public Key Convert pem->xml
  21.         /// </summary>
  22.         /// <param name="publicKey">公钥字符串</param>
  23.         /// <returns></returns>
  24.         /// <exception cref="Exception"></exception>
  25.         public static string PublicKeyPemToXml(string publicKey)
  26.         {
  27.             publicKey = PublicKeyFormat(publicKey);
  28.             RsaKeyParameters rsaKeyParameters = new PemReader(new StringReader(publicKey)).ReadObject() as RsaKeyParameters;
  29.             if (rsaKeyParameters == null)
  30.             {
  31.                 throw new Exception("Public key format is incorrect");
  32.             }
  34.             XElement xElement = new XElement((XName?)"RSAKeyValue");
  35.             XElement content = new XElement((XName?)"Modulus", Convert.ToBase64String(rsaKeyParameters.Modulus.ToByteArrayUnsigned()));
  36.             XElement content2 = new XElement((XName?)"Exponent", Convert.ToBase64String(rsaKeyParameters.Exponent.ToByteArrayUnsigned()));
  37.             xElement.Add(content);
  38.             xElement.Add(content2);
  39.             return xElement.ToString();
  40.         }
  42.         /// <summary>
  43.         /// Pkcs1格式私钥转成Xml Pkcs1->xml
  44.         /// </summary>
  45.         /// <param name="privateKey">Pkcs1格式私钥字符串</param>
  46.         /// <returns></returns>
  47.         /// <exception cref="Exception"></exception>
  48.         public static string PrivateKeyPkcs1ToXml(string privateKey)
  49.         {
  50.             privateKey = Pkcs1PrivateKeyFormat(privateKey);
  51.             RsaPrivateCrtKeyParameters rsaPrivateCrtKeyParameters = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(PrivateKeyInfoFactory.CreatePrivateKeyInfo(((new PemReader(new StringReader(privateKey)).ReadObject() as AsymmetricCipherKeyPair) ?? throw new Exception("Private key format is incorrect")).Private));
  52.             XElement xElement = new XElement((XName?)"RSAKeyValue");
  53.             XElement content = new XElement((XName?)"Modulus", Convert.ToBase64String(rsaPrivateCrtKeyParameters.Modulus.ToByteArrayUnsigned()));
  54.             XElement content2 = new XElement((XName?)"Exponent", Convert.ToBase64String(rsaPrivateCrtKeyParameters.PublicExponent.ToByteArrayUnsigned()));
  55.             XElement content3 = new XElement((XName?)"P", Convert.ToBase64String(rsaPrivateCrtKeyParameters.P.ToByteArrayUnsigned()));
  56.             XElement content4 = new XElement((XName?)"Q", Convert.ToBase64String(rsaPrivateCrtKeyParameters.Q.ToByteArrayUnsigned()));
  57.             XElement content5 = new XElement((XName?)"DP", Convert.ToBase64String(rsaPrivateCrtKeyParameters.DP.ToByteArrayUnsigned()));
  58.             XElement content6 = new XElement((XName?)"DQ", Convert.ToBase64String(rsaPrivateCrtKeyParameters.DQ.ToByteArrayUnsigned()));
  59.             XElement content7 = new XElement((XName?)"InverseQ", Convert.ToBase64String(rsaPrivateCrtKeyParameters.QInv.ToByteArrayUnsigned()));
  60.             XElement content8 = new XElement((XName?)"D", Convert.ToBase64String(rsaPrivateCrtKeyParameters.Exponent.ToByteArrayUnsigned()));
  61.             xElement.Add(content);
  62.             xElement.Add(content2);
  63.             xElement.Add(content3);
  64.             xElement.Add(content4);
  65.             xElement.Add(content5);
  66.             xElement.Add(content6);
  67.             xElement.Add(content7);
  68.             xElement.Add(content8);
  69.             return xElement.ToString();
  70.         }
  72.         /// <summary>
  73.         /// 格式化公钥字符串
  74.         /// </summary>
  75.         /// <param name="str">公钥字符串</param>
  76.         /// <returns></returns>
  77.         public static string PublicKeyFormat(string str)
  78.         {
  79.             if (str.StartsWith("-----BEGIN PUBLIC KEY-----"))
  80.             {
  81.                 return str;
  82.             }
  84.             List<string> list = new List<string>();
  85.             list.Add("-----BEGIN PUBLIC KEY-----");
  86.             int num;
  87.             for (int i = 0; i < str.Length; i += num)
  88.             {
  89.                 num = ((str.Length - i < 64) ? (str.Length - i) : 64);
  90.                 list.Add(str.Substring(i, num));
  91.             }
  93.             list.Add("-----END PUBLIC KEY-----");
  94.             return string.Join(Environment.NewLine, list);
  95.         }
  97.         /// <summary>
  98.         /// 格式化Pkcs1私钥
  99.         /// </summary>
  100.         /// <param name="str">私钥字符串</param>
  101.         /// <returns></returns>
  102.         public static string Pkcs1PrivateKeyFormat(string str)
  103.         {
  104.             if (str.StartsWith("-----BEGIN RSA PRIVATE KEY-----"))
  105.             {
  106.                 return str;
  107.             }
  109.             List<string> list = new List<string>();
  110.             list.Add("-----BEGIN RSA PRIVATE KEY-----");
  111.             int num;
  112.             for (int i = 0; i < str.Length; i += num)
  113.             {
  114.                 num = ((str.Length - i < 64) ? (str.Length - i) : 64);
  115.                 list.Add(str.Substring(i, num));
  116.             }
  118.             list.Add("-----END RSA PRIVATE KEY-----");
  119.             return string.Join(Environment.NewLine, list);
  120.         }
  122.         #endregion
  124.         #region Xml格式的RSA秘钥转格式
  126.         /// <summary>
  127.         /// RSA公钥格式转换：Xml格式的公钥转Pem格式的公钥 xml->pem
  128.         /// </summary>
  129.         /// <param name="publicKey">Xml公钥字符串</param>
  130.         /// <returns></returns>
  131.         public static string PublicKeyXmlToPem(string publicKey)
  132.         {
  133.             XElement xElement = XElement.Parse(publicKey);
  134.             XElement xElement2 = xElement.Element((XName?)"Modulus");
  135.             XElement xElement3 = xElement.Element((XName?)"Exponent");
  136.             RsaKeyParameters obj = new RsaKeyParameters(isPrivate: false, new BigInteger(1, Convert.FromBase64String(xElement2.Value)), new BigInteger(1, Convert.FromBase64String(xElement3.Value)));
  137.             StringWriter stringWriter = new StringWriter();
  138.             PemWriter pemWriter = new PemWriter(stringWriter);
  139.             pemWriter.WriteObject(obj);
  140.             pemWriter.Writer.Close();
  141.             return stringWriter.ToString();
  142.         }
  144.         /// <summary>
  145.         /// RSA私钥格式转换：Xml格式的私钥转Pkcs1格式的私钥 xml->Pkcs1
  146.         /// </summary>
  147.         /// <param name="privateKey">Xml私钥字符串</param>
  148.         /// <returns></returns>
  149.         public static string PrivateKeyXmlToPkcs1(string privateKey)
  150.         {
  151.             XElement xElement = XElement.Parse(privateKey);
  152.             XElement xElement2 = xElement.Element((XName?)"Modulus");
  153.             XElement xElement3 = xElement.Element((XName?)"Exponent");
  154.             XElement xElement4 = xElement.Element((XName?)"P");
  155.             XElement xElement5 = xElement.Element((XName?)"Q");
  156.             XElement xElement6 = xElement.Element((XName?)"DP");
  157.             XElement xElement7 = xElement.Element((XName?)"DQ");
  158.             XElement xElement8 = xElement.Element((XName?)"InverseQ");
  159.             XElement xElement9 = xElement.Element((XName?)"D");
  160.             RsaPrivateCrtKeyParameters obj = new RsaPrivateCrtKeyParameters(new BigInteger(1, Convert.FromBase64String(xElement2.Value)), new BigInteger(1, Convert.FromBase64String(xElement3.Value)), new BigInteger(1, Convert.FromBase64String(xElement9.Value)), new BigInteger(1, Convert.FromBase64String(xElement4.Value)), new BigInteger(1, Convert.FromBase64String(xElement5.Value)), new BigInteger(1, Convert.FromBase64String(xElement6.Value)), new BigInteger(1, Convert.FromBase64String(xElement7.Value)), new BigInteger(1, Convert.FromBase64String(xElement8.Value)));
  161.             StringWriter stringWriter = new StringWriter();
  162.             PemWriter pemWriter = new PemWriter(stringWriter);
  163.             pemWriter.WriteObject(obj);
  164.             pemWriter.Writer.Close();
  165.             return stringWriter.ToString();
  166.         }
  168.         #endregion
  170.     }
  171. }
复制代码
2.5.1.3、添加RSA加密帮助类“RSACrypto”
  1. using System;
  2. using System.Collections.Generic;
  3. using System.IO;
  4. using System.Linq;
  5. using System.Security.Cryptography;
  6. using System.Security.Cryptography.X509Certificates;
  7. using System.Text;
  8. using System.Threading.Tasks;
  10. namespace WebApplication1 //命名空间依据自己的项目进行修改
  11. {
  12.     /// <summary>
  13.     /// RSA加密帮助类
  14.     /// </summary>
  15.     public class RSACrypto
  16.     {
  17.         /// <summary>
  18.         /// 默认的私钥
  19.         /// </summary>
  20.         private const string defaultprivateKey = @"MIICXAIBAAKBgQCC0hrRIjb3noDWNtbDpANbjt5Iwu2NFeDwU16Ec87ToqeoIm2KI+cOs81JP9aTDk/jkAlU97mN8wZkEMDr5utAZtMVht7GLX33Wx9XjqxUsDfsGkqNL8dXJklWDu9Zh80Ui2Ug+340d5dZtKtd+nv09QZqGjdnSp9PTfFDBY133QIDAQABAoGAJBNTOITaP6LCyKVKyEdnHaKNAz0DS+V9UwjKhyAgfcAxwm3sDdd6FQCEW0TIJA7Np7rFYrGwcR1UOoKxkNxB10ACl6JX4rE7xKS6NLZumdwxON/KgDb+2SQtWEXDgBySZ7Znv/FhEp1RmoBDjZ05E99kILWO3ToorUM0Eq2GHQkCQQCnUMXgZa4HS0tu
  21. INzysgB37d7ene9+CIARyJphs079qao2UWCgXqen43Ob6GJUgulz7We+4JOZFld0TfEi1E5rAkEAyClQAVzafLO3gXgqH7tbRbPPx788+4opxT9QBo2Trzl6/3FlcC1PIZeqbQ/Oc2wT7jmidFnpyTEnM2p7Yq3U1wJBAILTWaX4W3dAnJ5j+9+Y51zfFiEjhRwbMWi2XmB+gAlAHOOUBeXfnWBdLQx/TEOgiUIoI7LQjxhoq8E5II+HSjkCQDlKSdH6B7dFoTJ3eGcYsykiLEiZ3hSJGSeR1Y/qmei/ZQsUI9qVvV56EJeivI6g0puO94ah7Z5eaT/4LFS0OIUCQDgLn586pGgeidLhQsIe/AR3y9YOCAygTFLxzmeBXOKtM90q4516KWlTtK2u99442mNi7hNmjryBVwk62foWo8w=";
  23.         /// <summary>
  24.         /// 默认公钥
  25.         /// </summary>
  26.         private const string defaultpublicKey = @"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCC0hrRIjb3noDWNtbDpANbjt5Iwu2NFeDwU16Ec87ToqeoIm2KI+cOs81JP9aTDk/jkAlU97mN8wZkEMDr5utAZtMVht7GLX33Wx9XjqxUsDfsGkqNL8dXJklWDu9Zh80Ui2Ug+340d5dZtKtd+nv09QZqGjdnSp9PTfFDBY133QIDAQAB";
  28.         private RSACryptoServiceProvider _privateKeyRsaProvider;
  29.         private RSACryptoServiceProvider _publicKeyRsaProvider;
  31.         /// <summary>
  32.         /// RSA加密帮助类构造函数
  33.         /// </summary>
  34.         /// <param name="privateKey">RSA解密密匙</param>
  35.         /// <param name="publicKey">RSA加密密匙</param>
  36.         public RSACrypto(string privateKey = "", string publicKey = "")
  37.         {
  38.             //判断私钥密匙是否为空，为空，使用默认的私钥；
  39.             if (string.IsNullOrEmpty(privateKey))
  40.             {
  41.                 privateKey = defaultprivateKey;
  42.             }
  43.             //判断公钥密匙是否为空，为空，使用默认的公钥；
  44.             if (string.IsNullOrEmpty(publicKey))
  45.             {
  46.                 publicKey = defaultpublicKey;
  47.             }
  48.             //不为空：使用定义的私钥密匙创建
  49.             if (!string.IsNullOrEmpty(privateKey))
  50.             {
  51.                 _privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
  52.             }
  53.             //不为空：使用定义的公钥密匙创建
  54.             if (!string.IsNullOrEmpty(publicKey))
  55.             {
  56.                 _publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
  57.             }
  58.         }
  60.         public string GetPublicRsaKeyStr(string publicKey)
  61.         {
  62.             string keyStr = "";
  63.             CreateRsaProviderFromPublicKey(publicKey);
  64.             return keyStr;
  65.         }
  67.         /// <summary>
  68.         /// RSA解密
  69.         /// </summary>
  70.         /// <param name="cipherText">解密的密文字符串</param>
  71.         /// <returns></returns>
  72.         /// <exception cref="Exception"></exception>
  73.         public string RSADecrypt(string cipherText)
  74.         {
  75.             if (_privateKeyRsaProvider == null)
  76.             {
  77.                 throw new Exception("提供的RSA私钥为空");
  78.             }
  79.             if (string.IsNullOrEmpty(cipherText))
  80.             {
  81.                 return "";
  82.             }
  83.             return Encoding.UTF8.GetString(_privateKeyRsaProvider.Decrypt(System.Convert.FromBase64String(cipherText), false));
  84.         }
  86.         /// <summary>
  87.         /// RSA解密
  88.         /// </summary>
  89.         /// <param name="cipherText">需要解密的密文字符串</param>
  90.         /// <param name="publicKeyString">私钥</param>
  91.         /// <param name="keyType">密钥类型XML/PEM</param>
  92.         /// <returns></returns>
  93.         public static string RSADecrypt(string cipherText, string privateKeyString, string keyType, int size = 1024)
  94.         {
  95.             RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(size);
  96.             switch (keyType)
  97.             {
  98.                 case "XML":
  99.                     rsa.FromXmlString(privateKeyString);
  100.                     break;
  101.                 case "PEM":
  102.                     break;
  103.                 default:
  104.                     throw new Exception("不支持的密钥类型");
  105.             }
  106.             int MaxBlockSize = rsa.KeySize / 8;    //解密块最大长度限制
  107.             //正常解密
  108.             if (cipherText.Length <= MaxBlockSize)
  109.             {
  110.                 byte[] hashvalueDcy = rsa.Decrypt(System.Convert.FromBase64String(cipherText), false);//解密
  111.                 return Encoding.GetEncoding("UTF-8").GetString(hashvalueDcy);
  112.             }
  113.             //分段解密
  114.             else
  115.             {
  116.                 using (MemoryStream CrypStream = new MemoryStream(System.Convert.FromBase64String(cipherText)))
  117.                 {
  118.                     using (MemoryStream PlaiStream = new MemoryStream())
  119.                     {
  120.                         Byte[] Buffer = new Byte[MaxBlockSize];
  121.                         int BlockSize = CrypStream.Read(Buffer, 0, MaxBlockSize);
  123.                         while (BlockSize > 0)
  124.                         {
  125.                             Byte[] ToDecrypt = new Byte[BlockSize];
  126.                             Array.Copy(Buffer, 0, ToDecrypt, 0, BlockSize);
  128.                             Byte[] Plaintext = rsa.Decrypt(ToDecrypt, false);
  129.                             PlaiStream.Write(Plaintext, 0, Plaintext.Length);
  130.                             BlockSize = CrypStream.Read(Buffer, 0, MaxBlockSize);
  131.                         }
  132.                         string output = Encoding.GetEncoding("UTF-8").GetString(PlaiStream.ToArray());
  133.                         return output;
  134.                     }
  135.                 }
  136.             }
  137.         }
  139.         /// <summary>
  140.         /// RSA加密
  141.         /// </summary>
  142.         /// <param name="text">需要进行加密的明文字符串</param>
  143.         /// <returns></returns>
  144.         /// <exception cref="Exception"></exception>
  145.         public string RSAEncrypt(string text)
  146.         {
  147.             if (_publicKeyRsaProvider == null)
  148.             {
  149.                 throw new Exception("提供的RSA公钥为空");
  150.             }
  151.             return Convert.ToBase64String(_publicKeyRsaProvider.Encrypt(Encoding.UTF8.GetBytes(text), false));
  152.         }
  154.         /// <summary>
  155.         /// RSA加密
  156.         /// </summary>
  157.         /// <param name="clearText">需要加密的明文字符串</param>
  158.         /// <param name="publicKeyString">公钥</param>
  159.         /// <param name="keyType">密钥类型XML/PEM</param>
  160.         /// <returns></returns>
  161.         public static string RSAEncrypt(string clearText, string publicKeyString, string keyType, int size = 1024)
  162.         {
  163.             byte[] data = Encoding.GetEncoding("UTF-8").GetBytes(clearText);
  164.             RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(size);
  165.             switch (keyType)
  166.             {
  167.                 case "XML":
  168.                     rsa.FromXmlString(publicKeyString);
  169.                     break;
  170.                 case "PEM":
  171.                     break;
  172.                 default:
  173.                     throw new Exception("不支持的密钥类型");
  174.             }
  175.             //加密块最大长度限制，如果加密数据的长度超过 秘钥长度/8-11，会引发长度不正确的异常，所以进行数据的分块加密
  176.             int MaxBlockSize = rsa.KeySize / 8 - 11;
  177.             //正常长度
  178.             if (data.Length <= MaxBlockSize)
  179.             {
  180.                 byte[] hashvalueEcy = rsa.Encrypt(data, false); //加密
  181.                 return System.Convert.ToBase64String(hashvalueEcy);
  182.             }
  183.             //长度超过正常值
  184.             else
  185.             {
  186.                 using (MemoryStream PlaiStream = new MemoryStream(data))
  187.                 using (MemoryStream CrypStream = new MemoryStream())
  188.                 {
  189.                     Byte[] Buffer = new Byte[MaxBlockSize];
  190.                     int BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);
  191.                     while (BlockSize > 0)
  192.                     {
  193.                         Byte[] ToEncrypt = new Byte[BlockSize];
  194.                         Array.Copy(Buffer, 0, ToEncrypt, 0, BlockSize);
  196.                         Byte[] Cryptograph = rsa.Encrypt(ToEncrypt, false);
  197.                         CrypStream.Write(Cryptograph, 0, Cryptograph.Length);
  198.                         BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);
  199.                     }
  200.                     return System.Convert.ToBase64String(CrypStream.ToArray(), Base64FormattingOptions.None);
  201.                 }
  202.             }
  203.         }
  205.         /// <summary>
  206.         /// 通过提供的RSA私钥来创建RSA
  207.         /// </summary>
  208.         /// <param name="privateKey">私钥字符串</param>
  209.         /// <returns></returns>
  210.         /// <exception cref="Exception"></exception>
  211.         private RSACryptoServiceProvider CreateRsaProviderFromPrivateKey(string privateKey)
  212.         {
  213.             byte[] privateKeyBits = System.Convert.FromBase64String(privateKey);
  214.             RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
  215.             RSAParameters RSAparams = new RSAParameters();
  216.             using (BinaryReader binr = new BinaryReader(new MemoryStream(privateKeyBits)))
  217.             {
  218.                 byte bt = 0;
  219.                 ushort twobytes = 0;
  220.                 twobytes = binr.ReadUInt16();
  221.                 if (twobytes == 0x8130)
  222.                 {
  223.                     binr.ReadByte();
  224.                 }
  225.                 else if (twobytes == 0x8230)
  226.                 {
  227.                     binr.ReadInt16();
  228.                 }
  229.                 else
  230.                 {
  231.                     throw new Exception("Unexpected value read binr.ReadUInt16()");
  232.                 }
  233.                 twobytes = binr.ReadUInt16();
  234.                 if (twobytes != 0x0102)
  235.                 {
  236.                     throw new Exception("Unexpected version");
  237.                 }
  238.                 bt = binr.ReadByte();
  239.                 if (bt != 0x00)
  240.                 {
  241.                     throw new Exception("Unexpected value read binr.ReadByte()");
  242.                 }
  243.                 RSAparams.Modulus = binr.ReadBytes(GetIntegerSize(binr));
  244.                 RSAparams.Exponent = binr.ReadBytes(GetIntegerSize(binr));
  245.                 RSAparams.D = binr.ReadBytes(GetIntegerSize(binr));
  246.                 RSAparams.P = binr.ReadBytes(GetIntegerSize(binr));
  247.                 RSAparams.Q = binr.ReadBytes(GetIntegerSize(binr));
  248.                 RSAparams.DP = binr.ReadBytes(GetIntegerSize(binr));
  249.                 RSAparams.DQ = binr.ReadBytes(GetIntegerSize(binr));
  250.                 RSAparams.InverseQ = binr.ReadBytes(GetIntegerSize(binr));
  251.             }
  252.             RSA.ImportParameters(RSAparams);
  253.             return RSA;
  254.         }
  256.         /// <summary>
  257.         /// 获取整数大小
  258.         /// </summary>
  259.         /// <param name="binr"></param>
  260.         /// <returns></returns>
  261.         private int GetIntegerSize(BinaryReader binr)
  262.         {
  263.             byte bt = 0;
  264.             byte lowbyte = 0x00;
  265.             byte highbyte = 0x00;
  266.             int count = 0;
  267.             bt = binr.ReadByte();
  268.             if (bt != 0x02)
  269.                 return 0;
  270.             bt = binr.ReadByte();
  272.             if (bt == 0x81)
  273.                 count = binr.ReadByte();
  274.             else
  275.                 if (bt == 0x82)
  276.             {
  277.                 highbyte = binr.ReadByte();
  278.                 lowbyte = binr.ReadByte();
  279.                 byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };
  280.                 count = BitConverter.ToInt32(modint, 0);
  281.             }
  282.             else
  283.             {
  284.                 count = bt;
  285.             }
  287.             while (binr.ReadByte() == 0x00)
  288.             {
  289.                 count -= 1;
  290.             }
  291.             binr.BaseStream.Seek(-1, SeekOrigin.Current);
  292.             return count;
  293.         }
  295.         /// <summary>
  296.         /// 通过提供的RSA公钥来创建RSA
  297.         /// </summary>
  298.         /// <param name="publicKeyString">公钥字符串</param>
  299.         /// <returns></returns>
  300.         private RSACryptoServiceProvider CreateRsaProviderFromPublicKey(string publicKeyString)
  301.         {
  302.             // encoded OID sequence for  PKCS #1 rsaEncryption szOID_RSA_RSA = "1.2.840.113549.1.1.1"
  303.             byte[] SeqOID = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };
  304.             byte[] x509key;
  305.             byte[] seq = new byte[15];
  306.             int x509size;
  308.             x509key = Convert.FromBase64String(publicKeyString);
  309.             x509size = x509key.Length;
  311.             // ---------  Set up stream to read the asn.1 encoded SubjectPublicKeyInfo blob  ------
  312.             using (MemoryStream mem = new MemoryStream(x509key))
  313.             {
  314.                 using (BinaryReader binr = new BinaryReader(mem))  //wrap Memory Stream with BinaryReader for easy reading
  315.                 {
  316.                     byte bt = 0;
  317.                     ushort twobytes = 0;
  319.                     twobytes = binr.ReadUInt16();
  320.                     if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
  321.                         binr.ReadByte();    //advance 1 byte
  322.                     else if (twobytes == 0x8230)
  323.                         binr.ReadInt16();   //advance 2 bytes
  324.                     else
  325.                         return null;
  327.                     seq = binr.ReadBytes(15);       //read the Sequence OID
  328.                     if (!CompareBytearrays(seq, SeqOID))    //make sure Sequence for OID is correct
  329.                         return null;
  331.                     twobytes = binr.ReadUInt16();
  332.                     if (twobytes == 0x8103) //data read as little endian order (actual data order for Bit String is 03 81)
  333.                         binr.ReadByte();    //advance 1 byte
  334.                     else if (twobytes == 0x8203)
  335.                         binr.ReadInt16();   //advance 2 bytes
  336.                     else
  337.                         return null;
  339.                     bt = binr.ReadByte();
  340.                     if (bt != 0x00)     //expect null byte next
  341.                         return null;
  343.                     twobytes = binr.ReadUInt16();
  344.                     if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
  345.                         binr.ReadByte();    //advance 1 byte
  346.                     else if (twobytes == 0x8230)
  347.                         binr.ReadInt16();   //advance 2 bytes
  348.                     else
  349.                         return null;
  351.                     twobytes = binr.ReadUInt16();
  352.                     byte lowbyte = 0x00;
  353.                     byte highbyte = 0x00;
  355.                     if (twobytes == 0x8102) //data read as little endian order (actual data order for Integer is 02 81)
  356.                         lowbyte = binr.ReadByte();  // read next bytes which is bytes in modulus
  357.                     else if (twobytes == 0x8202)
  358.                     {
  359.                         highbyte = binr.ReadByte(); //advance 2 bytes
  360.                         lowbyte = binr.ReadByte();
  361.                     }
  362.                     else
  363.                         return null;
  364.                     byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };   //reverse byte order since asn.1 key uses big endian order
  365.                     int modsize = BitConverter.ToInt32(modint, 0);
  367.                     int firstbyte = binr.PeekChar();
  368.                     if (firstbyte == 0x00)
  369.                     {   //if first byte (highest order) of modulus is zero, don't include it
  370.                         binr.ReadByte();    //skip this null byte
  371.                         modsize -= 1;   //reduce modulus buffer size by 1
  372.                     }
  374.                     byte[] modulus = binr.ReadBytes(modsize);   //读取模量字节
  376.                     if (binr.ReadByte() != 0x02)            //期望指数数据为Integer
  377.                         return null;
  378.                     int expbytes = (int)binr.ReadByte();        // should only need one byte for actual exponent data (for all useful values)
  379.                     byte[] exponent = binr.ReadBytes(expbytes);
  381.                     // ------- create RSACryptoServiceProvider instance and initialize with public key -----
  382.                     RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
  383.                     RSAParameters RSAKeyInfo = new RSAParameters();
  384.                     RSAKeyInfo.Modulus = modulus;
  385.                     RSAKeyInfo.Exponent = exponent;
  386.                     RSA.ImportParameters(RSAKeyInfo);
  387.                     return RSA;
  388.                 }
  389.             }
  390.         }
  392.         /// <summary>
  393.         /// 比较字节数组
  394.         /// </summary>
  395.         /// <param name="a"></param>
  396.         /// <param name="b"></param>
  397.         /// <returns></returns>
  398.         private bool CompareBytearrays(byte[] a, byte[] b)
  399.         {
  400.             if (a.Length != b.Length)
  401.             {
  402.                 return false;
  403.             }
  404.             int i = 0;
  405.             foreach (byte c in a)
  406.             {
  407.                 if (c != b[i])
  408.                 {
  409.                     return false;
  410.                 }
  411.                 i++;
  412.             }
  413.             return true;
  414.         }
  416.     }
  417. }
复制代码
2.6、.NET 控制器后端代码

2.6.1、视图控制图代码
  1. public IActionResult worddata()
  2. {
  3.     var dataStr = RASKeyConversion.createPulbicKey();
  4.     publicKey = RsaKeyConvert1.PublicKeyXmlToPem(dataStr[1]);
  5.     privateKey = RsaKeyConvert1.PrivateKeyXmlToPkcs1(dataStr[0]);
  6.     ViewBag.publicKey = publicKey;
  7.     ViewBag.privateKey = privateKey;
  8.     return View();
  9. }
复制代码
2.6.2、POST请求接口代码
  1. /// <summary>
  2. /// 解密接口
  3. /// </summary>
  4. /// <param name="pwd"></param>
  5. /// <param name="privateKey">私钥</param>
  6. /// <returns></returns>
  7. [HttpPost]
  8. public IActionResult wordEncrypt(string pwd, string privateKey)
  9. {
  10.     string resPwd = "";
  11.     try
  12.     {
  13.         string privateStr= RsaKeyConvert1.PrivateKeyPkcs1ToXml(privateKey);
  14.         resPwd = RSACrypto.RSADecrypt(pwd,privateStr,"XML");
  15.         return Json(new { code = 200, msg = resPwd });
  16.     }
  17.     catch (Exception ex)
  18.     {
  19.         return Json(new { code = 220, msg = "RSA解密时出现错误！！！" });
  20.     }
  21. }
复制代码
2.7、前端视图页面代码

2.7.1、Html代码
  1. @{
  2.     Layout = null;
  3. }
  5. <!DOCTYPE html>
  7. <html>
  8. <head>
  9.     <meta name="viewport" content="width=device-width" />
  10.     <title>sometext</title>
  11.     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  12.    
  13.    
  14.    
  15.    
  16.     <link href="/lib/layui/dist/css/layui.css" rel="stylesheet" />
  17.     <link href="/lib/bootstrap/dist/css/bootstrap.css" rel="stylesheet" />
  18.    
  19. </head>
  20. <body>
  21.    
  22.         
  23.             
  24.                 脱敏/加密前的内容：
  25.             
  26.             <input type="password"  id="sourctText" placeholder="脱敏/加密前的内容" aria-label="sourctText" aria-describedby="basic-addon1">
  27.         
  28.         <br />
  29.         
  30.             
  31.                 加密后的内容：
  32.             
  33.             <input type="text"  id="encryptText" placeholder="加密后的内容" readonly="readonly" aria-label="encryptText" aria-describedby="basic-addon1">
  34.         
  35.         <input type="hidden" value="@ViewBag.publicKey" id="publicKey" readonly="readonly" />
  36.         <input type="hidden" value="@ViewBag.privateKey" id="privateKey" readonly="readonly" />
  37.         <br />
  38.         
  39.             
  40.                 脱敏/加密后的内容：
  41.             
  42.             <input type="text"  id="resText" placeholder="脱敏/加密后的内容" readonly="readonly" aria-label="resText" aria-describedby="basic-addon1">
  43.         
  45.         
  46.             <button id="submit" type="button" >提交</button>
  47.         
  48.    
  49. </body>
  50. </html>
复制代码
2.7.2、javascript代码

[code][/code]
来源:https://www.cnblogs.com/lucasDC/archive/2023/09/17/17707813.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x

上一篇: .NET Core 实现Excel的导入导出

下一篇: 【C#】【命名空间（namespace）】.NET6.0后支持的顶级语句使用问题

发表于 2023-9-17 13:24:09

举报 回复 使用道具

返回列表 发新帖

Archiver|手机版|小黑屋|翼度科技

Copyright © 2001-2020, Tencent Cloud.　Powered by Discuz! X3.4