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

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

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

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

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

       4。将此两段密文传入服务端，服务端用私钥解出随机字符串，再用此私钥解出加密的密文。

       è¿™å…¶ä¸­æœ‰ä¸€ä¸ªå…³é”®æ˜¯è§£å†³æœåŠ¡ç«¯çš„公钥，传入客户端，客户端用此公钥加密字符串后，后又能在服务端用私钥解出。

       æ­¤æ–‡å³ä¸ºå®žçŽ°æ­¤æ­¥è€Œä½œã€‚

       åŠ å¯†ç®—法为RSA：

       1。服务端的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 å·¥å…·ç±»ã€‚提供加密，解密，生成密钥对等方法。 

        * éœ€è¦åˆ°http://www.bouncycastle.org下载bcprov-jdk-.jar。 

        *  

        */  

       public class RSAUtil {   

           /** 

            * * ç”Ÿæˆå¯†é’¥å¯¹ * 

            *  

            * @return KeyPair * 

            * @throws EncryptException 

            */  

           public static KeyPair generateKeyPair() throws Exception {   

               try {   

                   KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA",源码svn建的源码库怎么删除  

                           new org.bouncycastle.jce.provider.BouncyCastleProvider());  

                   final int KEY_SIZE = ;// æ²¡ä»€ä¹ˆå¥½è¯´çš„了，这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低  

                   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();// èŽ·å¾—加密块大小，如：加密前数据为个byte，而key_size=  

                   // åŠ å¯†å—大小为  

                   // byte,加密后为个byte;因此共有2个加密块，第一个  

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

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

           }  

       }

        2.测试页面：

       IndexAction.java