RSA加密例子和中途遇到的问题

在进行RSA加密例子

1. package test;
2. import java.io.IOException;
3. import java.security.Key;
4. import java.security.KeyFactory;
5. import java.security.KeyPair;
6. import java.security.KeyPairGenerator;
7. import java.security.PrivateKey;
8. import java.security.PublicKey;
9. import java.security.Signature;
10. import java.security.interfaces.RSAPrivateKey;
11. import java.security.interfaces.RSAPublicKey;
12. import java.security.spec.PKCS8EncodedKeySpec;
13. import java.security.spec.X509EncodedKeySpec;
14. import sun.misc.BASE64Decoder;
15. import sun.misc.BASE64Encoder;
16. import java.util.HashMap;
17. import java.util.Map;
18. import javax.crypto.Cipher;
19. public abstract class RSACoder {
20. public static final String KEY_ALGORITHM = "RSA";
21. public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
22. private static final String PUBLIC_KEY = "RSAPublicKey";
23. private static final String PRIVATE_KEY = "RSAPrivateKey";
24. public static byte[] decryptBASE64(String privateKey){
25. byte[] output = null;
26. try {
27. output = (new BASE64Decoder()).decodeBuffer(privateKey);
28. return  output;
29. } catch (IOException e) {
30. e.printStackTrace();
31. }
32. return output;
33. }
34. public static String encryptBASE64( byte[] keyBytes){
35. String s = (new BASE64Encoder()).encode(keyBytes);
36. return s;
37. }
38. /**
39. * 用私钥对信息生成数字签名
40. *
41. * @param data
42. *            加密数据
43. * @param privateKey
44. *            私钥
45. *
46. * @return
47. * @throws Exception
48. */
49. public static String sign(byte[] data, String privateKey) throws Exception {
50. // 解密由base64编码的私钥
51. byte[] keyBytes = decryptBASE64(privateKey);
52. // 构造PKCS8EncodedKeySpec对象
53. PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
54. // KEY_ALGORITHM 指定的加密算法
55. KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
56. // 取私钥匙对象
57. PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
58. // 用私钥对信息生成数字签名
59. Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
60. signature.initSign(priKey);
61. signature.update(data);
62. return encryptBASE64(signature.sign());
63. }
64. /**
65. * 校验数字签名
66. *
67. * @param data
68. *            加密数据
69. * @param publicKey
70. *            公钥
71. * @param sign
72. *            数字签名
73. *
74. * @return 校验成功返回true 失败返回false
75. * @throws Exception
76. *
77. */
78. public static boolean verify(byte[] data, String publicKey, String sign)
79. throws Exception {
80. // 解密由base64编码的公钥
81. byte[] keyBytes = decryptBASE64(publicKey);
82. // 构造X509EncodedKeySpec对象
83. X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
84. // KEY_ALGORITHM 指定的加密算法
85. KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
86. // 取公钥匙对象
87. PublicKey pubKey = keyFactory.generatePublic(keySpec);
88. Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
89. signature.initVerify(pubKey);
90. signature.update(data);
91. // 验证签名是否正常
92. return signature.verify(decryptBASE64(sign));
93. }
94. /**
95. * 解密<br>
96. * 用私钥解密
97. *
98. * @param data
99. * @param key
100. * @return
101. * @throws Exception
102. */
103. public static byte[] decryptByPrivateKey(byte[] data, String key)
104. throws Exception {
105. // 对密钥解密
106. byte[] keyBytes = decryptBASE64(key);
107. // 取得私钥
108. PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
109. KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
110. Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
111. // 对数据解密
112. Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
113. cipher.init(Cipher.DECRYPT_MODE, privateKey);
114. return cipher.doFinal(data);
115. }
116. /**
117. * 解密<br>
118. * 用公钥解密
119. *
120. * @param data
121. * @param key
122. * @return
123. * @throws Exception
124. */
125. public static byte[] decryptByPublicKey(byte[] data, String key)
126. throws Exception {
127. // 对密钥解密
128. byte[] keyBytes = decryptBASE64(key);
129. // 取得公钥
130. X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
131. KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
132. Key publicKey = keyFactory.generatePublic(x509KeySpec);
133. // 对数据解密
134. Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
135. cipher.init(Cipher.DECRYPT_MODE, publicKey);
136. return cipher.doFinal(data);
137. }
138. /**
139. * 加密<br>
140. * 用公钥加密
141. *
142. * @param data
143. * @param key
144. * @return
145. * @throws Exception
146. */
147. public static byte[] encryptByPublicKey(byte[] data, String key)
148. throws Exception {
149. // 对公钥解密
150. byte[] keyBytes = decryptBASE64(key);
151. // 取得公钥
152. X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
153. KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
154. Key publicKey = keyFactory.generatePublic(x509KeySpec);
155. // 对数据加密
156. Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
157. cipher.init(Cipher.ENCRYPT_MODE, publicKey);
158. return cipher.doFinal(data);
159. }
160. /**
161. * 加密<br>
162. * 用私钥加密
163. *
164. * @param data
165. * @param key
166. * @return
167. * @throws Exception
168. */
169. public static byte[] encryptByPrivateKey(byte[] data, String key)
170. throws Exception {
171. // 对密钥解密
172. byte[] keyBytes = decryptBASE64(key);
173. // 取得私钥
174. PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
175. KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
176. Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
177. // 对数据加密
178. Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
179. cipher.init(Cipher.ENCRYPT_MODE, privateKey);
180. return cipher.doFinal(data);
181. }
182. /**
183. * 取得私钥
184. *
185. * @param keyMap
186. * @return
187. * @throws Exception
188. */
189. public static String getPrivateKey(Map<String, Object> keyMap)
190. throws Exception {
191. Key key = (Key) keyMap.get(PRIVATE_KEY);
192. return encryptBASE64(key.getEncoded());
193. }
194. /**
195. * 取得公钥
196. *
197. * @param keyMap
198. * @return
199. * @throws Exception
200. */
201. public static String getPublicKey(Map<String, Object> keyMap)
202. throws Exception {
203. Key key = (Key) keyMap.get(PUBLIC_KEY);
204. return encryptBASE64(key.getEncoded());
205. }
206. /**
207. * 初始化密钥
208. *
209. * @return
210. * @throws Exception
211. */
212. public static Map<String, Object> initKey() throws Exception {
213. KeyPairGenerator keyPairGen = KeyPairGenerator
214. .getInstance(KEY_ALGORITHM);
215. keyPairGen.initialize(1024);
216. KeyPair keyPair = keyPairGen.generateKeyPair();
217. // 公钥
218. RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
219. // 私钥
220. RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
221. Map<String, Object> keyMap = new HashMap<String, Object>(2);
222. keyMap.put(PUBLIC_KEY, publicKey);
223. keyMap.put(PRIVATE_KEY, privateKey);
224. return keyMap;
225. }
226. }

测试类

1. package test;
2. import java.util.Map;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
5. import sun.misc.BASE64Decoder;
6. import sun.misc.BASE64Encoder;
7. public class RSACoderTest {
8. package com;
9. import java.util.Map;
10. import sun.misc.BASE64Encoder;
11. public class RSACoderTest {
12. static String privateKey ;
13. static String publicKey ;
14. public static void getKey() throws Exception {
15. Map<String, Object> keyMap = RSACoder.initKey();
16. publicKey = RSACoder.getPublicKey(keyMap);
17. privateKey = RSACoder.getPrivateKey(keyMap);
18. //公钥生成
19. System.out.println("public : "+publicKey);
20. //私钥生成
21. System.out.println("private : "+privateKey);
22. }
23. public static void main(String[] args) throws Exception {
24. getKey() ;
25. //      System.err.println("公钥加密——私钥解密");
26. //将明文转换为字节数组
27. byte[] data = "serricee1".getBytes();
28. //用公钥加密
29. byte[] encodedData = RSACoder.encryptByPublicKey(data, publicKey);
30. //打印加密字符串 为什么使用BASE64Encoder 因为在RSACoder里加密用的是 BASE64Encoder 加密
31. String s = (new BASE64Encoder()).encode(encodedData);
32. System.err.println("加密: " +s);
33. //                //用私钥解密
34. byte[] decodedData = RSACoder.decryptByPrivateKey(RSACoder.decryptBASE64(s),privateKey);
35. //
36. //
37. System.out.println( "解密后: " + new String(decodedData));
38. }
39. }

遇到的问题在

解密的时候 用new BASE64Encoder()).encode(keyBytes); 获得明文发现明文长度只能是4的倍数而且不支持特殊字符串和中文不然解密出来不是多出来 就是解密不对 后面解密

直接用.getBytes() 和new String(decodedData)不用Base64的就好了