关于使用JS前台加密、JAVA后台解密的RSA实现，RSA加密和签名

需求环境：

西安项目中，客户要求保护用户的密码信息，不允许在http中传递明文的密码信息。

实现：

用RSA非对称加密方式实现。后台生成rsa密钥对，然后在登陆页面设置rsa公钥，提交时用公钥加密密码，生成的密文传到后台，用私钥解密，获取密码明文。

这样客户端只需要知道rsa加密方式和公钥，前台不知道私钥是无法解密的，此解决方案还是相对比较安全的。

附件是参照网友资料的Java+JS的实现，放在这里供大家下载。访问方式/RSA/login.jsp。

需要到http://www.bouncycastle.org下载bcprov-jdk14-123.jar文件。

因为后台要转换成bigint，所以对明文长度有些限制：

总长度不超过126（1汉字长度为9），如下两个字符串：

阿送大法散得阿送大法散得阿送
1232132131231231232131232K1232132131231231232131232K1232132131231231232131232K1232132131231231232131232K1234567890123456789012

RSA速度  
 * 由于进行的都是大数计算，使得RSA最快的情况也比DES慢上100倍，无论 是软件还是硬件实现。  
 * 速度一直是RSA的缺陷。一般来说只用于少量数据 加密。

Util.java

1. package RSA;  
2.   
3. /** 
4.  *  
5.  */  
6.   
7. import java.io.ByteArrayOutputStream;  
8. import java.io.FileInputStream;  
9. import java.io.FileOutputStream;  
10. import java.io.ObjectInputStream;  
11. import java.io.ObjectOutputStream;  
12. import java.math.BigInteger;  
13. import java.security.KeyFactory;  
14. import java.security.KeyPair;  
15. import java.security.KeyPairGenerator;  
16. import java.security.NoSuchAlgorithmException;  
17. import java.security.PrivateKey;  
18. import java.security.PublicKey;  
19. import java.security.SecureRandom;  
20. import java.security.interfaces.RSAPrivateKey;  
21. import java.security.interfaces.RSAPublicKey;  
22. import java.security.spec.InvalidKeySpecException;  
23. import java.security.spec.RSAPrivateKeySpec;  
24. import java.security.spec.RSAPublicKeySpec;  
25.   
26. import javax.crypto.Cipher;  
27.   
28. /** 
29.  * RSA 工具类。提供加密，解密，生成密钥对等方法。 
30.  * 需要到http://www.bouncycastle.org下载bcprov-jdk14-123.jar。 
31.  *  
32.  */  
33. public class RSAUtil {  
34.       
35.     private static String RSAKeyStore = "C:/RSAKey.txt";  
36.     /** 
37.      * * 生成密钥对 * 
38.      *  
39.      * @return KeyPair * 
40.      * @throws EncryptException 
41.      */  
42.     public static KeyPair generateKeyPair() throws Exception {  
43.         try {  
44.             KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA",  
45.                     new org.bouncycastle.jce.provider.BouncyCastleProvider());  
46.             final int KEY_SIZE = 1024;// 没什么好说的了，这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低  
47.             keyPairGen.initialize(KEY_SIZE, new SecureRandom());  
48.             KeyPair keyPair = keyPairGen.generateKeyPair();  
49.               
50.             System.out.println(keyPair.getPrivate());  
51.             System.out.println(keyPair.getPublic());  
52.               
53.             saveKeyPair(keyPair);  
54.             return keyPair;  
55.         } catch (Exception e) {  
56.             throw new Exception(e.getMessage());  
57.         }  
58.     }  
59.   
60.     public static KeyPair getKeyPair() throws Exception {  
61.         FileInputStream fis = new FileInputStream(RSAKeyStore);  
62.         ObjectInputStream oos = new ObjectInputStream(fis);  
63.         KeyPair kp = (KeyPair) oos.readObject();  
64.         oos.close();  
65.         fis.close();  
66.         return kp;  
67.     }  
68.   
69.     public static void saveKeyPair(KeyPair kp) throws Exception {  
70.   
71.         FileOutputStream fos = new FileOutputStream(RSAKeyStore);  
72.         ObjectOutputStream oos = new ObjectOutputStream(fos);  
73.         // 生成密钥  
74.         oos.writeObject(kp);  
75.         oos.close();  
76.         fos.close();  
77.     }  
78.   
79.     /** 
80.      * * 生成公钥 * 
81.      *  
82.      * @param modulus * 
83.      * @param publicExponent * 
84.      * @return RSAPublicKey * 
85.      * @throws Exception 
86.      */  
87.     public static RSAPublicKey generateRSAPublicKey(byte[] modulus,  
88.             byte[] publicExponent) throws Exception {  
89.         KeyFactory keyFac = null;  
90.         try {  
91.             keyFac = KeyFactory.getInstance("RSA",  
92.                     new org.bouncycastle.jce.provider.BouncyCastleProvider());  
93.         } catch (NoSuchAlgorithmException ex) {  
94.             throw new Exception(ex.getMessage());  
95.         }  
96.   
97.         RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(  
98.                 modulus), new BigInteger(publicExponent));  
99.         try {  
100.             return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);  
101.         } catch (InvalidKeySpecException ex) {  
102.             throw new Exception(ex.getMessage());  
103.         }  
104.     }  
105.   
106.     /** 
107.      * * 生成私钥 * 
108.      *  
109.      * @param modulus * 
110.      * @param privateExponent * 
111.      * @return RSAPrivateKey * 
112.      * @throws Exception 
113.      */  
114.     public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus,  
115.             byte[] privateExponent) throws Exception {  
116.         KeyFactory keyFac = null;  
117.         try {  
118.             keyFac = KeyFactory.getInstance("RSA",  
119.                     new org.bouncycastle.jce.provider.BouncyCastleProvider());  
120.         } catch (NoSuchAlgorithmException ex) {  
121.             throw new Exception(ex.getMessage());  
122.         }  
123.   
124.         RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(  
125.                 modulus), new BigInteger(privateExponent));  
126.         try {  
127.             return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);  
128.         } catch (InvalidKeySpecException ex) {  
129.             throw new Exception(ex.getMessage());  
130.         }  
131.     }  
132.   
133.     /** 
134.      * * 加密 * 
135.      *  
136.      * @param key 
137.      *            加密的密钥 * 
138.      * @param data 
139.      *            待加密的明文数据 * 
140.      * @return 加密后的数据 * 
141.      * @throws Exception 
142.      */  
143.     public static byte[] encrypt(PublicKey pk, byte[] data) throws Exception {  
144.         try {  
145.             Cipher cipher = Cipher.getInstance("RSA",  
146.                     new org.bouncycastle.jce.provider.BouncyCastleProvider());  
147.             cipher.init(Cipher.ENCRYPT_MODE, pk);