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 方法進行解密