兼容javascript和C#的RSA加密解密算法，对web提交的数据进行加密传输

　　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 /  - ;//加密块最大长度限制

             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, , MaxBlockSize);

                     while (BlockSize > )

                     {

                         Byte[] ToEncrypt = new Byte[BlockSize];

                         Array.Copy(Buffer, , ToEncrypt, , BlockSize);

                         Byte[] Cryptograph = _publicKeyRsaProvider.Encrypt(ToEncrypt, false);

                         CrypStream.Write(Cryptograph, , Cryptograph.Length);

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

                     }

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

                 }

             }

         }

         private string Decrypt2(string ciphertext)

         {

             Byte[] CiphertextData = Convert.FromBase64String(ciphertext);

             int MaxBlockSize = _privateKeyRsaProvider.KeySize / ;    //解密块最大长度限制

             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, , MaxBlockSize);

                 while (BlockSize > )

                 {

                     Byte[] ToDecrypt = new Byte[BlockSize];

                     Array.Copy(Buffer, , ToDecrypt, , BlockSize);

                     Byte[] Plaintext = _privateKeyRsaProvider.Decrypt(ToDecrypt, false);

                     PlaiStream.Write(Plaintext, , Plaintext.Length);

                     BlockSize = CrypStream.Read(Buffer, , 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 = ;

                 ushort twobytes = ;

                 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 = ;

             byte lowbyte = 0x00;

             byte highbyte = 0x00;

             int count = ;

             bt = binr.ReadByte();

             if (bt != 0x02)

                 return ;

             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, );

             }

             else

             {

                 count = bt;

             }

             while (binr.ReadByte() == 0x00)

             {

                 count -= ;

             }

             binr.BaseStream.Seek(-, 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[];

             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 = ;

                     ushort twobytes = ;

                     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();       //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, );

                     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 -= ;   //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 = ;

             foreach (byte c in a)

             {

                 if (c != b[i])

                     return false;

                 i++;

             }

             return true;

         }

     }

 }

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

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

兼容javascript和C#的RSA加密解密算法，对web提交的数据进行加密传输的更多相关文章

介绍三种PHP加密解密算法
PHP加密解密算法这里主要介绍三种常用的加密解密算法:方法一: /** * @param $string 要加密/解密的字符串 * @param string $operation 类型,ENCOD ...
RSA加密解密算法
/** * RSA加密解密算法 * Class Rsa */ class Rsa { /** * 获取pem格式的公钥 * @param $public_key 公钥文件路径或者字符串 * @retu ...
数据的加密传输——单片机上实现TEA加密解密算法
各位大侠在做数据传输时,有没有考虑过把数据加密起来进行传输,若在串口或者无线中把所要传的数据加密起来,岂不是增加了通信的安全性.常用的加密解密算法比如DES.RSA等,受限于单片机的内存和运算速度,实 ...
JAVA常用加密解密算法Encryption and decryption
加密,是以某种特殊的算法改变原有的信息数据,使得未授权的用户即使获得了已加密的信息,但因不知解密的方法,仍然无法了解信息的内容.大体上分为双向加密和单向加密,而双向加密又分为对称加密和非对称加密(有些 ...
一组PHP可逆加密解密算法
对于大部分密码加密,我们可以采用md5.sha1等方法.可以有效防止数据泄露,但是这些方法仅适用于无需还原的数据加密. 对于需要还原的信息,则需要采用可逆的加密解密算法. 下面一组PHP函数是实现此加 ...
RC4加密解密算法
RC4相对是速度快.安全性高的加密算法.在实际应用中,我们可以对安全系数要求高的文本进行多重加密,这样破解就有一定困难了.如下测试给出了先用RC4加密,然后再次用BASE64编码,这样双重锁定,保证数 ...
java 实现 DES加密解密算法
DES算法的入口参数有三个:Key.Data.Mode.其中Key为8个字节共64位,是DES算法的工作密钥:Data也为8个字节64位,是要被加密或被解密的数据:Mode为DES的工作方式,有两种: ...
md5加密以及可逆的加密解密算法
md5加密 package gov.mof.fasp2.gcfr.adjustoffset.adjust; import java.security.MessageDigest; public cla ...
N个整数（数的大小为0-255）的序列，把它们加密为K个整数（数的大小为0-255）.再将K个整数顺序随机打乱，使得可以从这乱序的K个整数中解码出原序列。设计加密解密算法,且要求K<=15*N.
N个整数(数的大小为0-255)的序列,把它们加密为K个整数(数的大小为0-255).再将K个整数顺序随机打乱,使得可以从这乱序的K个整数中解码出原序列.设计加密解密算法,且要求K<=15*N. ...

随机推荐

SAP自定义权限对象
SAP系统自带了很多的权限对象,每一个运行画面都有非常多的权限用到.不过标准的权限对象并不一定适合于用在客户自己开发的程序里面,所以每个ABAPer都应该会自己开发一套权限对象,并引用在程序代码里面. ...
Vue.js——60分钟browserify项目模板快速入门
概述在之前的一系列vue.js文章,我们都是用传统模式引用vue.js以及其他的js文件的,这在开发时会产生一些问题. 首先,这限定了我们的开发模式是基于页面的,而不是基于组件的,组件的所有代码都直 ...
全面解析ASP.NET MVC模块化架构方案
什么叫架构?揭开架构神秘的面纱,无非就是:分层+模块化.任意复杂的架构,你也会发现架构师也就做了这两件事. 本文将会全面的介绍我们团队在模块化设计方面取得的经验.之所以加了“全面”二字,是因为本文的内 ...
Ubuntu部署python3.5的开发和运行环境
Ubuntu部署python3.5的开发和运行环境 1 概述由于最近项目全部由python2.x转向 python3.x(使用目前最新的 python3.5.1) ,之前的云主机的的默认python ...
ABP(现代ASP.NET样板开发框架)系列之7、ABP Session管理
点这里进入ABP系列文章总目录基于DDD的现代ASP.NET开发框架--ABP系列之7.ABP Session管理 ABP是“ASP.NET Boilerplate Project (ASP.NET ...
【PRINCE2是什么】PRINCE2认证之七大原则（6）
我们先来回顾一下,PRINCE2七大原则分别是持续的业务验证,经验学习,角色与责任,按阶段管理,例外管理,关注产品,剪裁第六个原则:关注产品 PRINCE2指出,一个成功的项目必须以产品为导向,而不 ...
JSON.stringify()与JSON.parse()
JSON.stringify()用于把一个对象解析成字符串,如 var student = { age: 23, name: 'wang' } JSON.stringify(student); 结果: ...
css实现文本溢出显示...
在网页中显示文字内容时,经常会碰到文字内容特别长的情况,那么这个时候为了使网页看起来比较美观和简洁,会对内容进行处理.下面我们就来看一看,如何使用css来对文字溢出部分增加.... 首先来看第一种情况 ...
.NetCore之EF跳过的坑
我在网上看到很多.netCore的信息,就动手自己写一个例子测试哈,但是想不到其中这么多坑: 1.首先.netCore和EF的安装就不用多说了,网上有很多的讲解可以跟着一步一步的下载和安装,但是需要注 ...
设置MYSQL允许用IP访问
mysql>use mysql; mysql>update user set host = '%' where user ='root'; mysql>flush privileg ...

兼容javascript和C#的RSA加密解密算法，对web提交的数据进行加密传输

兼容javascript和C#的RSA加密解密算法，对web提交的数据进行加密传输的更多相关文章

随机推荐

热门专题