Android接口安全 - RSA+AES混合加密方案

素颜马尾好姑娘i 2022-06-07 07:55 499阅读 0赞

转载请注明出处：

[http://blog.csdn.net/aa464971/article/details/51034462][http_blog.csdn.net_aa464971_article_details_51034462]

本文以Android客户端加密提交数据到Java服务端后进行解密为例子。

生成RSA公钥和密钥的方法请参考：

[http://blog.csdn.net/aa464971/article/details/51035200][http_blog.csdn.net_aa464971_article_details_51035200]

Android端的加密思路需要4步：

1.生成AES密钥；

2.使用RSA公钥加密刚刚生成的AES密钥；

3.再使用第1步生成的AES密钥，通过AES加密需要提交给服务端的数据；

4.将第2与第3生成的内容传给服务端。

JAVA服务端的解密思路只需3步：

1.获取到客户端传过来的AES密钥密文和内容密文；

2.使用RSA私钥解密从客户端拿到的AES密钥密文；

3.再使用第2步解密出来的明文密钥，通过AES解密内容的密文。

AES的代码可以在JAVA和Android上通用

\[java\] [view plain][] [copy][view plain]

1.  **package** com.dyhdyh.encrypt; 
2.  
3.  **import** java.io.UnsupportedEncodingException; 
4.  **import** java.security.NoSuchAlgorithmException; 
5.  **import** java.security.SecureRandom; 
6.  
7.  **import** javax.crypto.Cipher; 
8.  **import** javax.crypto.KeyGenerator; 
9.  **import** javax.crypto.SecretKey; 
10. **import** javax.crypto.spec.SecretKeySpec; 
11. 
12. /\*\*
13.  \* AES
14.  \* @author dengyuhan
15.  \* @create 2016/3/31 15:43
16.  \*/
17. **public****class** AES \{ 
18. // /\*\* 算法/模式/填充 \*\*/
19. **private****static****final** String CipherMode = "AES/ECB/PKCS5Padding"; 
20. // private static final String CipherMode = "AES";
21. 
22. /\*\*
23.  \* 生成一个AES密钥对象
24.  \* @return
25.  \*/
26. **public****static** SecretKeySpec generateKey()\{ 
27. **try** \{ 
28.  KeyGenerator kgen = KeyGenerator.getInstance("AES"); 
29.  kgen.init(128, **new** SecureRandom()); 
30.  SecretKey secretKey = kgen.generateKey(); 
31. **byte**\[\] enCodeFormat = secretKey.getEncoded(); 
32.  SecretKeySpec key = **new** SecretKeySpec(enCodeFormat, "AES"); 
33. **return** key; 
34.  \} **catch** (NoSuchAlgorithmException e) \{ 
35.  e.printStackTrace(); 
36.  \} 
37. **return****null**; 
38.  \} 
39. 
40. /\*\*
41.  \* 生成一个AES密钥字符串
42.  \* @return
43.  \*/
44. **public****static** String generateKeyString()\{ 
45. **return** byte2hex(generateKey().getEncoded()); 
46.  \} 
47. 
48. /\*\*
49.  \* 加密字节数据
50.  \* @param content
51.  \* @param key
52.  \* @return
53.  \*/
54. **public****static****byte**\[\] encrypt(**byte**\[\] content,**byte**\[\] key) \{ 
55. **try** \{ 
56.  Cipher cipher = Cipher.getInstance(CipherMode); 
57.  cipher.init(Cipher.ENCRYPT\_MODE, **new** SecretKeySpec(key, "AES")); 
58. **byte**\[\] result = cipher.doFinal(content); 
59. **return** result; 
60.  \} **catch** (Exception e) \{ 
61.  e.printStackTrace(); 
62.  \} 
63. **return****null**; 
64.  \} 
65. 
66. /\*\*
67.  \* 通过byte\[\]类型的密钥加密String
68.  \* @param content
69.  \* @param key
70.  \* @return 16进制密文字符串
71.  \*/
72. **public****static** String encrypt(String content,**byte**\[\] key) \{ 
73. **try** \{ 
74.  Cipher cipher = Cipher.getInstance(CipherMode); 
75.  cipher.init(Cipher.ENCRYPT\_MODE, **new** SecretKeySpec(key, "AES")); 
76. **byte**\[\] data = cipher.doFinal(content.getBytes("UTF-8")); 
77.  String result = byte2hex(data); 
78. **return** result; 
79.  \} **catch** (Exception e) \{ 
80.  e.printStackTrace(); 
81.  \} 
82. **return****null**; 
83.  \} 
84. 
85. /\*\*
86.  \* 通过String类型的密钥加密String
87.  \* @param content
88.  \* @param key
89.  \* @return 16进制密文字符串
90.  \*/
91. **public****static** String encrypt(String content,String key) \{ 
92. **byte**\[\] data = **null**; 
93. **try** \{ 
94.  data = content.getBytes("UTF-8"); 
95.  \} **catch** (Exception e) \{ 
96.  e.printStackTrace(); 
97.  \} 
98.  data = encrypt(data,**new** SecretKeySpec(hex2byte(key), "AES").getEncoded()); 
99.  String result = byte2hex(data); 
100. **return** result; 
101.  \} 
102. 
103. /\*\*
104.  \* 通过byte\[\]类型的密钥解密byte\[\]
105.  \* @param content
106.  \* @param key
107.  \* @return
108.  \*/
109. **public****static****byte**\[\] decrypt(**byte**\[\] content,**byte**\[\] key) \{ 
110. **try** \{ 
111.  Cipher cipher = Cipher.getInstance(CipherMode); 
112.  cipher.init(Cipher.DECRYPT\_MODE, **new** SecretKeySpec(key, "AES")); 
113. **byte**\[\] result = cipher.doFinal(content); 
114. **return** result; 
115.  \} **catch** (Exception e) \{ 
116.  e.printStackTrace(); 
117.  \} 
118. **return****null**; 
119.  \} 
120. 
121. /\*\*
122.  \* 通过String类型的密钥 解密String类型的密文
123.  \* @param content
124.  \* @param key
125.  \* @return
126.  \*/
127. **public****static** String decrypt(String content, String key) \{ 
128. **byte**\[\] data = **null**; 
129. **try** \{ 
130.  data = hex2byte(content); 
131.  \} **catch** (Exception e) \{ 
132.  e.printStackTrace(); 
133.  \} 
134.  data = decrypt(data, hex2byte(key)); 
135. **if** (data == **null**) 
136. **return****null**; 
137.  String result = **null**; 
138. **try** \{ 
139.  result = **new** String(data, "UTF-8"); 
140.  \} **catch** (UnsupportedEncodingException e) \{ 
141.  e.printStackTrace(); 
142.  \} 
143. **return** result; 
144.  \} 
145. 
146. /\*\*
147.  \* 通过byte\[\]类型的密钥 解密String类型的密文
148.  \* @param content
149.  \* @param key
150.  \* @return
151.  \*/
152. **public****static** String decrypt(String content,**byte**\[\] key) \{ 
153. **try** \{ 
154.  Cipher cipher = Cipher.getInstance(CipherMode); 
155.  cipher.init(Cipher.DECRYPT\_MODE,**new** SecretKeySpec(key, "AES")); 
156. **byte**\[\] data = cipher.doFinal(hex2byte(content)); 
157. **return****new** String(data, "UTF-8"); 
158.  \} **catch** (Exception e) \{ 
159.  e.printStackTrace(); 
160.  \} 
161. **return****null**; 
162.  \} 
163. 
164. /\*\*
165.  \* 字节数组转成16进制字符串
166.  \* @param b
167.  \* @return
168.  \*/
169. **public****static** String byte2hex(**byte**\[\] b) \{ // 一个字节的数，
170.  StringBuffer sb = **new** StringBuffer(b.length \* 2); 
171.  String tmp = ""; 
172. **for** (**int** n = 0; n < b.length; n++) \{ 
173. // 整数转成十六进制表示
174.  tmp = (Integer.toHexString(b\[n\] & 0XFF)); 
175. **if** (tmp.length() == 1) \{ 
176.  sb.append("0"); 
177.  \} 
178.  sb.append(tmp); 
179.  \} 
180. **return** sb.toString().toUpperCase(); // 转成大写
181.  \} 
182. 
183. /\*\*
184.  \* 将hex字符串转换成字节数组
185.  \* @param inputString
186.  \* @return
187.  \*/
188. **private****static****byte**\[\] hex2byte(String inputString) \{ 
189. **if** (inputString == **null** || inputString.length() < 2) \{ 
190. **return****new****byte**\[0\]; 
191.  \} 
192.  inputString = inputString.toLowerCase(); 
193. **int** l = inputString.length() / 2; 
194. **byte**\[\] result = **new****byte**\[l\]; 
195. **for** (**int** i = 0; i < l; ++i) \{ 
196.  String tmp = inputString.substring(2 \* i, 2 \* i + 2); 
197.  result\[i\] = (**byte**) (Integer.parseInt(tmp, 16) & 0xFF); 
198.  \} 
199. **return** result; 
200.  \} 
201. \}

Android - RSA实现

\[java\] [view plain][] [copy][view plain]

1.  **package** com.dyhdyh.encrypt; 
2.  
3.  **import** android.util.Base64; 
4.  
5.  **import** java.io.BufferedReader; 
6.  **import** java.io.IOException; 
7.  **import** java.io.InputStream; 
8.  **import** java.io.InputStreamReader; 
9.  **import** java.security.KeyFactory; 
10. **import** java.security.NoSuchAlgorithmException; 
11. **import** java.security.interfaces.RSAPrivateKey; 
12. **import** java.security.interfaces.RSAPublicKey; 
13. **import** java.security.spec.InvalidKeySpecException; 
14. **import** java.security.spec.PKCS8EncodedKeySpec; 
15. **import** java.security.spec.X509EncodedKeySpec; 
16. 
17. **import** javax.crypto.Cipher; 
18. 
19. /\*\*
20.  \* 用于Android平台的RSA加密解密
21.  \* 
22.  \* @desc
23.  \* @author dengyuhan
24.  \* @create 2016-3-31 下午2:36:18
25.  \*/
26. **public****class** RSA \{ 
27. **private****static****final** String ALGORITHM = "RSA"; 
28. **private****static****final** String TRANSFORMATION = "RSA"; 
29. 
30. /\*\*
31.  \* 从文件中输入流中加载公钥
32.  \* 
33.  \* @param in
34.  \* 公钥输入流
35.  \* @throws Exception
36.  \* 加载公钥时产生的异常
37.  \*/
38. **public****static** RSAPublicKey loadPublicKey(InputStream in) **throws** Exception \{ 
39. **try** \{ 
40.  BufferedReader br = **new** BufferedReader(**new** InputStreamReader(in)); 
41.  String readLine = **null**; 
42.  StringBuilder sb = **new** StringBuilder(); 
43. **while** ((readLine = br.readLine()) != **null**) \{ 
44. **if** (readLine.charAt(0) == '-') \{ 
45. **continue**; 
46.  \} **else** \{ 
47.  sb.append(readLine); 
48.  sb.append('\\r'); 
49.  \} 
50.  \} 
51. **return** loadPublicKey(sb.toString()); 
52.  \} **catch** (IOException e) \{ 
53. **throw****new** Exception("公钥数据流读取错误"); 
54.  \} **catch** (NullPointerException e) \{ 
55. **throw****new** Exception("公钥输入流为空"); 
56.  \} 
57.  \} 
58. 
59. /\*\*
60.  \* 从字符串中加载公钥
61.  \* 
62.  \* @param publicKeyStr
63.  \* 公钥数据字符串
64.  \* @return
65.  \* @throws Exception
66.  \* 加载公钥时产生的异常
67.  \*/
68. **public****static** RSAPublicKey loadPublicKey(String publicKeyStr) 
69. **throws** Exception \{ 
70. **try** \{ 
71. **byte**\[\] buffer = Base64.decode(publicKeyStr, Base64.DEFAULT); 
72.  KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM); 
73.  X509EncodedKeySpec keySpec = **new** X509EncodedKeySpec(buffer); 
74. **return** (RSAPublicKey) keyFactory.generatePublic(keySpec); 
75.  \} **catch** (NoSuchAlgorithmException e) \{ 
76. **throw****new** Exception("无此算法"); 
77.  \} **catch** (InvalidKeySpecException e) \{ 
78. **throw****new** Exception("公钥非法"); 
79.  \}**catch** (NullPointerException e) \{ 
80. **throw****new** Exception("公钥数据为空"); 
81.  \} 
82.  \} 
83. 
84. /\*\*
85.  \* 从文件中加载私钥
86.  \* 
87.  \* @param in
88.  \* 私钥输入流
89.  \* @return
90.  \* @throws Exception
91.  \*/
92. **public****static** RSAPrivateKey loadPrivateKey(InputStream in) **throws** Exception \{ 
93. **try** \{ 
94.  BufferedReader br = **new** BufferedReader(**new** InputStreamReader(in)); 
95.  String readLine = **null**; 
96.  StringBuilder sb = **new** StringBuilder(); 
97. **while** ((readLine = br.readLine()) != **null**) \{ 
98. **if** (readLine.charAt(0) == '-') \{ 
99. **continue**; 
100.  \} **else** \{ 
101.  sb.append(readLine); 
102.  sb.append('\\r'); 
103.  \} 
104.  \} 
105. **return** loadPrivateKey(sb.toString()); 
106.  \} **catch** (IOException e) \{ 
107. **throw****new** Exception("私钥数据读取错误"); 
108.  \} **catch** (NullPointerException e) \{ 
109. **throw****new** Exception("私钥输入流为空"); 
110.  \} 
111.  \} 
112. 
113. /\*\*
114.  \* 从字符串中加载私钥
115.  \* 
116.  \* @desc
117.  \* @param privateKeyStr
118.  \* 私钥字符串
119.  \* @return
120.  \* @throws Exception
121.  \*/
122. **public****static** RSAPrivateKey loadPrivateKey(String privateKeyStr) 
123. **throws** Exception \{ 
124. **try** \{ 
125. **byte**\[\] buffer = Base64.decode(privateKeyStr, Base64.DEFAULT); 
126.  PKCS8EncodedKeySpec keySpec = **new** PKCS8EncodedKeySpec(buffer); 
127.  KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM); 
128. **return** (RSAPrivateKey) keyFactory.generatePrivate(keySpec); 
129.  \} **catch** (NoSuchAlgorithmException e) \{ 
130. **throw****new** Exception("无此算法"); 
131.  \} **catch** (InvalidKeySpecException e) \{ 
132. **throw****new** Exception("私钥非法"); 
133.  \}**catch** (NullPointerException e) \{ 
134. **throw****new** Exception("私钥数据为空"); 
135.  \} 
136.  \} 
137. 
138. /\*\*
139.  \* 公钥加密
140.  \* 
141.  \* @param data
142.  \* @param publicKey
143.  \* @return
144.  \* @throws Exception
145.  \*/
146. **public****static** String encryptByPublicKey(String data, RSAPublicKey publicKey) 
147. **throws** Exception \{ 
148. // 模长
149. **int** key\_len = publicKey.getModulus().bitLength() / 8; 
150. // 加密数据长度 <= 模长-11
151.  String\[\] datas = splitString(data, key\_len - 11); 
152.  String mi = ""; 
153. // 如果明文长度大于模长-11则要分组加密
154. **for** (String s : datas) \{ 
155.  mi += bcd2Str(encryptByPublicKey(s.getBytes(), publicKey)); 
156.  \} 
157. **return** mi; 
158.  \} 
159. 
160. /\*\*
161.  \* 公钥加密
162.  \* @desc 
163.  \* @param data
164.  \* @param publicKey
165.  \* @return
166.  \* @throws Exception
167.  \*/
168. **public****static****byte**\[\] encryptByPublicKey(**byte**\[\] data, RSAPublicKey publicKey) 
169. **throws** Exception \{ 
170.  Cipher cipher = Cipher.getInstance(TRANSFORMATION); 
171.  cipher.init(Cipher.ENCRYPT\_MODE, publicKey); 
172. **return** cipher.doFinal(data); 
173.  \} 
174. 
175. /\*\*
176.  \* 私钥加密
177.  \* @desc 
178.  \* @param data
179.  \* @param privateKey
180.  \* @return
181.  \* @throws Exception
182.  \*/
183. **public****static****byte**\[\] encryptByPrivateKey(**byte**\[\] data, 
184.  RSAPrivateKey privateKey) **throws** Exception \{ 
185.  Cipher cipher = Cipher.getInstance(TRANSFORMATION); 
186.  cipher.init(Cipher.ENCRYPT\_MODE, privateKey); 
187. **return** cipher.doFinal(data); 
188.  \} 
189. 
190. 
191. /\*\*
192.  \* 私钥加密
193.  \* @desc 
194.  \* @param data
195.  \* @param privateKey
196.  \* @return
197.  \* @throws Exception
198.  \*/
199. **public****static** String encryptByPrivateKey(String data, 
200.  RSAPrivateKey privateKey) **throws** Exception \{ 
201. // 模长
202. **int** key\_len = privateKey.getModulus().bitLength() / 8; 
203. // 加密数据长度 <= 模长-11
204.  String\[\] datas = splitString(data, key\_len - 11); 
205.  String mi = ""; 
206. // 如果明文长度大于模长-11则要分组加密
207. **for** (String s : datas) \{ 
208.  mi += bcd2Str(encryptByPrivateKey(s.getBytes(), privateKey)); 
209.  \} 
210. **return** mi; 
211.  \} 
212. 
213. /\*\*
214.  \* 私钥解密
215.  \* 
216.  \* @param data
217.  \* @param privateKey
218.  \* @return
219.  \* @throws Exception
220.  \*/
221. **public****static** String decryptByPrivateKey(String data, 
222.  RSAPrivateKey privateKey) **throws** Exception \{ 
223. // 模长
224. **int** key\_len = privateKey.getModulus().bitLength() / 8; 
225. **byte**\[\] bytes = data.getBytes(); 
226. **byte**\[\] bcd = ASCII\_To\_BCD(bytes, bytes.length); 
227. // 如果密文长度大于模长则要分组解密
228.  String ming = ""; 
229. **byte**\[\]\[\] arrays = splitArray(bcd, key\_len); 
230. **for** (**byte**\[\] arr : arrays) \{ 
231.  ming += **new** String(decryptByPrivateKey(arr, privateKey)); 
232.  \} 
233. **return** ming; 
234.  \} 
235. 
236. /\*\*
237.  \* 私钥解密
238.  \* @desc 
239.  \* @param data
240.  \* @param privateKey
241.  \* @return
242.  \* @throws Exception
243.  \*/
244. **public****static****byte**\[\] decryptByPrivateKey(**byte**\[\] data, 
245.  RSAPrivateKey privateKey) **throws** Exception \{ 
246.  Cipher cipher = Cipher.getInstance(TRANSFORMATION); 
247.  cipher.init(Cipher.DECRYPT\_MODE, privateKey); 
248. **return** cipher.doFinal(data); 
249.  \} 
250. 
251. /\*\*
252.  \* 公钥解密
253.  \* @desc 
254.  \* @param data
255.  \* @param publicKey
256.  \* @return
257.  \* @throws Exception
258.  \*/
259. **public****static** String decryptByPublicKey(String data, 
260.  RSAPublicKey publicKey) **throws** Exception \{ 
261. // 模长
262. **int** key\_len = publicKey.getModulus().bitLength() / 8; 
263. **byte**\[\] bytes = data.getBytes(); 
264. **byte**\[\] bcd = ASCII\_To\_BCD(bytes, bytes.length); 
265. // 如果密文长度大于模长则要分组解密
266.  String ming = ""; 
267. **byte**\[\]\[\] arrays = splitArray(bcd, key\_len); 
268. **for** (**byte**\[\] arr : arrays) \{ 
269.  ming += **new** String(decryptByPublicKey(arr, publicKey)); 
270.  \} 
271. **return** ming; 
272.  \} 
273. 
274. /\*\*
275.  \* 公钥解密
276.  \* @desc 
277.  \* @param data
278.  \* @param publicKey
279.  \* @return
280.  \* @throws Exception
281.  \*/
282. **public****static****byte**\[\] decryptByPublicKey(**byte**\[\] data, 
283.  RSAPublicKey publicKey) **throws** Exception \{ 
284.  Cipher cipher = Cipher.getInstance(TRANSFORMATION); 
285.  cipher.init(Cipher.DECRYPT\_MODE, publicKey); 
286. **return** cipher.doFinal(data); 
287.  \} 
288. 
289. /\*\*
290.  \* ASCII码转BCD码
291.  \* 
292.  \*/
293. **private****static****byte**\[\] ASCII\_To\_BCD(**byte**\[\] ascii, **int** asc\_len) \{ 
294. **byte**\[\] bcd = **new****byte**\[asc\_len / 2\]; 
295. **int** j = 0; 
296. **for** (**int** i = 0; i < (asc\_len + 1) / 2; i++) \{ 
297.  bcd\[i\] = asc\_to\_bcd(ascii\[j++\]); 
298.  bcd\[i\] = (**byte**) (((j >= asc\_len) ? 0x00 : asc\_to\_bcd(ascii\[j++\])) + (bcd\[i\] << 4)); 
299.  \} 
300. **return** bcd; 
301.  \} 
302. 
303. **private****static****byte** asc\_to\_bcd(**byte** asc) \{ 
304. **byte** bcd; 
305. 
306. **if** ((asc >= '0') && (asc <= '9')) 
307.  bcd = (**byte**) (asc - '0'); 
308. **else****if** ((asc >= 'A') && (asc <= 'F')) 
309.  bcd = (**byte**) (asc - 'A' \+ 10); 
310. **else****if** ((asc >= 'a') && (asc <= 'f')) 
311.  bcd = (**byte**) (asc - 'a' \+ 10); 
312. **else**
313.  bcd = (**byte**) (asc - 48); 
314. **return** bcd; 
315.  \} 
316. 
317. /\*\*
318.  \* BCD转字符串
319.  \*/
320. **private****static** String bcd2Str(**byte**\[\] bytes) \{ 
321. **char** temp\[\] = **new****char**\[bytes.length \* 2\], val; 
322. 
323. **for** (**int** i = 0; i < bytes.length; i++) \{ 
324.  val = (**char**) (((bytes\[i\] & 0xf0) >> 4) & 0x0f); 
325.  temp\[i \* 2\] = (**char**) (val > 9 ? val + 'A' \- 10 : val + '0'); 
326. 
327.  val = (**char**) (bytes\[i\] & 0x0f); 
328.  temp\[i \* 2 \+ 1\] = (**char**) (val > 9 ? val + 'A' \- 10 : val + '0'); 
329.  \} 
330. **return****new** String(temp); 
331.  \} 
332. 
333. /\*\*
334.  \* 拆分字符串
335.  \*/
336. **private****static** String\[\] splitString(String string, **int** len) \{ 
337. **int** x = string.length() / len; 
338. **int** y = string.length() % len; 
339. **int** z = 0; 
340. **if** (y != 0) \{ 
341.  z = 1; 
342.  \} 
343.  String\[\] strings = **new** String\[x + z\]; 
344.  String str = ""; 
345. **for** (**int** i = 0; i < x + z; i++) \{ 
346. **if** (i == x + z - 1 && y != 0) \{ 
347.  str = string.substring(i \* len, i \* len + y); 
348.  \} **else** \{ 
349.  str = string.substring(i \* len, i \* len + len); 
350.  \} 
351.  strings\[i\] = str; 
352.  \} 
353. **return** strings; 
354.  \} 
355. 
356. /\*\*
357.  \* 拆分数组
358.  \*/
359. **private****static****byte**\[\]\[\] splitArray(**byte**\[\] data, **int** len) \{ 
360. **int** x = data.length / len; 
361. **int** y = data.length % len; 
362. **int** z = 0; 
363. **if** (y != 0) \{ 
364.  z = 1; 
365.  \} 
366. **byte**\[\]\[\] arrays = **new****byte**\[x + z\]\[\]; 
367. **byte**\[\] arr; 
368. **for** (**int** i = 0; i < x + z; i++) \{ 
369.  arr = **new****byte**\[len\]; 
370. **if** (i == x + z - 1 && y != 0) \{ 
371.  System.arraycopy(data, i \* len, arr, 0, y); 
372.  \} **else** \{ 
373.  System.arraycopy(data, i \* len, arr, 0, len); 
374.  \} 
375.  arrays\[i\] = arr; 
376.  \} 
377. **return** arrays; 
378.  \} 
379. \}

JAVA - RSA实现

\[java\] [view plain][] [copy][view plain]

1.  **package** com.dyhdyh.encrypt; 
2.  
3.  **import** java.io.BufferedReader; 
4.  **import** java.io.IOException; 
5.  **import** java.io.InputStream; 
6.  **import** java.io.InputStreamReader; 
7.  **import** java.security.KeyFactory; 
8.  **import** java.security.NoSuchAlgorithmException; 
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. 
15. **import** javax.crypto.Cipher; 
16. 
17. **import** org.bouncycastle.jce.provider.BouncyCastleProvider; 
18. 
19. **import** sun.misc.BASE64Decoder; 
20. 
21. /\*\*
22.  \* 用于java平台的RSA加密解密
23.  \* 
24.  \* @desc
25.  \* @author dengyuhan
26.  \* @create 2016-3-31 下午2:36:18
27.  \*/
28. **public****class** RSA \{ 
29. **private****static****final** String ALGORITHM = "RSA"; 
30. **private****static****final** String TRANSFORMATION = "RSA"; 
31. 
32. /\*\*
33.  \* 从文件中输入流中加载公钥
34.  \* 
35.  \* @param in
36.  \* 公钥输入流
37.  \* @throws Exception
38.  \* 加载公钥时产生的异常
39.  \*/
40. **public****static** RSAPublicKey loadPublicKey(InputStream in) **throws** Exception \{ 
41. **try** \{ 
42.  BufferedReader br = **new** BufferedReader(**new** InputStreamReader(in)); 
43.  String readLine = **null**; 
44.  StringBuilder sb = **new** StringBuilder(); 
45. **while** ((readLine = br.readLine()) != **null**) \{ 
46. **if** (readLine.charAt(0) == '-') \{ 
47. **continue**; 
48.  \} **else** \{ 
49.  sb.append(readLine); 
50.  sb.append('\\r'); 
51.  \} 
52.  \} 
53. **return** loadPublicKey(sb.toString()); 
54.  \} **catch** (IOException e) \{ 
55. **throw****new** Exception("公钥数据流读取错误"); 
56.  \} **catch** (NullPointerException e) \{ 
57. **throw****new** Exception("公钥输入流为空"); 
58.  \} 
59.  \} 
60. 
61. /\*\*
62.  \* 从字符串中加载公钥
63.  \* 
64.  \* @param publicKeyStr
65.  \* 公钥数据字符串
66.  \* @return
67.  \* @throws Exception
68.  \* 加载公钥时产生的异常
69.  \*/
70. **public****static** RSAPublicKey loadPublicKey(String publicKeyStr) 
71. **throws** Exception \{ 
72. **try** \{ 
73.  BASE64Decoder base64Decoder = **new** BASE64Decoder(); 
74. **byte**\[\] buffer = base64Decoder.decodeBuffer(publicKeyStr); 
75.  KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM); 
76.  X509EncodedKeySpec keySpec = **new** X509EncodedKeySpec(buffer); 
77. **return** (RSAPublicKey) keyFactory.generatePublic(keySpec); 
78.  \} **catch** (NoSuchAlgorithmException e) \{ 
79. **throw****new** Exception("无此算法"); 
80.  \} **catch** (InvalidKeySpecException e) \{ 
81. **throw****new** Exception("公钥非法"); 
82.  \} **catch** (IOException e) \{ 
83. **throw****new** Exception("公钥数据内容读取错误"); 
84.  \} **catch** (NullPointerException e) \{ 
85. **throw****new** Exception("公钥数据为空"); 
86.  \} 
87.  \} 
88. 
89. /\*\*
90.  \* 从文件中加载私钥
91.  \* 
92.  \* @param in
93.  \* 私钥输入流
94.  \* @return
95.  \* @throws Exception
96.  \*/
97. **public****static** RSAPrivateKey loadPrivateKey(InputStream in) **throws** Exception \{ 
98. **try** \{ 
99.  BufferedReader br = **new** BufferedReader(**new** InputStreamReader(in)); 
100.  String readLine = **null**; 
101.  StringBuilder sb = **new** StringBuilder(); 
102. **while** ((readLine = br.readLine()) != **null**) \{ 
103. **if** (readLine.charAt(0) == '-') \{ 
104. **continue**; 
105.  \} **else** \{ 
106.  sb.append(readLine); 
107.  sb.append('\\r'); 
108.  \} 
109.  \} 
110. **return** loadPrivateKey(sb.toString()); 
111.  \} **catch** (IOException e) \{ 
112. **throw****new** Exception("私钥数据读取错误"); 
113.  \} **catch** (NullPointerException e) \{ 
114. **throw****new** Exception("私钥输入流为空"); 
115.  \} 
116.  \} 
117. 
118. /\*\*
119.  \* 从字符串中加载私钥
120.  \* 
121.  \* @desc
122.  \* @param privateKeyStr
123.  \* 私钥字符串
124.  \* @return
125.  \* @throws Exception
126.  \*/
127. **public****static** RSAPrivateKey loadPrivateKey(String privateKeyStr) 
128. **throws** Exception \{ 
129. **try** \{ 
130.  BASE64Decoder base64Decoder = **new** BASE64Decoder(); 
131. **byte**\[\] buffer = base64Decoder.decodeBuffer(privateKeyStr); 
132.  PKCS8EncodedKeySpec keySpec = **new** PKCS8EncodedKeySpec(buffer); 
133.  KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM); 
134. **return** (RSAPrivateKey) keyFactory.generatePrivate(keySpec); 
135.  \} **catch** (NoSuchAlgorithmException e) \{ 
136. **throw****new** Exception("无此算法"); 
137.  \} **catch** (InvalidKeySpecException e) \{ 
138. **throw****new** Exception("私钥非法"); 
139.  \} **catch** (IOException e) \{ 
140. **throw****new** Exception("私钥数据内容读取错误"); 
141.  \} **catch** (NullPointerException e) \{ 
142. **throw****new** Exception("私钥数据为空"); 
143.  \} 
144.  \} 
145. 
146. /\*\*
147.  \* 公钥加密
148.  \* 
149.  \* @param data
150.  \* @param publicKey
151.  \* @return
152.  \* @throws Exception
153.  \*/
154. **public****static** String encryptByPublicKey(String data, RSAPublicKey publicKey) 
155. **throws** Exception \{ 
156. // 模长
157. **int** key\_len = publicKey.getModulus().bitLength() / 8; 
158. // 加密数据长度 <= 模长-11
159.  String\[\] datas = splitString(data, key\_len - 11); 
160.  String mi = ""; 
161. // 如果明文长度大于模长-11则要分组加密
162. **for** (String s : datas) \{ 
163.  mi += bcd2Str(encryptByPublicKey(s.getBytes(), publicKey)); 
164.  \} 
165. **return** mi; 
166.  \} 
167. 
168. /\*\*
169.  \* 公钥加密
170.  \* @desc 
171.  \* @param data
172.  \* @param publicKey
173.  \* @return
174.  \* @throws Exception
175.  \*/
176. **public****static****byte**\[\] encryptByPublicKey(**byte**\[\] data, RSAPublicKey publicKey) 
177. **throws** Exception \{ 
178.  Cipher cipher = Cipher.getInstance(TRANSFORMATION); 
179.  cipher.init(Cipher.ENCRYPT\_MODE, publicKey); 
180. **return** cipher.doFinal(data); 
181.  \} 
182. 
183. /\*\*
184.  \* 私钥加密
185.  \* @desc 
186.  \* @param data
187.  \* @param privateKey
188.  \* @return
189.  \* @throws Exception
190.  \*/
191. **public****static****byte**\[\] encryptByPrivateKey(**byte**\[\] data, 
192.  RSAPrivateKey privateKey) **throws** Exception \{ 
193.  Cipher cipher = Cipher.getInstance(TRANSFORMATION); 
194.  cipher.init(Cipher.ENCRYPT\_MODE, privateKey); 
195. **return** cipher.doFinal(data); 
196.  \} 
197. 
198. /\*\*
199.  \* 私钥加密
200.  \* @desc 
201.  \* @param data
202.  \* @param privateKey
203.  \* @return
204.  \* @throws Exception
205.  \*/
206. **public****static** String encryptByPrivateKey(String data, 
207.  RSAPrivateKey privateKey) **throws** Exception \{ 
208. // 模长
209. **int** key\_len = privateKey.getModulus().bitLength() / 8; 
210. // 加密数据长度 <= 模长-11
211.  String\[\] datas = splitString(data, key\_len - 11); 
212.  String mi = ""; 
213. // 如果明文长度大于模长-11则要分组加密
214. **for** (String s : datas) \{ 
215.  mi += bcd2Str(encryptByPrivateKey(s.getBytes(), privateKey)); 
216.  \} 
217. **return** mi; 
218.  \} 
219. 
220. /\*\*
221.  \* 私钥解密
222.  \* 
223.  \* @param data
224.  \* @param privateKey
225.  \* @return
226.  \* @throws Exception
227.  \*/
228. **public****static** String decryptByPrivateKey(String data, 
229.  RSAPrivateKey privateKey) **throws** Exception \{ 
230. // 模长
231. **int** key\_len = privateKey.getModulus().bitLength() / 8; 
232. **byte**\[\] bytes = data.getBytes(); 
233. **byte**\[\] bcd = ASCII\_To\_BCD(bytes, bytes.length); 
234. // 如果密文长度大于模长则要分组解密
235.  String ming = ""; 
236. **byte**\[\]\[\] arrays = splitArray(bcd, key\_len); 
237. **for** (**byte**\[\] arr : arrays) \{ 
238.  ming += **new** String(decryptByPrivateKey(arr, privateKey)); 
239.  \} 
240. **return** ming; 
241.  \} 
242. 
243. /\*\*
244.  \* 私钥解密
245.  \* @desc 
246.  \* @param data
247.  \* @param privateKey
248.  \* @return
249.  \* @throws Exception
250.  \*/
251. **public****static****byte**\[\] decryptByPrivateKey(**byte**\[\] data, 
252.  RSAPrivateKey privateKey) **throws** Exception \{ 
253.  Cipher cipher = Cipher.getInstance(TRANSFORMATION,**new** BouncyCastleProvider()); 
254.  cipher.init(Cipher.DECRYPT\_MODE, privateKey); 
255. **return** cipher.doFinal(data); 
256.  \} 
257. 
258. /\*\*
259.  \* 公钥解密
260.  \* @desc 
261.  \* @param data
262.  \* @param publicKey
263.  \* @return
264.  \* @throws Exception
265.  \*/
266. **public****static** String decryptByPublicKey(String data, 
267.  RSAPublicKey publicKey) **throws** Exception \{ 
268. // 模长
269. **int** key\_len = publicKey.getModulus().bitLength() / 8; 
270. **byte**\[\] bytes = data.getBytes(); 
271. **byte**\[\] bcd = ASCII\_To\_BCD(bytes, bytes.length); 
272. // 如果密文长度大于模长则要分组解密
273.  String ming = ""; 
274. **byte**\[\]\[\] arrays = splitArray(bcd, key\_len); 
275. **for** (**byte**\[\] arr : arrays) \{ 
276.  ming += **new** String(decryptByPublicKey(arr, publicKey)); 
277.  \} 
278. **return** ming; 
279.  \} 
280. 
281. /\*\*
282.  \* 公钥解密
283.  \* @desc 
284.  \* @param data
285.  \* @param publicKey
286.  \* @return
287.  \* @throws Exception
288.  \*/
289. **public****static****byte**\[\] decryptByPublicKey(**byte**\[\] data, 
290.  RSAPublicKey publicKey) **throws** Exception \{ 
291.  Cipher cipher = Cipher.getInstance(TRANSFORMATION,**new** BouncyCastleProvider()); 
292.  cipher.init(Cipher.DECRYPT\_MODE, publicKey); 
293. **return** cipher.doFinal(data); 
294.  \} 
295. 
296. /\*\*
297.  \* ASCII码转BCD码
298.  \* 
299.  \*/
300. **private****static****byte**\[\] ASCII\_To\_BCD(**byte**\[\] ascii, **int** asc\_len) \{ 
301. **byte**\[\] bcd = **new****byte**\[asc\_len / 2\]; 
302. **int** j = 0; 
303. **for** (**int** i = 0; i < (asc\_len + 1) / 2; i++) \{ 
304.  bcd\[i\] = asc\_to\_bcd(ascii\[j++\]); 
305.  bcd\[i\] = (**byte**) (((j >= asc\_len) ? 0x00 : asc\_to\_bcd(ascii\[j++\])) + (bcd\[i\] << 4)); 
306.  \} 
307. **return** bcd; 
308.  \} 
309. 
310. **private****static****byte** asc\_to\_bcd(**byte** asc) \{ 
311. **byte** bcd; 
312. 
313. **if** ((asc >= '0') && (asc <= '9')) 
314.  bcd = (**byte**) (asc - '0'); 
315. **else****if** ((asc >= 'A') && (asc <= 'F')) 
316.  bcd = (**byte**) (asc - 'A' \+ 10); 
317. **else****if** ((asc >= 'a') && (asc <= 'f')) 
318.  bcd = (**byte**) (asc - 'a' \+ 10); 
319. **else**
320.  bcd = (**byte**) (asc - 48); 
321. **return** bcd; 
322.  \} 
323. 
324. /\*\*
325.  \* BCD转字符串
326.  \*/
327. **private****static** String bcd2Str(**byte**\[\] bytes) \{ 
328. **char** temp\[\] = **new****char**\[bytes.length \* 2\], val; 
329. 
330. **for** (**int** i = 0; i < bytes.length; i++) \{ 
331.  val = (**char**) (((bytes\[i\] & 0xf0) >> 4) & 0x0f); 
332.  temp\[i \* 2\] = (**char**) (val > 9 ? val + 'A' \- 10 : val + '0'); 
333. 
334.  val = (**char**) (bytes\[i\] & 0x0f); 
335.  temp\[i \* 2 \+ 1\] = (**char**) (val > 9 ? val + 'A' \- 10 : val + '0'); 
336.  \} 
337. **return****new** String(temp); 
338.  \} 
339. 
340. /\*\*
341.  \* 拆分字符串
342.  \*/
343. **private****static** String\[\] splitString(String string, **int** len) \{ 
344. **int** x = string.length() / len; 
345. **int** y = string.length() % len; 
346. **int** z = 0; 
347. **if** (y != 0) \{ 
348.  z = 1; 
349.  \} 
350.  String\[\] strings = **new** String\[x + z\]; 
351.  String str = ""; 
352. **for** (**int** i = 0; i < x + z; i++) \{ 
353. **if** (i == x + z - 1 && y != 0) \{ 
354.  str = string.substring(i \* len, i \* len + y); 
355.  \} **else** \{ 
356.  str = string.substring(i \* len, i \* len + len); 
357.  \} 
358.  strings\[i\] = str; 
359.  \} 
360. **return** strings; 
361.  \} 
362. 
363. /\*\*
364.  \* 拆分数组
365.  \*/
366. **private****static****byte**\[\]\[\] splitArray(**byte**\[\] data, **int** len) \{ 
367. **int** x = data.length / len; 
368. **int** y = data.length % len; 
369. **int** z = 0; 
370. **if** (y != 0) \{ 
371.  z = 1; 
372.  \} 
373. **byte**\[\]\[\] arrays = **new****byte**\[x + z\]\[\]; 
374. **byte**\[\] arr; 
375. **for** (**int** i = 0; i < x + z; i++) \{ 
376.  arr = **new****byte**\[len\]; 
377. **if** (i == x + z - 1 && y != 0) \{ 
378.  System.arraycopy(data, i \* len, arr, 0, y); 
379.  \} **else** \{ 
380.  System.arraycopy(data, i \* len, arr, 0, len); 
381.  \} 
382.  arrays\[i\] = arr; 
383.  \} 
384. **return** arrays; 
385.  \} 
386. \}

JAVA的RSA跟Android的RSA有所不同：

1.加载key的时候，JAVA上用的是BASE64Decoder

\[java\] [view plain][] [copy][view plain]

1.  BASE64Decoder base64Decoder = **new** BASE64Decoder(); 
2.  **byte**\[\] buffer = base64Decoder.decodeBuffer(publicKeyStr);

而Android上用的Base64，这个地方只是API不一样，作用是一样的

\[java\] [view plain][] [copy][view plain]

1.  **byte**\[\] buffer = Base64.decode(publicKeyStr, Base64.DEFAULT);

2.在JAVA平台上调用Cipher.getInstance()的时候，需要多传一个参数，也就是BouncyCastleProvider的实例：

\[java\] [view plain][] [copy][view plain]

1.  Cipher cipher = Cipher.getInstance("RSA",**new** BouncyCastleProvider());

这个类jdk上是没有的，所以需要添加一个jar包bcprov-jdk15-143.jar

如果不这样做，JAVA上解密的时候就会抛出一个BadPaddingException

\[java\] [view plain][] [copy][view plain]

1.  Exception in thread "main" javax.crypto.BadPaddingException: Blocktype mismatch: 0
2.   at sun.security.rsa.RSAPadding.unpadV15(RSAPadding.java:332) 
3.   at sun.security.rsa.RSAPadding.unpad(RSAPadding.java:272) 
4.   at com.sun.crypto.provider.RSACipher.doFinal(RSACipher.java:356) 
5.   at com.sun.crypto.provider.RSACipher.engineDoFinal(RSACipher.java:382) 
6.   at javax.crypto.Cipher.doFinal(Cipher.java:2087) 
7.   at com.dyhdyh.encrypt.RSA.decryptByPrivateKey(RSA.java:255) 
8.   at com.dyhdyh.encrypt.RSA.decryptByPrivateKey(RSA.java:238)

这是因为Android的加密标准与JAVA的加密标准不一致导致，Android上的RSA实现是"RSA/None/NoPadding"，而标准JDK实现是"RSA/None/PKCS1Padding"，这造成了在Android上加密后无法在服务器上解密

最后来看看怎样混合加密(这里只举一种方式，附件里有完整的)

Android上加密

1.将openssl生成出来的公钥，放入assets文件夹内（不一定要放这里，只要能拿到文件内容就行）。

![Center][]

2.加载放在assets文件里的公钥

\[java\] [view plain][] [copy][view plain]

1.  //加载RSA公钥
2.  RSAPublicKey rsaPublicKey = RSA.loadPublicKey(getAssets().open("rsa\_public\_key.pem"));

3.再生成一个AES的密钥，用于AES加密

\[java\] [view plain][] [copy][view plain]

1.  //生成一个AES密钥
2.  String aesKey=AES.generateKeyString();

4.通过RSA的公钥来加密刚刚生成的AES密钥

\[java\] [view plain][] [copy][view plain]

1.  //用RSA公钥加密AES的密钥
2.  String encryptAesKey = RSA.encryptByPublicKey(aesKey, rsaPublicKey);

5.最后使用AES来加密需要传输的数据，AES加密需要传入两个参数，第一个是明文数据，第二个是3步生成出来的密钥

\[java\] [view plain][] [copy][view plain]

1.  //再使用AES加密内容，传给服务器
2.  String encryptContent = AES.encrypt(content, aesKey);

6.第5步返回的字符串就是加密过后的数据，最后将4和5传给服务端，接下来就是服务端的事情了。

客户端传过来密文之后，接下来就需要服务端来解密了

JAVA解密

1.加载RSA私钥(这里的私钥是跟客户端的公钥是成对的)

\[java\] [view plain][] [copy][view plain]

1.  //加载私钥
2.  RSAPrivateKey privateKey = RSA.loadPrivateKey(**new** FileInputStream("G:/RSA密钥/pkcs8\_rsa\_private\_key.pem"));

2.通过RSA的私钥解密客户端传来的AES-KEY（也就是客户端的第4），因为这个key是加过密的，所以我们需要先将key解密成明文

\[java\] [view plain][] [copy][view plain]

1.  //解密AES-KEY
2.  String decryptAesKey = RSA.decryptByPrivateKey(aesKey, privateKey);

3.AES-KEY加密成明文之后，现在可以拿这个key来解密客户端传过来的数据了

\[java\] [view plain][] [copy][view plain]

1.  //AES解密数据
2.  String decrypt = AES.decrypt(content, decryptAesKey);

RSA-AES混合加密就是这个样子，有什么问题请跟帖回复，我会继续改进

最后附上完整demo

[http://download.csdn.net/detail/aa464971/9478798][http_download.csdn.net_detail_aa464971_9478798]

[http_blog.csdn.net_aa464971_article_details_51034462]: http://blog.csdn.net/aa464971/article/details/51034462
[http_blog.csdn.net_aa464971_article_details_51035200]: http://blog.csdn.net/aa464971/article/details/51035200
[view plain]: http://blog.csdn.net/aa464971/article/details/51034462#
[Center]: /images/20220607/645c0a688e394f469e4cbccc0d8faca6.png
[http_download.csdn.net_detail_aa464971_9478798]: http://download.csdn.net/detail/aa464971/9478798