JAVA实现RSA加密

悠悠 2022-07-24 09:16 180阅读 0赞

**\[html\]**  [view plain][]   [copy][view plain]

1.  package utils;

**\[html\]**  [view plain][]   [copy][view plain]

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

Base64Utils文件

**\[html\]**  [view plain][]   [copy][view plain]

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

测试用例：

**\[html\]**  [view plain][]   [copy][view plain]

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

**生成RSA密钥、保存到文件、从文件读取、加密、解密等操作**

**\[html\]**  [view plain][]   [copy][view plain]

1.  import java.security.Key;     
2.  import java.security.KeyFactory;     
3.  import java.security.KeyPair;     
4.  import java.security.KeyPairGenerator;     
5.  import java.security.NoSuchAlgorithmException;     
6.  import java.security.PrivateKey;     
7.  import java.security.PublicKey;     
8.  import java.security.SecureRandom;     
9.  import java.security.interfaces.RSAPrivateKey;     
10. import java.security.interfaces.RSAPublicKey;     
11. import java.security.spec.InvalidKeySpecException;     
12. import java.security.spec.PKCS8EncodedKeySpec;     
13. import java.security.spec.X509EncodedKeySpec;     
14. import javax.crypto.Cipher;     
15. import org.apache.commons.configuration.ConfigurationException;     
16. import org.apache.commons.configuration.PropertiesConfiguration;     
17. import org.bouncycastle.jce.provider.BouncyCastleProvider;     
18.     
19. public class RSATest \{     
20.     
21.     public static void main(String\[\] args) \{     
22.         try \{     
23.             RSATest encrypt = new RSATest();     
24.             String encryptText = "encryptText";     
25.     
26.             // Generate keys     
27.             KeyPair keyPair = encrypt.generateKey();     
28.             RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();     
29.             RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();     
30.     
31.             byte\[\] e = encrypt.encrypt(publicKey, encryptText.getBytes());     
32.             byte\[\] de = encrypt.decrypt(privateKey, e);     
33.             System.out.println(toHexString(e));     
34.             System.out.println(toHexString(de));     
35.         \} catch (Exception e) \{     
36.             e.printStackTrace();     
37.         \}     
38.     \}     
39.     
40.     public KeyPair generateKey() throws NoSuchAlgorithmException \{     
41.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");     
42.         keyPairGen.initialize(1024, new SecureRandom());     
43.     
44.         KeyPair keyPair = keyPairGen.generateKeyPair();     
45.         return keyPair;     
46.     \}     
47.     
48.     public void saveKey(KeyPair keyPair, String publicKeyFile,     
49.             String privateKeyFile) throws ConfigurationException \{     
50.         PublicKey pubkey = keyPair.getPublic();     
51.         PrivateKey prikey = keyPair.getPrivate();     
52.     
53.         // save public key     
54.         PropertiesConfiguration publicConfig = new PropertiesConfiguration(     
55.                 publicKeyFile);     
56.         publicConfig.setProperty("PULIICKEY", toHexString(pubkey.getEncoded()));     
57.         publicConfig.save();     
58.     
59.         // save private key     
60.         PropertiesConfiguration privateConfig = new PropertiesConfiguration(     
61.                 privateKeyFile);     
62.         privateConfig.setProperty("PRIVATEKEY",     
63.                 toHexString(prikey.getEncoded()));     
64.         privateConfig.save();     
65.     \}     
66.     
67.     /\*\*    
68.      \* @param filename    
69.      \* @param type：    
70.      \*            1-public 0-private    
71.      \* @return    
72.      \* @throws ConfigurationException    
73.      \* @throws NoSuchAlgorithmException    
74.      \* @throws InvalidKeySpecException    
75.      \*/    
76.     public Key loadKey(String filename, int type)     
77.             throws ConfigurationException, NoSuchAlgorithmException,     
78.             InvalidKeySpecException \{     
79.         PropertiesConfiguration config = new PropertiesConfiguration(filename);     
80.         KeyFactory keyFactory = KeyFactory.getInstance("RSA",     
81.                 new BouncyCastleProvider());     
82.     
83.         if (type == 0) \{     
84.             // privateKey     
85.             String privateKeyValue = config.getString("PULIICKEY");     
86.             PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(     
87.                     toBytes(privateKeyValue));     
88.             PrivateKey privateKey = keyFactory.generatePrivate(priPKCS8);     
89.             return privateKey;     
90.     
91.         \} else \{     
92.             // publicKey     
93.             String privateKeyValue = config.getString("PRIVATEKEY");     
94.             X509EncodedKeySpec bobPubKeySpec = new X509EncodedKeySpec(     
95.                     toBytes(privateKeyValue));     
96.             PublicKey publicKey = keyFactory.generatePublic(bobPubKeySpec);     
97.             return publicKey;     
98.         \}     
99.     \}     
100.     
101.     /\*\*    
102.      \* Encrypt String.    
103.      \*     
104.      \* @return byte\[\]    
105.      \*/    
106.     protected byte\[\] encrypt(RSAPublicKey publicKey, byte\[\] data) \{     
107.         if (publicKey != null) \{     
108.             try \{     
109.                 Cipher cipher = Cipher.getInstance("RSA",     
110.                         new BouncyCastleProvider());     
111.                 cipher.init(Cipher.ENCRYPT\_MODE, publicKey);     
112.                 return cipher.doFinal(data);     
113.             \} catch (Exception e) \{     
114.                 e.printStackTrace();     
115.             \}     
116.         \}     
117.         return null;     
118.     \}     
119.     
120.     /\*\*    
121.      \* Basic decrypt method    
122.      \*     
123.      \* @return byte\[\]    
124.      \*/    
125.     protected byte\[\] decrypt(RSAPrivateKey privateKey, byte\[\] raw) \{     
126.         if (privateKey != null) \{     
127.             try \{     
128.                 Cipher cipher = Cipher.getInstance("RSA",     
129.                         new BouncyCastleProvider());     
130.                 cipher.init(Cipher.DECRYPT\_MODE, privateKey);     
131.                 return cipher.doFinal(raw);     
132.             \} catch (Exception e) \{     
133.                 e.printStackTrace();     
134.             \}     
135.         \}     
136.     
137.         return null;     
138.     \}     
139.     
140.     public static String toHexString(byte\[\] b) \{     
141.         StringBuilder sb = new StringBuilder(b.length \* 2);     
142.         for (int i = 0; i **<** **b.length**; i++) \{     
143.             sb.append(HEXCHAR\[(b\[i\] & 0xf0) **>****>****>** 4\]);     
144.             sb.append(HEXCHAR\[b\[i\] & 0x0f\]);     
145.         \}     
146.         return sb.toString();     
147.     \}     
148.     
149.     public static final byte\[\] toBytes(String s) \{     
150.         byte\[\] bytes;     
151.         bytes = new byte\[s.length() / 2\];     
152.         for (int i = 0; i **<** **bytes.length**; i++) \{     
153.             bytes\[i\] = (byte) Integer.parseInt(s.substring(2 \* i, 2 \* i + 2),     
154.                     16);     
155.         \}     
156.         return bytes;     
157.     \}     
158.     
159.     private static char\[\] HEXCHAR = \{ '0', '1', '2', '3', '4', '5', '6', '7',     
160.             '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' \};     
161.     
162. \}

# Java中RSA非对称密钥加解密使用示例 #

一、简介：

RSA加密算法是最常用的非对称加密算法，CFCA在证书服务中离不了它。RSA是第一个比较完善的公开密钥算法，它既能用于加密，也能用于数字签名。这个算法经受住了多年深入的密码分析，虽然密码分析者既不能证明也不能否定RSA的安全性，但这恰恰说明该算法有一定的可信性，目前它已经成为最流行的公开密钥算法。

二、RSA的公钥、私钥的组成，以及加密、解密的公式可见于下表

三、使用方式：

① 假设A、B机器进行通信，已A机器为主；

② A首先需要用自己的私钥为发送请求数据签名，并将公钥一同发送给B；

③ B收到数据后，需要用A发送的公钥进行验证，已确保收到的数据是未经篡改的；

④ B验签通过后，处理逻辑，并把处理结果返回，返回数据需要用A发送的公钥进行加密（公钥加密后，只能用配对的私钥解密）；

⑤ A收到B返回的数据，使用私钥解密，至此，一次数据交互完成。

四、代码示例：

1、第一步获取私钥，为签名做准备。

**\[html\]**  [view plain][]   [copy][view plain]

1.  /\*\*  
2.       \* 读取私钥  返回PrivateKey  
3.       \* @param path  包含私钥的证书路径  
4.       \* @param password  私钥证书密码  
5.       \* @return 返回私钥PrivateKey  
6.       \* @throws KeyStoreException  
7.       \* @throws NoSuchAlgorithmException  
8.       \* @throws CertificateException  
9.       \* @throws IOException  
10.      \* @throws UnrecoverableKeyException  
11.      \*/  
12.     private static PrivateKey getPrivateKey(String path,String password)  
13.             throws KeyStoreException, NoSuchAlgorithmException, CertificateException,  
14.             IOException, UnrecoverableKeyException \{  
15.         KeyStore ks = KeyStore.getInstance("PKCS12");  
16.         FileInputStream fis = new FileInputStream(path);  
17.         char\[\] nPassword = null;  
18.         if ((password == null) || password.trim().equals("")) \{  
19.             nPassword = null;  
20.         \} else \{  
21.             nPassword = password.toCharArray();  
22.         \}  
23.         ks.load(fis, nPassword);  
24.         fis.close();  
25.         Enumeration**<****String****>** en = ks.aliases();  
26.         String keyAlias = null;  
27.         if (en.hasMoreElements()) \{  
28.             keyAlias = (String) en.nextElement();  
29.         \}  
30.    
31.         return (PrivateKey) ks.getKey(keyAlias, nPassword);  
32.     \}

2、签名示例：通过第一步得到的私钥，进行签名操作，具体请看以下代码：

**\[html\]**  [view plain][]   [copy][view plain]

1.  /\*\*  
2.       \* 私钥签名： 签名方法如下：BASE64(RSA(MD5(src),privatekey))，其中src为需要签名的字符串，  
3.  privatekey是商户的CFCA证书私钥。  
4.       \* @param plainText 待签名字符串  
5.       \* @param path 签名私钥路径  
6.       \* @param password  签名私钥密码  
7.       \* @return 返回签名后的字符串  
8.       \* @throws Exception  
9.       \*/  
10.     public static String sign(String plainText,String path,String password)  
11.             throws Exception  \{  
12.         /\*  
13.          \* MD5加密  
14.          \*/  
15.         MessageDigest md5 = MessageDigest.getInstance("MD5");  
16.         md5.update(plainText.getBytes("utf-8"));  
17.         byte\[\] digestBytes = md5.digest();  
18.         /\*  
19.          \* 用私钥进行签名 RSA  
20.          \* Cipher负责完成加密或解密工作，基于RSA  
21.          \*/  
22.         Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");  
23.         //ENCRYPT\_MODE表示为加密模式  
24.         cipher.init(Cipher.ENCRYPT\_MODE, getPrivateKey(path, password));  
25.         //加密  
26.         byte\[\] rsaBytes = cipher.doFinal(digestBytes);  
27.         //Base64编码  
28.         return Base64.byteArrayToBase64(rsaBytes);\}

3、B收到数据后，需要使用A提供的公钥信息进行验签，此处使用公钥的N、E进行验签

首先通过公钥N、E得到公钥PublicKey，如下：

**\[html\]**  [view plain][]   [copy][view plain]

1.  /\*\*   
2.       \* 根据公钥n、e生成公钥  
3.       \* @param modulus   公钥n串  
4.       \* @param publicExponent  公钥e串  
5.       \* @return 返回公钥PublicKey  
6.       \* @throws Exception  
7.       \*/  
8.      public static PublicKey getPublickKey(String modulus, String publicExponent)  
9.              throws Exception \{  
10.         KeySpec publicKeySpec = new RSAPublicKeySpec(  
11.                 new BigInteger(modulus, 16), new BigInteger(publicExponent, 16));  
12.         KeyFactory factory = KeyFactory.getInstance("RSA");  
13.         PublicKey publicKey = factory.generatePublic(publicKeySpec);  
14.         return publicKey;  
15.     \}

得到公钥PublicKey后，再去验证签名，代码如下：

**\[html\]**  [view plain][]   [copy][view plain]

1.  /\*\*  
2.       \* 用公钥证书进行验签  
3.       \* @param message  签名之前的原文  
4.       \* @param cipherText  签名  
5.       \* @param pubKeyn 公钥n串  
6.       \* @param pubKeye 公钥e串  
7.       \* @return boolean 验签成功为true,失败为false  
8.       \* @throws Exception  
9.       \*/  
10.     public static boolean verify(String message, String cipherText,String pubKeyn,  
11.             String pubKeye) throws Exception \{  
12.         Cipher c4 = Cipher.getInstance("RSA/ECB/PKCS1Padding");  
13.         // 根据密钥，对Cipher对象进行初始化,DECRYPT\_MODE表示解密模式  
14.         c4.init(Cipher.DECRYPT\_MODE, getPublickKey(pubKeyn,pubKeye));  
15.         // 解密  
16.         byte\[\] desDecTextBytes = c4.doFinal(Base64.base64ToByteArray(cipherText));  
17.         // 得到前置对原文进行的MD5  
18.         String md5Digest1 = Base64.byteArrayToBase64(desDecTextBytes);  
19.         MessageDigest md5 = MessageDigest.getInstance("MD5");  
20.         md5.update(message.getBytes("utf-8"));  
21.         byte\[\] digestBytes = md5.digest();  
22.         // 得到商户对原文进行的MD5  
23.         String md5Digest2 = Base64.byteArrayToBase64(digestBytes);  
24.         // 验证签名  
25.         if (md5Digest1.equals(md5Digest2)) \{  
26.             return true;  
27.         \} else \{  
28.             return false;  
29.         \}  
30.     \}

至此，签名验签已经完毕

4、提供一个从.cer文件读取公钥的方法：

**\[html\]**  [view plain][]   [copy][view plain]

1.  /\*\*  
2.       \* 读取公钥cer  
3.       \* @param path .cer文件的路径  如：c:/abc.cer  
4.       \* @return  base64后的公钥串  
5.       \* @throws IOException  
6.       \* @throws CertificateException  
7.       \*/  
8.      public static String getPublicKey(String path) throws IOException,  
9.      CertificateException\{  
10.         InputStream inStream = new FileInputStream(path);  
11.         ByteArrayOutputStream out = new ByteArrayOutputStream();  
12.         int ch;  
13.         String res = "";  
14.         while ((ch = inStream.read()) != -1) \{  
15.             out.write(ch);  
16.         \}  
17.         byte\[\] result = out.toByteArray();  
18.         res = Base64.byteArrayToBase64(result);  
19.         return res;  
20.     \}

[view plain]: http://blog.csdn.net/keda8997110/article/details/16823361#