js使用rsa加密

A. 如何实现用javascript实现rsa加解密

1. 获取公钥串
   

var encryptionJs = {

//公钥串
public_key :
'',
//公钥长度
public_length : "10001",




/**
* 加密串
× str 加密变量
* @Return bool
*/

edai_encryption:function(str){
var rsa = new RSAKey();
rsa.setPublic(encryptionJs.public_key, encryptionJs.public_length);
var res = rsa.encrypt(str);

return res;
},
/**
* 加密
*/
form_encryption:function(formDataStr){
/*datas=formDataStr.split("&");
var real_name='';
var postStr = '';
$.each(datas,function(i,v){
var vv=v.split("=");
if(vv[0]=='real_name'){
real_name = 'real_name='+encryptionJs.edai_encryption(vv[1]);
}else{
if(postStr){
postStr+='&'+vv[0]+'='+(vv[1]?vv[1]:'');
}else{
postStr=vv[0]+'='+(vv[1]?vv[1]:'');
}
}
});

postStr = real_name+'&postData='+encryptionJs.edai_encryption(postStr);*/

datas=formDataStr.split("&");
var postArr = new Array();
$.each(datas,function(i,v){
var vv=v.split("=");
postArr.push(vv[0]+'='+(vv[1]?encryptionJs.edai_encryption(vv[1]):''));
});
postStr = postArr.join('&');
return postStr;
}


}


参考：RSA JS 在这个网页里读取 https://weilicai.yidai.com/Resource/js/rsa.js

B. 用JavaScript实现RSA加密和解密

下面是一个我收藏的函数，用于计算rsa的pow和mod有很高的效率。我不知道是什么算法，但这个函数真的很好用。
function RSAPowMod(txt, key, n) {
var a, b;
if (key % 2 == 0) {
a = 1
for (var i = 1; i <= key / 2; i++) {
b = (txt * txt) % n
a = (b * a) % n
}
} else {
a = txt
for (var i = 1; i <= key / 2; i++) {
b = (txt * txt) % n
a = (b * a) % n
}
}
return a;
}
txt，key，n都可以是字符串，代表着大数，当然，具体大到什么范围我不知道。
大于65535的数我测试过，表示支持不止两字节了，那推测是四字节或者以上。
当我用九位数和十位数的时候，计算效率就不行。中间的，比如七位八位数的，我没有现成的密钥对，测试不了。
把对应的变量名改一改就符合要求了。（其实不用改，直接使用函数也是可以的。）

C. 如何实现用javascript实现rsa加解密

1. 服务端生成公钥与私钥，保存。

2. 客户端在请求到登录页面后，随机生成一字符串。

3. 后此随机字符串作为密钥加密密码，再用从服务端获取到的公钥加密生成的随机字符串

4. 将此两段密文传入服务端，服务端用私钥解出随机字符串，再用此私钥解出加密的密文。这其中有一个关键是解决服务端的公钥，传入客户端，客户端用此公钥加密字符串后，后又能在服务端用私钥解出。

步骤：

1. 服务端的RSAJava实现：

   /**
   *
   */
   packagecom.sunsoft.struts.util;
   
   importjava.io.ByteArrayOutputStream;
   importjava.io.FileInputStream;
   importjava.io.FileOutputStream;
   importjava.io.ObjectInputStream;
   importjava.io.ObjectOutputStream;
   importjava.math.BigInteger;
   importjava.security.KeyFactory;
   importjava.security.KeyPair;
   importjava.security.KeyPairGenerator;
   importjava.security.NoSuchAlgorithmException;
   importjava.security.PrivateKey;
   importjava.security.PublicKey;
   importjava.security.SecureRandom;
   importjava.security.interfaces.RSAPrivateKey;
   importjava.security.interfaces.RSAPublicKey;
   importjava.security.spec.InvalidKeySpecException;
   importjava.security.spec.RSAPrivateKeySpec;
   importjava.security.spec.RSAPublicKeySpec;
   
   importjavax.crypto.Cipher;/**
   *RSA工具类。提供加密，解密，生成密钥对等方法。
   *需要到
   下载bcprov-jdk14-123.jar。
   *
   */
   publicclassRSAUtil{
   /**
   **生成密钥对*
   *
   *@returnKeyPair*
   *@throwsEncryptException
   */
   ()throwsException{
   try{
   KeyPairGeneratorkeyPairGen=KeyPairGenerator.getInstance("RSA",
   neworg.bouncycastle.jce.provider.BouncyCastleProvider());
   finalintKEY_SIZE=1024;//没什么好说的了，这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低
   keyPairGen.initialize(KEY_SIZE,newSecureRandom());
   KeyPairkeyPair=keyPairGen.generateKeyPair();
   saveKeyPair(keyPair);
   returnkeyPair;
   }catch(Exceptione){
   thrownewException(e.getMessage());
   }
   }
   
   publicstaticKeyPairgetKeyPair()throwsException{
   FileInputStreamfis=newFileInputStream("C:/RSAKey.txt");
   ObjectInputStreamoos=newObjectInputStream(fis);
   KeyPairkp=(KeyPair)oos.readObject();
   oos.close();
   fis.close();
   returnkp;
   }
   
   publicstaticvoidsaveKeyPair(KeyPairkp)throwsException{
   
   FileOutputStreamfos=newFileOutputStream("C:/RSAKey.txt");
   ObjectOutputStreamoos=newObjectOutputStream(fos);
   //生成密钥
   oos.writeObject(kp);
   oos.close();
   fos.close();
   }
   
   /**
   **生成公钥*
   *
   *@parammolus*
   *@parampublicExponent*
   *@returnRSAPublicKey*
   *@throwsException
   */
   (byte[]molus,
   byte[]publicExponent)throwsException{
   KeyFactorykeyFac=null;
   try{
   keyFac=KeyFactory.getInstance("RSA",
   neworg.bouncycastle.jce.provider.BouncyCastleProvider());
   }catch(NoSuchAlgorithmExceptionex){
   thrownewException(ex.getMessage());
   }
   
   RSAPublicKeySpecpubKeySpec=newRSAPublicKeySpec(newBigInteger(
   molus),newBigInteger(publicExponent));
   try{
   return(RSAPublicKey)keyFac.generatePublic(pubKeySpec);
   }catch(InvalidKeySpecExceptionex){
   thrownewException(ex.getMessage());
   }
   }
   
   /**
   **生成私钥*
   *
   *@parammolus*
   *@paramprivateExponent*
   *@returnRSAPrivateKey*
   *@throwsException
   */
   (byte[]molus,
   byte[]privateExponent)throwsException{
   KeyFactorykeyFac=null;
   try{
   keyFac=KeyFactory.getInstance("RSA",
   neworg.bouncycastle.jce.provider.BouncyCastleProvider());
   }catch(NoSuchAlgorithmExceptionex){
   thrownewException(ex.getMessage());
   }
   
   RSAPrivateKeySpecpriKeySpec=newRSAPrivateKeySpec(newBigInteger(
   molus),newBigInteger(privateExponent));
   try{
   return(RSAPrivateKey)keyFac.generatePrivate(priKeySpec);
   }catch(InvalidKeySpecExceptionex){
   thrownewException(ex.getMessage());
   }
   }
   
   /**
   **加密*
   *
   *@paramkey
   *加密的密钥*
   *@paramdata
   *待加密的明文数据*
   *@return加密后的数据*
   *@throwsException
   */
   publicstaticbyte[]encrypt(PublicKeypk,byte[]data)throwsException{
   try{
   Ciphercipher=Cipher.getInstance("RSA",
   neworg.bouncycastle.jce.provider.BouncyCastleProvider());
   cipher.init(Cipher.ENCRYPT_MODE,pk);
   intblockSize=cipher.getBlockSize();//获得加密块大小，如：加密前数据为128个byte，而key_size=1024
   //加密块大小为127
   //byte,加密后为128个byte;因此共有2个加密块，第一个127
   //byte第二个为1个byte
   intoutputSize=cipher.getOutputSize(data.length);//获得加密块加密后块大小
   intleavedSize=data.length%blockSize;
   intblocksSize=leavedSize!=0?data.length/blockSize+1
   :data.length/blockSize;
   byte[]raw=newbyte[outputSize*blocksSize];
   inti=0;
   while(data.length-i*blockSize>0){
   if(data.length-i*blockSize>blockSize)
   cipher.doFinal(data,i*blockSize,blockSize,raw,i
   *outputSize);
   else
   cipher.doFinal(data,i*blockSize,data.length-i
   *blockSize,raw,i*outputSize);
   //这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到
   //ByteArrayOutputStream中，而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了
   //OutputSize所以只好用dofinal方法。
   
   i++;
   }
   returnraw;
   }catch(Exceptione){
   thrownewException(e.getMessage());
   }
   }
   
   /**
   **解密*
   *
   *@paramkey
   *解密的密钥*
   *@paramraw
   *已经加密的数据*
   *@return解密后的明文*
   *@throwsException
   */
   publicstaticbyte[]decrypt(PrivateKeypk,byte[]raw)throwsException{
   try{
   Ciphercipher=Cipher.getInstance("RSA",
   neworg.bouncycastle.jce.provider.BouncyCastleProvider());
   cipher.init(cipher.DECRYPT_MODE,pk);
   intblockSize=cipher.getBlockSize();
   ByteArrayOutputStreambout=newByteArrayOutputStream(64);
   intj=0;
   
   while(raw.length-j*blockSize>0){
   bout.write(cipher.doFinal(raw,j*blockSize,blockSize));
   j++;
   }
   returnbout.toByteArray();
   }catch(Exceptione){
   thrownewException(e.getMessage());
   }
   }
   
   /**
   ***
   *
   *@paramargs*
   *@throwsException
   */
   publicstaticvoidmain(String[]args)throwsException{
   RSAPublicKeyrsap=(RSAPublicKey)RSAUtil.generateKeyPair().getPublic();
   Stringtest="helloworld";
   byte[]en_test=encrypt(getKeyPair().getPublic(),test.getBytes());
   byte[]de_test=decrypt(getKeyPair().getPrivate(),en_test);
   System.out.println(newString(de_test));
   }
   }

2. 测试页面IndexAction.java：

   /*
   *GeneratedbyMyEclipseStruts
   *Templatepath:templates/java/JavaClass.vtl
   */
   packagecom.sunsoft.struts.action;
   
   importjava.security.interfaces.RSAPrivateKey;
   importjava.security.interfaces.RSAPublicKey;
   
   importjavax.servlet.http.HttpServletRequest;
   importjavax.servlet.http.HttpServletResponse;
   
   importorg.apache.struts.action.Action;
   importorg.apache.struts.action.ActionForm;
   importorg.apache.struts.action.ActionForward;
   importorg.apache.struts.action.ActionMapping;
   
   importcom.sunsoft.struts.util.RSAUtil;
   
   /**
   *MyEclipseStruts
   *Creationdate:06-28-2008
   *
   *XDocletdefinition:
   *@struts.actionvalidate="true"
   */
   {
   /*
   *GeneratedMethods
   */
   
   /**
   *Methodexecute
   *@parammapping
   *@paramform
   *@paramrequest
   *@paramresponse
   *@returnActionForward
   */
   publicActionForwardexecute(ActionMappingmapping,ActionFormform,
   HttpServletRequestrequest,HttpServletResponseresponse)throwsException{
   
   RSAPublicKeyrsap=(RSAPublicKey)RSAUtil.getKeyPair().getPublic();
   Stringmole=rsap.getMolus().toString(16);
   Stringempoent=rsap.getPublicExponent().toString(16);
   System.out.println("mole");
   System.out.println(mole);
   System.out.println("empoent");
   System.out.println(empoent);
   request.setAttribute("m",mole);
   request.setAttribute("e",empoent);
   returnmapping.findForward("login");
   }
   }

   通过此action进入登录页面，并传入公钥的Molus 与PublicExponent的hex编码形式。

D. 如何实现用javascript实现rsa加解密

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE> New Document </TITLE>
<META NAME="Generator" CONTENT="EditPlus">
<META NAME="Author" CONTENT="">
<META NAME="Keywords" CONTENT="">
<META NAME="Description" CONTENT="">
</HEAD>

<BODY>
<SCRIPT LANGUAGE="JavaScript">
function RSAAlgorithm(){
//1.首先选择两个简单的质数p,q
var p=5
var q=13
var n=p*q
//随机选择余数r,保证r与(p-1)*(q-1)=48互质
var r=7
//得到private key是p,q,r
document.write("----------------------------------<br>");
document.write("<B>Private Key：</B><br>");
document.write("p= "+p+"<br>");
document.write("q= "+q+"<br>");
document.write("r= "+r+"<br>");
document.write("----------------------------------<br>");
//2.计算public key
//找到m,保证rm ==1 mod (p-1)*(q-1)
var num=0
for(a=0;a<500;a++){
if(r*a%((p-1)*(q-1))==1){
num=a;
break;
}
}
var m=num
if(m>0){
document.write("<br>找到m= "+num+" ,计算余数="+(num*r)%((p-1)*(q-1))+",成功！<br>")
}
else{
document.write("找不到满足条件的m,请调整参数");
}
document.write("----------------------------------<br>");
document.write("<B>Public Key：<br></B>");
document.write("m= "+m+"<br>");
document.write("n= "+n+"<br>");
document.write("----------------------------------<br>");
document.write("<br>");
document.write("<B>#演示加密过程#</B><br>");
var text=20 //明文
document.write("明文="+text+"<br>");
//接下来, 计算 etext == text^r mod n, (0 <= b < n)
var etext=Math.pow(text,r)%n;
document.write("加密后的内容:"+etext+"<br>");
document.write("<br>");
document.write("#演示解密过程#<br>");
//text=etext^m mod pq
var text=Math.pow(etext,m)%n;
document.write("解密后的内容:"+text+"<br>");}
</SCRIPT>
</BODY>
</HTML>

E. 如何实现用javascript实现rsa加解密

用javascript实现rsa加解密的实现方式是通过PKCS完成的。
1、整个定义的function

function pkcs1pad2(s,n) {
if(n < s.length + 11) { // TODO: fix for utf-8
alert("Message too long for RSA");
return null;
}
var ba = new Array();
var i = s.length - 1;
while(i >= 0 && n > 0) {
var c = s.charCodeAt(i--);
//UTF-8编码为变长字节,使用实际的字节来记录
if(c < 128) { // encode using utf-8
ba[--n] = c;
}
else if((c > 127) && (c < 2048)) {
ba[--n] = (c & 63) | 128;
ba[--n] = (c >> 6) | 192;
}
else {
ba[--n] = (c & 63) | 128;
ba[--n] = ((c >> 6) & 63) | 128;
ba[--n] = (c >> 12) | 224;
}
}
//实际输入拼装结束,将下一位赋值为0标记结束
ba[--n] = 0;
var rng = new SecureRandom();
var x = new Array();
//拼接随机非0字节
while(n > 2) { // random non-zero pad
x[0] = 0;
while(x[0] == 0) rng.nextBytes(x);
ba[--n] = x[0];
}
//这两位做简单的校验
ba[--n] = 2;
ba[--n] = 0;
return new BigInteger(ba);
}
该方法中对UTF-8字符进行了兼容，并且在拼装完实际输入的字符后，还拼装了随机的字节，使用拼装后的字符串去加密。由于每次拼装的结果是随机的，这样每次加密后的密文都不同。
2、调用方法：；
function RSAEncrypt(text) {
var m = pkcs1pad2(text,(this.n.bitLength()+7)>>3);
if(m == null) return null;
var c = this.doPublic(m);
if(c == null) return null;
var h = c.toString(16);
if((h.length & 1) == 0) return h; else return "0" + h;
}

F. 非vue项目在js里使用jsencrypt

java，thinkPHP等都可以使用jsencrypt.js。
使用jsencrypt.js的目的是实现对数据进行加密传输，因为JSEncrypt属于RSA加密，RSA加密算法是一种非对称加密算法，RSA加密使用了"一对"密钥.分别是公钥和私钥，使用公钥加密的数据,利用私钥进行解密，使用私钥加密的数据，利用公钥进行解密。
在前端项目中使用jsencrypt进行字段加密的使用步骤（以PHP为例）：获取公钥；实例化对象；设置公钥；将所需数据进行加密然后返回。

G. 使用jsencrypt.js进行RSA加密

一个基于RSA加解密的js库

使用公钥结合 jsencrypt 提供的 encrypt 方法(需要加密的内容)进行加密

使用私钥结合 jsencrypt 提供的 decrypt 方法进行解密