java RSA加密解密实现

该工具类中用到了BASE64，需要借助第三方类库：javabase64-1.3.1.jar

下载地址：http://download.csdn.net/detail/centralperk/5025595

注意：
RSA加密明文最大长度117字节，解密要求密文最大长度为128字节，所以在加密和解密的过程中需要分块进行。
RSA加密对明文的长度是有限制的，如果加密数据过大会抛出如下异常：

[java] view plain copy print ?

1. Exception in thread "main" javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes 
2.     at com.sun.crypto.provider.RSACipher.a(DashoA13*..) 
3.     at com.sun.crypto.provider.RSACipher.engineDoFinal(DashoA13*..) 
4.     at javax.crypto.Cipher.doFinal(DashoA13*..) 

Exception in thread "main" javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes
    at com.sun.crypto.provider.RSACipher.a(DashoA13*..)
    at com.sun.crypto.provider.RSACipher.engineDoFinal(DashoA13*..)
    at javax.crypto.Cipher.doFinal(DashoA13*..)

RSAUtils.java

[java] view plain copy print ?

1. package security; 
2.  
3. import java.io.ByteArrayOutputStream; 
4. import java.security.Key; 
5. import java.security.KeyFactory; 
6. import java.security.KeyPair; 
7. import java.security.KeyPairGenerator; 
8. import java.security.PrivateKey; 
9. import java.security.PublicKey; 
10. import java.security.Signature; 
11. import java.security.interfaces.RSAPrivateKey; 
12. import java.security.interfaces.RSAPublicKey; 
13. import java.security.spec.PKCS8EncodedKeySpec; 
14. import java.security.spec.X509EncodedKeySpec; 
15. import java.util.HashMap; 
16. import java.util.Map; 
17.  
18. import javax.crypto.Cipher; 
19.  
20. /** *//**
21. * <p>
22. * RSA公钥/私钥/签名工具包
23. * </p>
24. * <p>
25. * 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman）
26. * </p>
27. * <p>
28. * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
29. * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>
30. * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全
31. * </p>
32. *
33. * @author IceWee
34. * @date 2012-4-26
35. * @version 1.0
36. */ 
37. public class RSAUtils { 
38.  
39.     /** *//**
40.      * 加密算法RSA
41.      */ 
42.     public static final String KEY_ALGORITHM = "RSA"; 
43.      
44.     /** *//**
45.      * 签名算法
46.      */ 
47.     public static final String SIGNATURE_ALGORITHM = "MD5withRSA"; 
48.  
49.     /** *//**
50.      * 获取公钥的key
51.      */ 
52.     private static final String PUBLIC_KEY = "RSAPublicKey"; 
53.      
54.     /** *//**
55.      * 获取私钥的key
56.      */ 
57.     private static final String PRIVATE_KEY = "RSAPrivateKey"; 
58.      
59.     /** *//**
60.      * RSA最大加密明文大小
61.      */ 
62.     private static final int MAX_ENCRYPT_BLOCK = 117; 
63.      
64.     /** *//**
65.      * RSA最大解密密文大小
66.      */ 
67.     private static final int MAX_DECRYPT_BLOCK = 128; 
68.  
69.     /** *//**
70.      * <p>
71.      * 生成密钥对(公钥和私钥)
72.      * </p>
73.      *
74.      * @return
75.      * @throws Exception
76.      */ 
77.     public static Map<String, Object> genKeyPair() throws Exception { 
78.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM); 
79.         keyPairGen.initialize(1024); 
80.         KeyPair keyPair = keyPairGen.generateKeyPair(); 
81.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); 
82.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); 
83.         Map<String, Object> keyMap = new HashMap<String, Object>(2); 
84.         keyMap.put(PUBLIC_KEY, publicKey); 
85.         keyMap.put(PRIVATE_KEY, privateKey); 
86.         return keyMap; 
87.     } 
88.      
89.     /** *//**
90.      * <p>
91.      * 用私钥对信息生成数字签名
92.      * </p>
93.      *
94.      * @param data 已加密数据
95.      * @param privateKey 私钥(BASE64编码)
96.      *
97.      * @return
98.      * @throws Exception
99.      */ 
100.     public static String sign(byte[] data, String privateKey) throws Exception { 
101.         byte[] keyBytes = Base64Utils.decode(privateKey); 
102.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); 
103.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 
104.         PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec); 
105.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM); 
106.         signature.initSign(privateK); 
107.         signature.update(data); 
108.         return Base64Utils.encode(signature.sign()); 
109.     } 
110.  
111.     /** *//**
112.      * <p>
113.      * 校验数字签名
114.      * </p>
115.      *
116.      * @param data 已加密数据
117.      * @param publicKey 公钥(BASE64编码)
118.      * @param sign 数字签名
119.      *
120.      * @return
121.      * @throws Exception
122.      *
123.      */ 
124.     public static boolean verify(byte[] data, String publicKey, String sign) 
125.             throws Exception { 
126.         byte[] keyBytes = Base64Utils.decode(publicKey); 
127.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes); 
128.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 
129.         PublicKey publicK = keyFactory.generatePublic(keySpec); 
130.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM); 
131.         signature.initVerify(publicK); 
132.         signature.update(data); 
133.         return signature.verify(Base64Utils.decode(sign)); 
134.     } 
135.  
136.     /** *//**
137.      * <P>
138.      * 私钥解密
139.      * </p>
140.      *
141.      * @param encryptedData 已加密数据
142.      * @param privateKey 私钥(BASE64编码)
143.      * @return
144.      * @throws Exception
145.      */ 
146.     public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) 
147.             throws Exception { 
148.         byte[] keyBytes = Base64Utils.decode(privateKey); 
149.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); 
150.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 
151.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec); 
152.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 
153.         cipher.init(Cipher.DECRYPT_MODE, privateK); 
154.         int inputLen = encryptedData.length; 
155.         ByteArrayOutputStream out = new ByteArrayOutputStream(); 
156.         int offSet = 0; 
157.         byte[] cache; 
158.         int i = 0; 
159.         // 对数据分段解密 
160.         while (inputLen - offSet > 0) { 
161.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) { 
162.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK); 
163.             } else { 
164.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet); 
165.             } 
166.             out.write(cache, 0, cache.length); 
167.             i++; 
168.             offSet = i * MAX_DECRYPT_BLOCK; 
169.         } 
170.         byte[] decryptedData = out.toByteArray(); 
171.         out.close(); 
172.         return decryptedData; 
173.     } 
174.  
175.     /** *//**
176.      * <p>
177.      * 公钥解密
178.      * </p>
179.      *
180.      * @param encryptedData 已加密数据
181.      * @param publicKey 公钥(BASE64编码)
182.      * @return
183.      * @throws Exception
184.      */ 
185.     public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) 
186.             throws Exception { 
187.         byte[] keyBytes = Base64Utils.decode(publicKey); 
188.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); 
189.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 
190.         Key publicK = keyFactory.generatePublic(x509KeySpec); 
191.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 
192.         cipher.init(Cipher.DECRYPT_MODE, publicK); 
193.         int inputLen = encryptedData.length; 
194.         ByteArrayOutputStream out = new ByteArrayOutputStream(); 
195.         int offSet = 0; 
196.         byte[] cache; 
197.         int i = 0; 
198.         // 对数据分段解密 
199.         while (inputLen - offSet > 0) { 
200.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) { 
201.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK); 
202.             } else { 
203.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet); 
204.             } 
205.             out.write(cache, 0, cache.length); 
206.             i++; 
207.             offSet = i * MAX_DECRYPT_BLOCK; 
208.         } 
209.         byte[] decryptedData = out.toByteArray(); 
210.         out.close(); 
211.         return decryptedData; 
212.     } 
213.  
214.     /** *//**
215.      * <p>
216.      * 公钥加密
217.      * </p>
218.      *
219.      * @param data 源数据
220.      * @param publicKey 公钥(BASE64编码)
221.      * @return
222.      * @throws Exception
223.      */ 
224.     public static byte[] encryptByPublicKey(byte[] data, String publicKey) 
225.             throws Exception { 
226.         byte[] keyBytes = Base64Utils.decode(publicKey); 
227.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); 
228.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 
229.         Key publicK = keyFactory.generatePublic(x509KeySpec); 
230.         // 对数据加密 
231.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 
232.         cipher.init(Cipher.ENCRYPT_MODE, publicK); 
233.         int inputLen = data.length; 
234.         ByteArrayOutputStream out = new ByteArrayOutputStream(); 
235.         int offSet = 0; 
236.         byte[] cache; 
237.         int i = 0; 
238.         // 对数据分段加密 
239.         while (inputLen - offSet > 0) { 
240.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) { 
241.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK); 
242.             } else { 
243.                 cache = cipher.doFinal(data, offSet, inputLen - offSet); 
244.             } 
245.             out.write(cache, 0, cache.length); 
246.             i++; 
247.             offSet = i * MAX_ENCRYPT_BLOCK; 
248.         } 
249.         byte[] encryptedData = out.toByteArray(); 
250.         out.close(); 
251.         return encryptedData; 
252.     } 
253.  
254.     /** *//**
255.      * <p>
256.      * 私钥加密
257.      * </p>
258.      *
259.      * @param data 源数据
260.      * @param privateKey 私钥(BASE64编码)
261.      * @return
262.      * @throws Exception
263.      */ 
264.     public static byte[] encryptByPrivateKey(byte[] data, String privateKey) 
265.             throws Exception { 
266.         byte[] keyBytes = Base64Utils.decode(privateKey); 
267.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); 
268.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 
269.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec); 
270.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 
271.         cipher.init(Cipher.ENCRYPT_MODE, privateK); 
272.         int inputLen = data.length; 
273.         ByteArrayOutputStream out = new ByteArrayOutputStream(); 
274.         int offSet = 0; 
275.         byte[] cache; 
276.         int i = 0; 
277.         // 对数据分段加密 
278.         while (inputLen - offSet > 0) { 
279.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) { 
280.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK); 
281.             } else { 
282.                 cache = cipher.doFinal(data, offSet, inputLen - offSet); 
283.             } 
284.             out.write(cache, 0, cache.length); 
285.             i++; 
286.             offSet = i * MAX_ENCRYPT_BLOCK; 
287.         } 
288.         byte[] encryptedData = out.toByteArray(); 
289.         out.close(); 
290.         return encryptedData; 
291.     } 
292.  
293.     /** *//**
294.      * <p>
295.      * 获取私钥
296.      * </p>
297.      *
298.      * @param keyMap 密钥对
299.      * @return
300.      * @throws Exception
301.      */ 
302.     public static String getPrivateKey(Map<String, Object> keyMap) 
303.             throws Exception { 
304.         Key key = (Key) keyMap.get(PRIVATE_KEY); 
305.         return Base64Utils.encode(key.getEncoded()); 
306.     } 
307.  
308.     /** *//**
309.      * <p>
310.      * 获取公钥
311.      * </p>
312.      *
313.      * @param keyMap 密钥对
314.      * @return
315.      * @throws Exception
316.      */ 
317.     public static String getPublicKey(Map<String, Object> keyMap) 
318.             throws Exception { 
319.         Key key = (Key) keyMap.get(PUBLIC_KEY); 
320.         return Base64Utils.encode(key.getEncoded()); 
321.     } 
322.  
323. } 

package security;

import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

/** *//**
 * <p>
 * RSA公钥/私钥/签名工具包
 * </p>
 * <p>
 * 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman）
 * </p>
 * <p>
 * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
 * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>
 * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全
 * </p>
 * 
 * @author IceWee
 * @date 2012-4-26
 * @version 1.0
 */
public class RSAUtils {

    /** *//**
     * 加密算法RSA
     */
    public static final String KEY_ALGORITHM = "RSA";
    
    /** *//**
     * 签名算法
     */
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

    /** *//**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";
    
    /** *//**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";
    
    /** *//**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;
    
    /** *//**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;

    /** *//**
     * <p>
     * 生成密钥对(公钥和私钥)
     * </p>
     * 
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }
    
    /** *//**
     * <p>
     * 用私钥对信息生成数字签名
     * </p>
     * 
     * @param data 已加密数据
     * @param privateKey 私钥(BASE64编码)
     * 
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateK);
        signature.update(data);
        return Base64Utils.encode(signature.sign());
    }

    /** *//**
     * <p>
     * 校验数字签名
     * </p>
     * 
     * @param data 已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @param sign 数字签名
     * 
     * @return
     * @throws Exception
     * 
     */
    public static boolean verify(byte[] data, String publicKey, String sign)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicK = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(Base64Utils.decode(sign));
    }

    /** *//**
     * <P>
     * 私钥解密
     * </p>
     * 
     * @param encryptedData 已加密数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /** *//**
     * <p>
     * 公钥解密
     * </p>
     * 
     * @param encryptedData 已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /** *//**
     * <p>
     * 公钥加密
     * </p>
     * 
     * @param data 源数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /** *//**
     * <p>
     * 私钥加密
     * </p>
     * 
     * @param data 源数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /** *//**
     * <p>
     * 获取私钥
     * </p>
     * 
     * @param keyMap 密钥对
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Object> keyMap)
            throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return Base64Utils.encode(key.getEncoded());
    }

    /** *//**
     * <p>
     * 获取公钥
     * </p>
     * 
     * @param keyMap 密钥对
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Object> keyMap)
            throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return Base64Utils.encode(key.getEncoded());
    }

}

Base64Utils.java

[java] view plain copy print ?

1. package security; 
2.  
3. import java.io.ByteArrayInputStream; 
4. import java.io.ByteArrayOutputStream; 
5. import java.io.File; 
6. import java.io.FileInputStream; 
7. import java.io.FileOutputStream; 
8. import java.io.InputStream; 
9. import java.io.OutputStream; 
10.  
11. import it.sauronsoftware.base64.Base64; 
12.  
13. /** *//**
14. * <p>
15. * BASE64编码解码工具包
16. * </p>
17. * <p>
18. * 依赖javabase64-1.3.1.jar
19. * </p>
20. *
21. * @author IceWee
22. * @date 2012-5-19
23. * @version 1.0
24. */ 
25. public class Base64Utils { 
26.  
27.     /** *//**
28.      * 文件读取缓冲区大小
29.      */ 
30.     private static final int CACHE_SIZE = 1024; 
31.      
32.     /** *//**
33.      * <p>
34.      * BASE64字符串解码为二进制数据
35.      * </p>
36.      *
37.      * @param base64
38.      * @return
39.      * @throws Exception
40.      */ 
41.     public static byte[] decode(String base64) throws Exception { 
42.         return Base64.decode(base64.getBytes()); 
43.     } 
44.      
45.     /** *//**
46.      * <p>
47.      * 二进制数据编码为BASE64字符串
48.      * </p>
49.      *
50.      * @param bytes
51.      * @return
52.      * @throws Exception
53.      */ 
54.     public static String encode(byte[] bytes) throws Exception { 
55.         return new String(Base64.encode(bytes)); 
56.     } 
57.      
58.     /** *//**
59.      * <p>
60.      * 将文件编码为BASE64字符串
61.      * </p>
62.      * <p>
63.      * 大文件慎用，可能会导致内存溢出
64.      * </p>
65.      *
66.      * @param filePath 文件绝对路径
67.      * @return
68.      * @throws Exception
69.      */ 
70.     public static String encodeFile(String filePath) throws Exception { 
71.         byte[] bytes = fileToByte(filePath); 
72.         return encode(bytes); 
73.     } 
74.      
75.     /** *//**
76.      * <p>
77.      * BASE64字符串转回文件
78.      * </p>
79.      *
80.      * @param filePath 文件绝对路径
81.      * @param base64 编码字符串
82.      * @throws Exception
83.      */ 
84.     public static void decodeToFile(String filePath, String base64) throws Exception { 
85.         byte[] bytes = decode(base64); 
86.         byteArrayToFile(bytes, filePath); 
87.     } 
88.      
89.     /** *//**
90.      * <p>
91.      * 文件转换为二进制数组
92.      * </p>
93.      *
94.      * @param filePath 文件路径
95.      * @return
96.      * @throws Exception
97.      */ 
98.     public static byte[] fileToByte(String filePath) throws Exception { 
99.         byte[] data = new byte[0]; 
100.         File file = new File(filePath); 
101.         if (file.exists()) { 
102.             FileInputStream in = new FileInputStream(file); 
103.             ByteArrayOutputStream out = new ByteArrayOutputStream(2048); 
104.             byte[] cache = new byte[CACHE_SIZE]; 
105.             int nRead = 0; 
106.             while ((nRead = in.read(cache)) != -1) { 
107.                 out.write(cache, 0, nRead); 
108.                 out.flush(); 
109.             } 
110.             out.close(); 
111.             in.close(); 
112.             data = out.toByteArray(); 
113.          } 
114.         return data; 
115.     } 
116.      
117.     /** *//**
118.      * <p>
119.      * 二进制数据写文件
120.      * </p>
121.      *
122.      * @param bytes 二进制数据
123.      * @param filePath 文件生成目录
124.      */ 
125.     public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception { 
126.         InputStream in = new ByteArrayInputStream(bytes);    
127.         File destFile = new File(filePath); 
128.         if (!destFile.getParentFile().exists()) { 
129.             destFile.getParentFile().mkdirs(); 
130.         } 
131.         destFile.createNewFile(); 
132.         OutputStream out = new FileOutputStream(destFile); 
133.         byte[] cache = new byte[CACHE_SIZE]; 
134.         int nRead = 0; 
135.         while ((nRead = in.read(cache)) != -1) {    
136.             out.write(cache, 0, nRead); 
137.             out.flush(); 
138.         } 
139.         out.close(); 
140.         in.close(); 
141.     } 
142.      
143.      
144. } 

package security;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

import it.sauronsoftware.base64.Base64;

/** *//**
 * <p>
 * BASE64编码解码工具包
 * </p>
 * <p>
 * 依赖javabase64-1.3.1.jar
 * </p>
 * 
 * @author IceWee
 * @date 2012-5-19
 * @version 1.0
 */
public class Base64Utils {

    /** *//**
     * 文件读取缓冲区大小
     */
    private static final int CACHE_SIZE = 1024;
    
    /** *//**
     * <p>
     * BASE64字符串解码为二进制数据
     * </p>
     * 
     * @param base64
     * @return
     * @throws Exception
     */
    public static byte[] decode(String base64) throws Exception {
        return Base64.decode(base64.getBytes());
    }
    
    /** *//**
     * <p>
     * 二进制数据编码为BASE64字符串
     * </p>
     * 
     * @param bytes
     * @return
     * @throws Exception
     */
    public static String encode(byte[] bytes) throws Exception {
        return new String(Base64.encode(bytes));
    }
    
    /** *//**
     * <p>
     * 将文件编码为BASE64字符串
     * </p>
     * <p>
     * 大文件慎用，可能会导致内存溢出
     * </p>
     * 
     * @param filePath 文件绝对路径
     * @return
     * @throws Exception
     */
    public static String encodeFile(String filePath) throws Exception {
        byte[] bytes = fileToByte(filePath);
        return encode(bytes);
    }
    
    /** *//**
     * <p>
     * BASE64字符串转回文件
     * </p>
     * 
     * @param filePath 文件绝对路径
     * @param base64 编码字符串
     * @throws Exception
     */
    public static void decodeToFile(String filePath, String base64) throws Exception {
        byte[] bytes = decode(base64);
        byteArrayToFile(bytes, filePath);
    }
    
    /** *//**
     * <p>
     * 文件转换为二进制数组
     * </p>
     * 
     * @param filePath 文件路径
     * @return
     * @throws Exception
     */
    public static byte[] fileToByte(String filePath) throws Exception {
        byte[] data = new byte[0];
        File file = new File(filePath);
        if (file.exists()) {
            FileInputStream in = new FileInputStream(file);
            ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
            byte[] cache = new byte[CACHE_SIZE];
            int nRead = 0;
            while ((nRead = in.read(cache)) != -1) {
                out.write(cache, 0, nRead);
                out.flush();
            }
            out.close();
            in.close();
            data = out.toByteArray();
         }
        return data;
    }
    
    /** *//**
     * <p>
     * 二进制数据写文件
     * </p>
     * 
     * @param bytes 二进制数据
     * @param filePath 文件生成目录
     */
    public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {
        InputStream in = new ByteArrayInputStream(bytes);   
        File destFile = new File(filePath);
        if (!destFile.getParentFile().exists()) {
            destFile.getParentFile().mkdirs();
        }
        destFile.createNewFile();
        OutputStream out = new FileOutputStream(destFile);
        byte[] cache = new byte[CACHE_SIZE];
        int nRead = 0;
        while ((nRead = in.read(cache)) != -1) {   
            out.write(cache, 0, nRead);
            out.flush();
        }
        out.close();
        in.close();
    }
    
    
}

RSATester.java

[java] view plain copy print ?

1. package security; 
2.  
3. import java.util.Map; 
4.  
5. public class RSATester { 
6.  
7.     static String publicKey; 
8.     static String privateKey; 
9.  
10.     static { 
11.         try { 
12.             Map<String, Object> keyMap = RSAUtils.genKeyPair(); 
13.             publicKey = RSAUtils.getPublicKey(keyMap); 
14.             privateKey = RSAUtils.getPrivateKey(keyMap); 
15.             System.err.println("公钥: \n\r" + publicKey); 
16.             System.err.println("私钥： \n\r" + privateKey); 
17.         } catch (Exception e) { 
18.             e.printStackTrace(); 
19.         } 
20.     } 
21.      
22.     public static void main(String[] args) throws Exception { 
23.         test(); 
24.         testSign(); 
25.     } 
26.  
27.     static void test() throws Exception { 
28.         System.err.println("公钥加密——私钥解密"); 
29.         String source = "这是一行没有任何意义的文字，你看完了等于没看，不是吗？"; 
30.         System.out.println("\r加密前文字：\r\n" + source); 
31.         byte[] data = source.getBytes(); 
32.         byte[] encodedData = RSAUtils.encryptByPublicKey(data, publicKey); 
33.         System.out.println("加密后文字：\r\n" + new String(encodedData)); 
34.         byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData, privateKey); 
35.         String target = new String(decodedData); 
36.         System.out.println("解密后文字: \r\n" + target); 
37.     } 
38.  
39.     static void testSign() throws Exception { 
40.         System.err.println("私钥加密——公钥解密"); 
41.         String source = "这是一行测试RSA数字签名的无意义文字"; 
42.         System.out.println("原文字：\r\n" + source); 
43.         byte[] data = source.getBytes(); 
44.         byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey); 
45.         System.out.println("加密后：\r\n" + new String(encodedData)); 
46.         byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey); 
47.         String target = new String(decodedData); 
48.         System.out.println("解密后: \r\n" + target); 
49.         System.err.println("私钥签名——公钥验证签名"); 
50.         String sign = RSAUtils.sign(encodedData, privateKey); 
51.         System.err.println("签名:\r" + sign); 
52.         boolean status = RSAUtils.verify(encodedData, publicKey, sign); 
53.         System.err.println("验证结果:\r" + status); 
54.     } 
55.      
56. }