同时兼容JS和C#的RSA加密解密算法详解（对web提交的数据加密传输）

2024-12-03 15:26:07

前言

我们在Web应用中往往涉及到敏感的数据，由于HTTP协议以明文的形式与服务器进行交互，因此可以通过截获请求的数据包进行分析来盗取有用的信息。虽然https可以对传输的数据进行加密，但是必须要申请证书（一般都是收费的），成本较高。那么问题来了，如果对web提交的敏感数据进行加密呢？web应用中，前端的数据处理和交互基本上都是靠javascript来完成，后台的逻辑处理可以C#(java)等进行处理。

微软的C#中虽然有RSA算法，但是格式和OpenSSL生成的公钥/私钥文件格式并不兼容。这个也给贯通前后台的RSA加密解密带来了难度。为了兼容OpenSSL生成的公钥/私钥文件格式，贯通javascript和C#的RSA加密解密算法，必须对C#内置的方法进行再度封装。

下面以登录为例，用户在密码框输入密码后，javascript发送ajax请求时，对密码先进行rsa加密后再发送，服务器接收到加密后的密码后，先对其进行解密，然后再验证登录是否成功。

1、为了进行RSA加密解密，首先需要用openssl生成一对公钥和私钥（没有的先下载openssl)：

1）打开openssl.exe文件，输入 genrsa -out openssl_rsa_priv.pem 1024

此命令在openssl.exe同目录下生成openssl_rsa_private_key.pem文件。

2）生成公钥 rsa -in openssl_rsa__private.pem -pubout -out openssl_rsa__public.pem

以上命令会创建如下的文件：

这个文件可以用文本编辑器进行打开，查看内容。

2、用jsencrypt对密码进行加密：

首先需要导入js包文件

<script src="dist/js/jsencrypt.js"></script>

var encrypt = new JSEncrypt();
var pubkey = "-----BEGIN PUBLIC KEY----- \
 MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDAj0dPnBMf3Z4VT1B8Ee6bjKNs \
 hlYj7xvGijAa8RCdmGR7mrtrExnk8mdUlwdcS05gc4SSFOyWJcYtKUHpWn8/pkS0 \
 vgGOl9Bzn0Xt9hiqTb3pZAfykNrMDGZMgJgfD6KTnfzVUAOupvxjcGkcoj6/vV5I \
 eMcx8mT/z3elfsDSjQIDAQAB \
 -----END PUBLIC KEY-----";
encrypt.setPublicKey(pubkey);
var encrypted = encrypt.encrypt($('#txtpwd').val());
//console.log(encrypted);
$.ajax({
 type: "POST",
 url: "http://localhost:24830/services/rsa_pem.ashx",
 data: { "pwd": encrypted },
 dataType: "Json",
 error: function (xhr, status, error) {
  // alert(error);
  $("#txtInfo").text(' 请求服务器失败！');
  $(that).text('登 录');
  $(that).attr('disabled', false);
 },
 success: function (json) {

 if (uid == "admin" && json.data=="000") {
  window.location.href = "index.html";
 }
 else {
  $("#txtInfo").text(' 用户名或者密码错误！');
  $(that).text('登 录');
  $(that).attr('disabled', false);
 }
 }
});

3、后台用C#进行解密

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace CMCloud.SaaS
{
 public class RSACryptoService
 {
 private RSACryptoServiceProvider _privateKeyRsaProvider;
 private RSACryptoServiceProvider _publicKeyRsaProvider;

 /// <summary>
 /// RSA解密
 /// </summary>
 /// <param name="cipherText"></param>
 /// <returns></returns>
 public string Decrypt(string cipherText)
 {
  if (_privateKeyRsaProvider == null)
  {
  throw new Exception("_privateKeyRsaProvider is null");
  }
  return Decrypt2(cipherText);
 }
 /// <summary>
 /// RSA加密
 /// </summary>
 /// <param name="text"></param>
 /// <returns></returns>
 public string Encrypt(string text)
 {
  if (_publicKeyRsaProvider == null)
  {
  throw new Exception("_publicKeyRsaProvider is null");
  }
  return Encrypt2(text);
  //return Convert.ToBase64String(_publicKeyRsaProvider.Encrypt(Encoding.UTF8.GetBytes(text), false));

 }
 private string Encrypt2(string text)
 {

  Byte[] PlaintextData = Encoding.UTF8.GetBytes(text);
  int MaxBlockSize = _publicKeyRsaProvider.KeySize / 8 - 11;//加密块最大长度限制

  if (PlaintextData.Length <= MaxBlockSize)
  {
  return Convert.ToBase64String(_publicKeyRsaProvider.Encrypt(PlaintextData, false));
  }
  else
  {
  using (MemoryStream PlaiStream = new MemoryStream(PlaintextData))
  using (MemoryStream CrypStream = new MemoryStream())
  {
   Byte[] Buffer = new Byte[MaxBlockSize];
   int BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);

   while (BlockSize > 0)
   {
   Byte[] ToEncrypt = new Byte[BlockSize];
   Array.Copy(Buffer, 0, ToEncrypt, 0, BlockSize);

   Byte[] Cryptograph = _publicKeyRsaProvider.Encrypt(ToEncrypt, false);
   CrypStream.Write(Cryptograph, 0, Cryptograph.Length);

   BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);
   }

   return Convert.ToBase64String(CrypStream.ToArray(), Base64FormattingOptions.None);
  }
  }

 }

 private string Decrypt2(string ciphertext)
 {

  Byte[] CiphertextData = Convert.FromBase64String(ciphertext);
  int MaxBlockSize = _privateKeyRsaProvider.KeySize / 8; //解密块最大长度限制

  if (CiphertextData.Length <= MaxBlockSize)
  return System.Text.Encoding.UTF8.GetString(_privateKeyRsaProvider.Decrypt(CiphertextData, false));

  using (MemoryStream CrypStream = new MemoryStream(CiphertextData))
  using (MemoryStream PlaiStream = new MemoryStream())
  {
  Byte[] Buffer = new Byte[MaxBlockSize];
  int BlockSize = CrypStream.Read(Buffer, 0, MaxBlockSize);

  while (BlockSize > 0)
  {
   Byte[] ToDecrypt = new Byte[BlockSize];
   Array.Copy(Buffer, 0, ToDecrypt, 0, BlockSize);

   Byte[] Plaintext = _privateKeyRsaProvider.Decrypt(ToDecrypt, false);
   PlaiStream.Write(Plaintext, 0, Plaintext.Length);

   BlockSize = CrypStream.Read(Buffer, 0, MaxBlockSize);
  }

  return System.Text.Encoding.UTF8.GetString(PlaiStream.ToArray());
  }
 }
 public RSACryptoService(string privateKey, string publicKey = null)
 {
  if (!string.IsNullOrEmpty(privateKey))
  {
  _privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
  }

  if (!string.IsNullOrEmpty(publicKey))
  {
  _publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
  }
 }

 private RSACryptoServiceProvider CreateRsaProviderFromPrivateKey(string privateKey)
 {
  var privateKeyBits = System.Convert.FromBase64String(privateKey);

  var RSA = new RSACryptoServiceProvider();
  var RSAparams = new RSAParameters();

  using (BinaryReader binr = new BinaryReader(new MemoryStream(privateKeyBits)))
  {
  byte bt = 0;
  ushort twobytes = 0;
  twobytes = binr.ReadUInt16();
  if (twobytes == 0x8130)
   binr.ReadByte();
  else if (twobytes == 0x8230)
   binr.ReadInt16();
  else
   throw new Exception("Unexpected value read binr.ReadUInt16()");

  twobytes = binr.ReadUInt16();
  if (twobytes != 0x0102)
   throw new Exception("Unexpected version");

  bt = binr.ReadByte();
  if (bt != 0x00)
   throw new Exception("Unexpected value read binr.ReadByte()");

  RSAparams.Modulus = binr.ReadBytes(GetIntegerSize(binr));
  RSAparams.Exponent = binr.ReadBytes(GetIntegerSize(binr));
  RSAparams.D = binr.ReadBytes(GetIntegerSize(binr));
  RSAparams.P = binr.ReadBytes(GetIntegerSize(binr));
  RSAparams.Q = binr.ReadBytes(GetIntegerSize(binr));
  RSAparams.DP = binr.ReadBytes(GetIntegerSize(binr));
  RSAparams.DQ = binr.ReadBytes(GetIntegerSize(binr));
  RSAparams.InverseQ = binr.ReadBytes(GetIntegerSize(binr));
  }

  RSA.ImportParameters(RSAparams);
  return RSA;
 }

 private int GetIntegerSize(BinaryReader binr)
 {
  byte bt = 0;
  byte lowbyte = 0x00;
  byte highbyte = 0x00;
  int count = 0;
  bt = binr.ReadByte();
  if (bt != 0x02)
  return 0;
  bt = binr.ReadByte();

  if (bt == 0x81)
  count = binr.ReadByte();
  else
  if (bt == 0x82)
  {
  highbyte = binr.ReadByte();
  lowbyte = binr.ReadByte();
  byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };
  count = BitConverter.ToInt32(modint, 0);
  }
  else
  {
  count = bt;
  }

  while (binr.ReadByte() == 0x00)
  {
  count -= 1;
  }
  binr.BaseStream.Seek(-1, SeekOrigin.Current);
  return count;
 }

 private RSACryptoServiceProvider CreateRsaProviderFromPublicKey(string publicKeyString)
 {
  // encoded OID sequence for PKCS #1 rsaEncryption szOID_RSA_RSA = "1.2.840.113549.1.1.1"
  byte[] SeqOID = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };
  byte[] x509key;
  byte[] seq = new byte[15];
  int x509size;

  x509key = Convert.FromBase64String(publicKeyString);
  x509size = x509key.Length;

  // --------- Set up stream to read the asn.1 encoded SubjectPublicKeyInfo blob ------
  using (MemoryStream mem = new MemoryStream(x509key))
  {
  using (BinaryReader binr = new BinaryReader(mem)) //wrap Memory Stream with BinaryReader for easy reading
  {
   byte bt = 0;
   ushort twobytes = 0;

   twobytes = binr.ReadUInt16();
   if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
   binr.ReadByte(); //advance 1 byte
   else if (twobytes == 0x8230)
   binr.ReadInt16(); //advance 2 bytes
   else
   return null;

   seq = binr.ReadBytes(15); //read the Sequence OID
   if (!CompareBytearrays(seq, SeqOID)) //make sure Sequence for OID is correct
   return null;

   twobytes = binr.ReadUInt16();
   if (twobytes == 0x8103) //data read as little endian order (actual data order for Bit String is 03 81)
   binr.ReadByte(); //advance 1 byte
   else if (twobytes == 0x8203)
   binr.ReadInt16(); //advance 2 bytes
   else
   return null;

   bt = binr.ReadByte();
   if (bt != 0x00) //expect null byte next
   return null;

   twobytes = binr.ReadUInt16();
   if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
   binr.ReadByte(); //advance 1 byte
   else if (twobytes == 0x8230)
   binr.ReadInt16(); //advance 2 bytes
   else
   return null;

   twobytes = binr.ReadUInt16();
   byte lowbyte = 0x00;
   byte highbyte = 0x00;

   if (twobytes == 0x8102) //data read as little endian order (actual data order for Integer is 02 81)
   lowbyte = binr.ReadByte(); // read next bytes which is bytes in modulus
   else if (twobytes == 0x8202)
   {
   highbyte = binr.ReadByte(); //advance 2 bytes
   lowbyte = binr.ReadByte();
   }
   else
   return null;
   byte[] modint = { lowbyte, highbyte, 0x00, 0x00 }; //reverse byte order since asn.1 key uses big endian order
   int modsize = BitConverter.ToInt32(modint, 0);

   int firstbyte = binr.PeekChar();
   if (firstbyte == 0x00)
   { //if first byte (highest order) of modulus is zero, don't include it
   binr.ReadByte(); //skip this null byte
   modsize -= 1; //reduce modulus buffer size by 1
   }

   byte[] modulus = binr.ReadBytes(modsize); //read the modulus bytes

   if (binr.ReadByte() != 0x02)  //expect an Integer for the exponent data
   return null;
   int expbytes = (int)binr.ReadByte(); // should only need one byte for actual exponent data (for all useful values)
   byte[] exponent = binr.ReadBytes(expbytes);

   // ------- create RSACryptoServiceProvider instance and initialize with public key -----
   RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
   RSAParameters RSAKeyInfo = new RSAParameters();
   RSAKeyInfo.Modulus = modulus;
   RSAKeyInfo.Exponent = exponent;
   RSA.ImportParameters(RSAKeyInfo);

   return RSA;
  }

  }
 }

 private bool CompareBytearrays(byte[] a, byte[] b)
 {
  if (a.Length != b.Length)
  return false;
  int i = 0;
  foreach (byte c in a)
  {
  if (c != b[i])
   return false;
  i++;
  }
  return true;
 }
 }
}

虽然将公钥暴露在js文件中，但是如果需要解密得到明文，必须需要私钥（这个存储在后台，不容易获取）。

调试运行，可以看到获取的密码是加密后的数据，然后在后台可以进行解密获取到明文。

总结

好了，大概就这样，以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对我们的支持

C#的3DES加密解密算法实例代码

C#类如下: 复制代码代码如下: using System;using System.Collections.Generic;using System.Text;using System.Security.Cryptography;using System.IO; namespace ConsoleApplication1{ /// <summary> /// 加解密类 /// </summary> public class EncryptHelper
C#加密算法汇总(推荐)

方法一: 复制代码代码如下: //须添加对System.Web的引用 using System.Web.Security; ... /// <summary> /// SHA1加密字符串 /// </summary> /// <param name="source">源字符串</param> /// <returns>加密后的字符串</returns> public string SHA1(string sour
c# rsa注册实现加密文字

复制代码代码如下: RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); private void btencoding_Click(object sender, EventArgs e){ if (mbox.Text == "") { MessageBox.Show("加密文字信息不能为空!"); return; } if (publick
基于私钥加密公钥解密的RSA算法C#实现方法

本文实例讲述了基于私钥加密公钥解密的RSA算法C#实现方法,是一种应用十分广泛的算法.分享给大家供大家参考之用.具体方法如下: 一.概述 RSA算法是第一个能同时用于加密和数字签名的算法,也易于理解和操作. RSA是被研究得最广泛的公钥算法,从提出到现在已近二十年,经历了各种攻击的考验,逐渐为人们接受,普遍认为是目前最优秀的公钥方案之一.RSA的安全性依赖于大数的因子分解,但并没有从理论上证明破译RSA的难度与大数分解难度等价. RSA的安全性依赖于大数分解.公钥和私钥都是两个大素数( 大于 1
C#实现简单的RSA非对称加密算法示例

本文实例讲述了C#实现简单的RSA非对称加密算法.分享给大家供大家参考,具体如下: 界面控件 namespace RSA算法 { partial class Form1 { /// <summary> /// 必需的设计器变量. /// </summary> private System.ComponentModel.IContainer components = null; /// <summary> /// 清理所有正在使用的资源. /// </summary
C# DES加密算法中向量的作用详细解析

DES一共就有4个参数参与运作:明文.密文.密钥.向量.为了初学者容易理解,可以把4个参数的关系写成:密文=明文+密钥+向量:明文=密文-密钥-向量.为什么要向量这个参数呢?因为如果有一篇文章,有几个词重复,那么这个词加上密钥形成的密文,仍然会重复,这给破解者有机可乘,破解者可以根据重复的内容,猜出是什么词,然而一旦猜对这个词,那么,他就能算出密钥,整篇文章就被破解了!加上向量这个参数以后,每块文字段都会依次加上一段值,这样,即使相同的文字,加密出来的密文,也是不一样的,算法的安全性大大提高!
c# 实现MD5,SHA1,SHA256,SHA512等常用加密算法源代码

复制代码代码如下: using System; using System.IO; using System.Data; using System.Text; using System.Diagnostics; using System.Security; using System.Security.Cryptography; /**//* * .Net框架由于拥有CLR提供的丰富库支持,只需很少的代码即可实现先前使用C等旧式语言很难实现的加密算法.本类实现一些常用机密算法,供参考.其中MD5算
C#自定义RSA加密解密及RSA签名和验证类实例

本文实例讲述了C#自定义RSA加密解密及RSA签名和验证类.分享给大家供大家参考.具体分析如下: 这个C#类自定义RSA加密解密及RSA签名和验证,包含了RSA加密.解密及签名所需的相关函数,带有详细的注释说明. using System; using System.Text; using System.Security.Cryptography; namespace DotNet.Utilities { /// <summary> /// RSA加密解密及RSA签名和验证 /// </
jQuery+C#实现参数RSA加密传输功能【附jsencrypt.js下载】

本文实例讲述了jQuery+C#实现参数RSA加密传输功能.分享给大家供大家参考,具体如下: 注意: 参数传递的+号处理,在传输时会把+变成空格,不处理后端就报错了. 1.前端代码 <!DOCTYPE html> <html> <head> <meta name="viewport" content="width=device-width" /> <title>Login</title> <
同时兼容JS和C#的RSA加密解密算法详解（对web提交的数据加密传输）

前言我们在Web应用中往往涉及到敏感的数据,由于HTTP协议以明文的形式与服务器进行交互,因此可以通过截获请求的数据包进行分析来盗取有用的信息.虽然https可以对传输的数据进行加密,但是必须要申请证书(一般都是收费的),成本较高.那么问题来了,如果对web提交的敏感数据进行加密呢?web应用中,前端的数据处理和交互基本上都是靠javascript来完成,后台的逻辑处理可以C#(java)等进行处理. 微软的C#中虽然有RSA算法,但是格式和OpenSSL生成的公钥/私钥文件格式并不兼容.这个
php rsa加密解密使用详解

1.加密解密的第一步是生成公钥.私钥对,私钥加密的内容能通过公钥解密(反过来亦可以) 下载开源RSA密钥生成工具openssl(通常Linux系统都自带该程序),解压缩至独立的文件夹,进入其中的bin目录,执行以下命令: 复制代码代码如下: openssl genrsa -out rsa_private_key.pem 1024 openssl pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform PEM -nocrypt -out
Java实现的RSA加密解密算法示例

本文实例讲述了Java实现的RSA加密解密算法.分享给大家供大家参考,具体如下: import java.awt.AlphaComposite; import java.awt.Color; import java.awt.Font; import java.awt.Graphics2D; import java.awt.Image; import java.awt.RenderingHints; import java.awt.image.BufferedImage; import java.
JS实现的3des+base64加密解密算法完整示例

本文实例讲述了JS实现的3des+base64加密解密算法.分享给大家供大家参考,具体如下: 1. index.html: <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>www.jb51.net BASE64编码</title> <meta http-equiv="Content-Type" content="text/html; c
php的RSA加密解密算法原理与用法分析

本文实例讲述了php的RSA加密解密算法原理与用法.分享给大家供大家参考,具体如下: 最近因为工作的需要,要倒腾支付宝支付相关的知识,因为支付宝应用了RSA加密机制,个人对此并不了解,所以在这里写下一篇总结. 1.生成公钥和私钥要应用RSA算法,必须先生成公钥和私钥,公钥和私钥的生成可以借助openssl工具. 本次测验是在windows下进行的,可以到以下的地址下载windows安装包:http://gnuwin32.sourceforge.net/packages/openssl.htm,
NodeJS加密解密及node-rsa加密解密用法详解

要用nodejs开发接口,实现远程调用,如果裸奔太危险了,就在网上找了一下nodejs的加密,感觉node-rsa挺不错的,下面来总结一下简单的rsa加密解密用法初始化环境新建一个文件夹 node-rsa-demo , 终端进入,运行下面命令初始化 cd node-rsa-demo npm init # 一路回车即可 npm install --save node-rsa 生成公钥私钥在 node-rsa-demo 下新建一个文件 index.js 写上如下代码 var NodeRSA =
python实现RSA加密(解密)算法

RSA是目前最有影响力的公钥加密算法,它能够抵抗到目前为止已知的绝大多数密码攻击,已被ISO推荐为公钥数据加密标准. 今天只有短的RSA钥匙才可能被强力方式解破.到2008年为止,世界上还没有任何可靠的攻击RSA算法的方式.只要其密钥的长度足够长,用RSA加密的信息实际上是不能被解破的.但在分布式计算和量子计算机理论日趋成熟的今天,RSA加密安全性受到了挑战. RSA算法基于一个十分简单的数论事实:将两个大素数相乘十分容易,但是想要对其乘积进行因式分解却极其困难,因此可以将乘积公开作为加密密钥.
Java中常用加密/解密方法详解

安全问题已经成为一个越来越重要的问题,在Java中如何对重要数据进行加密解密是本文的主要内容. 一.常用的加密/解密算法 1.Base64 严格来说Base64并不是一种加密/解密算法,而是一种编码方式.Base64不生成密钥,通过Base64编码后的密文就可以直接"翻译"为明文,但是可以通过向明文中添加混淆字符来达到加密的效果. 2.DES DES是一种基于56位密钥的对称算法,1976年被美国联邦政府的国家标准局确定为联邦资料处理标准(FIPS),随后在国际上广泛流传开来.现在DE
Python使用Pycrypto库进行RSA加密的方法详解

密码与通信密码技术是一门历史悠久的技术.信息传播离不开加密与解密.密码技术的用途主要源于两个方面,加密/解密和签名/验签在信息传播中,通常有发送者,接受者和窃听者三个角色.假设发送者Master想要写信给接受者Ghost,可是又不想信的内容被别人看到,因此Master需要先对信加密,而Ghost收到信之后又能解密.这样别的人即使窃听盗取了密文也无法解密.其次,如果窃听者并不像破译内容,而是伪造Master发消息给Ghost,那么Master发消息前就得先对机密内容进行签名. 密码技术为了进
PHP rsa加密解密算法原理解析

php服务端与客户端交互.提供开放api时,通常需要对敏感的部分api数据传输进行数据加密,这时候rsa非对称加密就能派上用处了,下面通过一个例子来说明如何用php来实现数据的加密解密 1.加密解密的第一步是生成公钥.私钥对,私钥加密的内容能通过公钥解密(反过来亦可以) 下载开源RSA密钥生成工具openssl(通常Linux系统都自带该程序),解压缩至独立的文件夹,进入其中的bin目录,执行以下命令: openssl genrsa -out rsa_private_key.pem 1024 o

同时兼容JS和C#的RSA加密解密算法详解（对web提交的数据加密传输）

相关推荐

随机推荐