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

Posted 2023-03-15

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

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

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

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

步骤：

服务端的RSA  Java实现：

/** 
 *  
 */  
package com.sunsoft.struts.util;  
  
import java.io.ByteArrayOutputStream;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
import java.math.BigInteger;  
import java.security.KeyFactory;  
import java.security.KeyPair;  
import java.security.KeyPairGenerator;  
import java.security.NoSuchAlgorithmException;  
import java.security.PrivateKey;  
import java.security.PublicKey;  
import java.security.SecureRandom;  
import java.security.interfaces.RSAPrivateKey;  
import java.security.interfaces.RSAPublicKey;  
import java.security.spec.InvalidKeySpecException;  
import java.security.spec.RSAPrivateKeySpec;  
import java.security.spec.RSAPublicKeySpec;  
  
import javax.crypto.Cipher;  
  
  
  
/** 
 * RSA 工具类。提供加密，解密，生成密钥对等方法。 
 * 需要到
下载bcprov-jdk14-123.jar。 
 *  
 */  
public class RSAUtil   
    /** 
     * * 生成密钥对 * 
     *  
     * @return KeyPair * 
     * @throws EncryptException 
     */  
    public static KeyPair generateKeyPair() throws Exception   
        try   
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA",  
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());  
            final int KEY_SIZE = 1024;// 没什么好说的了，这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低  
            keyPairGen.initialize(KEY_SIZE, new SecureRandom());  
            KeyPair keyPair = keyPairGen.generateKeyPair();  
            saveKeyPair(keyPair);  
            return keyPair;  
         catch (Exception e)   
            throw new Exception(e.getMessage());  
          
      
      
    public static KeyPair getKeyPair()throws Exception  
        FileInputStream fis = new FileInputStream("C:/RSAKey.txt");  
         ObjectInputStream oos = new ObjectInputStream(fis);  
         KeyPair kp= (KeyPair) oos.readObject();  
         oos.close();  
         fis.close();  
         return kp;  
      
      
    public static void saveKeyPair(KeyPair kp)throws Exception  
          
         FileOutputStream fos = new FileOutputStream("C:/RSAKey.txt");  
         ObjectOutputStream oos = new ObjectOutputStream(fos);  
         //生成密钥  
         oos.writeObject(kp);  
         oos.close();  
         fos.close();  
      
  
    /** 
     * * 生成公钥 * 
     *  
     * @param modulus * 
     * @param publicExponent * 
     * @return RSAPublicKey * 
     * @throws Exception 
     */  
    public static RSAPublicKey generateRSAPublicKey(byte[] modulus,  
            byte[] publicExponent) throws Exception   
        KeyFactory keyFac = null;  
        try   
            keyFac = KeyFactory.getInstance("RSA",  
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());  
         catch (NoSuchAlgorithmException ex)   
            throw new Exception(ex.getMessage());  
          
  
        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(  
                modulus), new BigInteger(publicExponent));  
        try   
            return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);  
         catch (InvalidKeySpecException ex)   
            throw new Exception(ex.getMessage());  
          
      
  
    /** 
     * * 生成私钥 * 
     *  
     * @param modulus * 
     * @param privateExponent * 
     * @return RSAPrivateKey * 
     * @throws Exception 
     */  
    public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus,  
            byte[] privateExponent) throws Exception   
        KeyFactory keyFac = null;  
        try   
            keyFac = KeyFactory.getInstance("RSA",  
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());  
         catch (NoSuchAlgorithmException ex)   
            throw new Exception(ex.getMessage());  
          
  
        RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(  
                modulus), new BigInteger(privateExponent));  
        try   
            return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);  
         catch (InvalidKeySpecException ex)   
            throw new Exception(ex.getMessage());  
          
      
  
    /** 
     * * 加密 * 
     *  
     * @param key 
     *            加密的密钥 * 
     * @param data 
     *            待加密的明文数据 * 
     * @return 加密后的数据 * 
     * @throws Exception 
     */  
    public static byte[] encrypt(PublicKey pk, byte[] data) throws Exception   
        try   
            Cipher cipher = Cipher.getInstance("RSA",  
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());  
            cipher.init(Cipher.ENCRYPT_MODE, pk);  
            int blockSize = cipher.getBlockSize();// 获得加密块大小，如：加密前数据为128个byte，而key_size=1024  
            // 加密块大小为127  
            // byte,加密后为128个byte;因此共有2个加密块，第一个127  
            // byte第二个为1个byte  
            int outputSize = cipher.getOutputSize(data.length);// 获得加密块加密后块大小  
            int leavedSize = data.length % blockSize;  
            int blocksSize = leavedSize != 0 ? data.length / blockSize + 1  
                    : data.length / blockSize;  
            byte[] raw = new byte[outputSize * blocksSize];  
            int i = 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++;  
              
            return raw;  
         catch (Exception e)   
            throw new Exception(e.getMessage());  
          
      
  
    /** 
     * * 解密 * 
     *  
     * @param key 
     *            解密的密钥 * 
     * @param raw 
     *            已经加密的数据 * 
     * @return 解密后的明文 * 
     * @throws Exception 
     */  
    public static byte[] decrypt(PrivateKey pk, byte[] raw) throws Exception   
        try   
            Cipher cipher = Cipher.getInstance("RSA",  
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());  
            cipher.init(cipher.DECRYPT_MODE, pk);  
            int blockSize = cipher.getBlockSize();  
            ByteArrayOutputStream bout = new ByteArrayOutputStream(64);  
            int j = 0;  
  
            while (raw.length - j * blockSize > 0)   
                bout.write(cipher.doFinal(raw, j * blockSize, blockSize));  
                j++;  
              
            return bout.toByteArray();  
         catch (Exception e)   
            throw new Exception(e.getMessage());  
          
      
  
    /** 
     * * * 
     *  
     * @param args * 
     * @throws Exception 
     */  
    public static void main(String[] args) throws Exception   
        RSAPublicKey rsap = (RSAPublicKey) RSAUtil.generateKeyPair().getPublic();  
        String test = "hello world";  
        byte[] en_test = encrypt(getKeyPair().getPublic(),test.getBytes());  
        byte[] de_test = decrypt(getKeyPair().getPrivate(),en_test);  
        System.out.println(new String(de_test));  
      


测试页面IndexAction.java：

/* 
 * Generated by MyEclipse Struts 
 * Template path: templates/java/JavaClass.vtl 
 */  
package com.sunsoft.struts.action;  
  
import java.security.interfaces.RSAPrivateKey;  
import java.security.interfaces.RSAPublicKey;  
  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
  
import org.apache.struts.action.Action;  
import org.apache.struts.action.ActionForm;  
import org.apache.struts.action.ActionForward;  
import org.apache.struts.action.ActionMapping;  
  
import com.sunsoft.struts.util.RSAUtil;  
  
/**  
 * MyEclipse Struts 
 * Creation date: 06-28-2008 
 *  
 * XDoclet definition: 
 * @struts.action validate="true" 
 */  
public class IndexAction extends Action   
    /* 
     * Generated Methods 
     */  
  
    /**  
     * Method execute 
     * @param mapping 
     * @param form 
     * @param request 
     * @param response 
     * @return ActionForward 
     */  
    public ActionForward execute(ActionMapping mapping, ActionForm form,  
            HttpServletRequest request, HttpServletResponse response)throws Exception   
          
        RSAPublicKey rsap = (RSAPublicKey) RSAUtil.getKeyPair().getPublic();  
        String module = rsap.getModulus().toString(16);  
        String empoent = rsap.getPublicExponent().toString(16);  
        System.out.println("module");  
        System.out.println(module);  
        System.out.println("empoent");  
        System.out.println(empoent);  
        request.setAttribute("m", module);  
        request.setAttribute("e", empoent);  
        return mapping.findForward("login");  
      


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

参考技术A 用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;
参考技术B 用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;

本回答由电脑网络分类达人 饶烽推荐
评论
0 0

育知同创教育 | 【0元入学，两周免费试听】
主营：培训【Java大数据，html5，VR，安卓】
给TA留言
其他回答

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;