原文：http://snowolf.iteye.com/blog/391931

請大家在閱讀本篇內容時先閱讀 Java加密技術（四），預先了解RSA加密算法。

在構建Java代碼實現前，我們需要完成證書的制作。
1.生成keyStroe文件
在命令行下執行以下命令：

1. keytool -genkey -validity 36000 -alias www.zlex.org -keyalg RSA -keystore d:\zlex.keystore

其中
-genkey表示生成密鑰
-validity指定證書有效期，這裏是36000天
-alias指定別名，這裏是www.zlex.org

1. 輸入keystore密碼：
2. 再次輸入新密碼:
3. 您的名字與姓氏是什麽？
4. [Unknown]： www.zlex.org
5. 您的組織單位名稱是什麽？
6. [Unknown]： zlex
7. 您的組織名稱是什麽？
8. [Unknown]： zlex
9. 您所在的城市或區域名稱是什麽？
10. [Unknown]： BJ
11. 您所在的州或省份名稱是什麽？
12. [Unknown]： BJ
13. 該單位的兩字母國家代碼是什麽
14. [Unknown]： CN
15. CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN 正確嗎？
16. [否]： Y
18. 輸入<tomcat>的主密碼
19. （如果和 keystore 密碼相同，按回車）：
20. 再次輸入新密碼:

這時，在D盤下會生成一個zlex.keystore的文件。

2.生成自簽名證書
光有keyStore文件是不夠的，還需要證書文件，證書才是直接提供給外界使用的公鑰憑證。
導出證書：

1. keytool -export -keystore d:\zlex.keystore -alias www.zlex.org -file d:\zlex.cer -rfc

其中
-export指定為導出操作
-keystore指定keystore文件
-alias指定導出keystore文件中的別名
-file指向導出路徑
-rfc以文本格式輸出，也就是以BASE64編碼輸出
這裏的密碼是 123456

控制臺輸出：

1. 輸入keystore密碼：
2. 保存在文件中的認證 <d:\zlex.cer>

當然，使用方是需要導入證書的！
可以通過自簽名證書完成CAS單點登錄系統的構建！

Ok，準備工作完成，開始Java實現！

通過java代碼實現如下：Coder類見 Java加密技術（一）

1. import java.io.FileInputStream;
2. import java.security.KeyStore;
3. import java.security.PrivateKey;
4. import java.security.PublicKey;
5. import java.security.Signature;
6. import java.security.cert.Certificate;
7. import java.security.cert.CertificateFactory;
8. import java.security.cert.X509Certificate;
9. import java.util.Date;
11. import javax.crypto.Cipher;
13. /**
14. * 證書組件
15. *
16. * @author 梁棟
17. * @version 1.0
18. * @since 1.0
19. */
20. public abstract class CertificateCoder extends Coder {
23. /**
24. * Java密鑰庫(Java Key Store，JKS)KEY_STORE
25. */
26. public static final String KEY_STORE = "JKS";
28. public static final String X509 = "X.509";
30. /**
31. * 由KeyStore獲得私鑰
32. *
33. * @param keyStorePath
34. * @param alias
35. * @param password
36. * @return
37. * @throws Exception
38. */
39. private static PrivateKey getPrivateKey(String keyStorePath, String alias,
40. String password) throws Exception {
41. KeyStore ks = getKeyStore(keyStorePath, password);
42. PrivateKey key = (PrivateKey) ks.getKey(alias, password.toCharArray());
43. return key;
44. }
46. /**
47. * 由Certificate獲得公鑰
48. *
49. * @param certificatePath
50. * @return
51. * @throws Exception
52. */
53. private static PublicKey getPublicKey(String certificatePath)
54. throws Exception {
55. Certificate certificate = getCertificate(certificatePath);
56. PublicKey key = certificate.getPublicKey();
57. return key;
58. }
60. /**
61. * 獲得Certificate
62. *
63. * @param certificatePath
64. * @return
65. * @throws Exception
66. */
67. private static Certificate getCertificate(String certificatePath)
68. throws Exception {
69. CertificateFactory certificateFactory = CertificateFactory
70. .getInstance(X509);
71. FileInputStream in = new FileInputStream(certificatePath);
73. Certificate certificate = certificateFactory.generateCertificate(in);
74. in.close();
76. return certificate;
77. }
79. /**
80. * 獲得Certificate
81. *
82. * @param keyStorePath
83. * @param alias
84. * @param password
85. * @return
86. * @throws Exception
87. */
88. private static Certificate getCertificate(String keyStorePath,
89. String alias, String password) throws Exception {
90. KeyStore ks = getKeyStore(keyStorePath, password);
91. Certificate certificate = ks.getCertificate(alias);
93. return certificate;
94. }
96. /**
97. * 獲得KeyStore
98. *
99. * @param keyStorePath
100. * @param password
101. * @return
102. * @throws Exception
103. */
104. private static KeyStore getKeyStore(String keyStorePath, String password)
105. throws Exception {
106. FileInputStream is = new FileInputStream(keyStorePath);
107. KeyStore ks = KeyStore.getInstance(KEY_STORE);
108. ks.load(is, password.toCharArray());
109. is.close();
110. return ks;
111. }
113. /**
114. * 私鑰加密
115. *
116. * @param data
117. * @param keyStorePath
118. * @param alias
119. * @param password
120. * @return
121. * @throws Exception
122. */
123. public static byte[] encryptByPrivateKey(byte[] data, String keyStorePath,
124. String alias, String password) throws Exception {
125. // 取得私鑰
126. PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);
128. // 對數據加密
129. Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
130. cipher.init(Cipher.ENCRYPT_MODE, privateKey);
132. return cipher.doFinal(data);
134. }
136. /**
137. * 私鑰解密
138. *
139. * @param data
140. * @param keyStorePath
141. * @param alias
142. * @param password
143. * @return
144. * @throws Exception
145. */
146. public static byte[] decryptByPrivateKey(byte[] data, String keyStorePath,
147. String alias, String password) throws Exception {
148. // 取得私鑰
149. PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);
151. // 對數據加密
152. Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
153. cipher.init(Cipher.DECRYPT_MODE, privateKey);
155. return cipher.doFinal(data);
157. }
159. /**
160. * 公鑰加密
161. *
162. * @param data
163. * @param certificatePath
164. * @return
165. * @throws Exception
166. */
167. public static byte[] encryptByPublicKey(byte[] data, String certificatePath)
168. throws Exception {
170. // 取得公鑰
171. PublicKey publicKey = getPublicKey(certificatePath);
172. // 對數據加密
173. Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
174. cipher.init(Cipher.ENCRYPT_MODE, publicKey);
176. return cipher.doFinal(data);
178. }
180. /**
181. * 公鑰解密
182. *
183. * @param data
184. * @param certificatePath
185. * @return
186. * @throws Exception
187. */
188. public static byte[] decryptByPublicKey(byte[] data, String certificatePath)
189. throws Exception {
190. // 取得公鑰
191. PublicKey publicKey = getPublicKey(certificatePath);
193. // 對數據加密
194. Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
195. cipher.init(Cipher.DECRYPT_MODE, publicKey);
197. return cipher.doFinal(data);
199. }
201. /**
202. * 驗證Certificate
203. *
204. * @param certificatePath
205. * @return
206. */
207. public static boolean verifyCertificate(String certificatePath) {
208. return verifyCertificate(new Date(), certificatePath);
209. }
211. /**
212. * 驗證Certificate是否過期或無效
213. *
214. * @param date
215. * @param certificatePath
216. * @return
217. */
218. public static boolean verifyCertificate(Date date, String certificatePath) {
219. boolean status = true;
220. try {
221. // 取得證書
222. Certificate certificate = getCertificate(certificatePath);
223. // 驗證證書是否過期或無效
224. status = verifyCertificate(date, certificate);
225. } catch (Exception e) {
226. status = false;
227. }
228. return status;
229. }
231. /**
232. * 驗證證書是否過期或無效
233. *
234. * @param date
235. * @param certificate
236. * @return
237. */
238. private static boolean verifyCertificate(Date date, Certificate certificate) {
239. boolean status = true;
240. try {
241. X509Certificate x509Certificate = (X509Certificate) certificate;
242. x509Certificate.checkValidity(date);
243. } catch (Exception e) {
244. status = false;
245. }
246. return status;
247. }
249. /**
250. * 簽名
251. *
252. * @param keyStorePath
253. * @param alias
254. * @param password
255. *
256. * @return
257. * @throws Exception
258. */
259. public static String sign(byte[] sign, String keyStorePath, String alias,
260. String password) throws Exception {
261. // 獲得證書
262. X509Certificate x509Certificate = (X509Certificate) getCertificate(
263. keyStorePath, alias, password);
264. // 獲取私鑰
265. KeyStore ks = getKeyStore(keyStorePath, password);
266. // 取得私鑰
267. PrivateKey privateKey = (PrivateKey) ks.getKey(alias, password
268. .toCharArray());
270. // 構建簽名
271. Signature signature = Signature.getInstance(x509Certificate
272. .getSigAlgName());
273. signature.initSign(privateKey);
274. signature.update(sign);
275. return encryptBASE64(signature.sign());
276. }
278. /**
279. * 驗證簽名
280. *
281. * @param data
282. * @param sign
283. * @param certificatePath
284. * @return
285. * @throws Exception
286. */
287. public static boolean verify(byte[] data, String sign,
288. String certificatePath) throws Exception {
289. // 獲得證書
290. X509Certificate x509Certificate = (X509Certificate) getCertificate(certificatePath);
291. // 獲得公鑰
292. PublicKey publicKey = x509Certificate.getPublicKey();
293. // 構建簽名
294. Signature signature = Signature.getInstance(x509Certificate
295. .getSigAlgName());
296. signature.initVerify(publicKey);
297. signature.update(data);
299. return signature.verify(decryptBASE64(sign));
301. }
303. /**
304. * 驗證Certificate
305. *
306. * @param keyStorePath
307. * @param alias
308. * @param password
309. * @return
310. */
311. public static boolean verifyCertificate(Date date, String keyStorePath,
312. String alias, String password) {
313. boolean status = true;
314. try {
315. Certificate certificate = getCertificate(keyStorePath, alias,
316. password);
317. status = verifyCertificate(date, certificate);
318. } catch (Exception e) {
319. status = false;
320. }
321. return status;
322. }
324. /**
325. * 驗證Certificate
326. *
327. * @param keyStorePath
328. * @param alias
329. * @param password
330. * @return
331. */
332. public static boolean verifyCertificate(String keyStorePath, String alias,
333. String password) {
334. return verifyCertificate(new Date(), keyStorePath, alias, password);
335. }
336. }

再給出一個測試類：

1. import static org.junit.Assert.*;
3. import org.junit.Test;
5. /**
6. *
7. * @author 梁棟
8. * @version 1.0
9. * @since 1.0
10. */
11. public class CertificateCoderTest {
12. private String password = "123456";
13. private String alias = "www.zlex.org";
14. private String certificatePath = "d:/zlex.cer";
15. private String keyStorePath = "d:/zlex.keystore";
17. @Test
18. public void test() throws Exception {
19. System.err.println("公鑰加密——私鑰解密");
20. String inputStr = "Ceritifcate";
21. byte[] data = inputStr.getBytes();
23. byte[] encrypt = CertificateCoder.encryptByPublicKey(data,
24. certificatePath);
26. byte[] decrypt = CertificateCoder.decryptByPrivateKey(encrypt,
27. keyStorePath, alias, password);
28. String outputStr = new String(decrypt);
30. System.err.println("加密前: " + inputStr + "\n\r" + "解密後: " + outputStr);
32. // 驗證數據一致
33. assertArrayEquals(data, decrypt);
35. // 驗證證書有效
36. assertTrue(CertificateCoder.verifyCertificate(certificatePath));
38. }
40. @Test
41. public void testSign() throws Exception {
42. System.err.println("私鑰加密——公鑰解密");
44. String inputStr = "sign";
45. byte[] data = inputStr.getBytes();
47. byte[] encodedData = CertificateCoder.encryptByPrivateKey(data,
48. keyStorePath, alias, password);
50. byte[] decodedData = CertificateCoder.decryptByPublicKey(encodedData,
51. certificatePath);
53. String outputStr = new String(decodedData);
54. System.err.println("加密前: " + inputStr + "\n\r" + "解密後: " + outputStr);
55. assertEquals(inputStr, outputStr);
57. System.err.println("私鑰簽名——公鑰驗證簽名");
58. // 產生簽名
59. String sign = CertificateCoder.sign(encodedData, keyStorePath, alias,
60. password);
61. System.err.println("簽名:\r" + sign);
63. // 驗證簽名
64. boolean status = CertificateCoder.verify(encodedData, sign,
65. certificatePath);
66. System.err.println("狀態:\r" + status);
67. assertTrue(status);
69. }
70. }

控制臺輸出：

1. 公鑰加密——私鑰解密
2. 加密前: Ceritificate
4. 解密後: Ceritificate
6. 私鑰加密——公鑰解密
7. 加密前: sign
9. 解密後: sign
10. 私鑰簽名——公鑰驗證簽名
11. 簽名:
12. pqBn5m6PJlfOjH0A6U2o2mUmBsfgyEY1NWCbiyA/I5Gc3gaVNVIdj/zkGNZRqTjhf3+J9a9z9EI7
13. 6F2eWYd7punHx5oh6hfNgcKbVb52EfItl4QEN+djbXiPynn07+Lbg1NOjULnpEd6ZhLP1YwrEAuM
14. OfvX0e7/wplxLbySaKQ=
16. 狀態:
17. true

由此完成了證書驗證體系！

同樣，我們可以對代碼做簽名——代碼簽名！
通過工具JarSigner可以完成代碼簽名。
這裏我們對tools.jar做代碼簽名，命令如下：

1. jarsigner -storetype jks -keystore zlex.keystore -verbose tools.jar www.zlex.org

控制臺輸出：

1. 輸入密鑰庫的口令短語：
2. 正在更新： META-INF/WWW_ZLEX.SF
3. 正在更新： META-INF/WWW_ZLEX.RSA
4. 正在簽名： org/zlex/security/Security.class
5. 正在簽名： org/zlex/tool/Main$1.class
6. 正在簽名： org/zlex/tool/Main$2.class
7. 正在簽名： org/zlex/tool/Main.class
9. 警告：
10. 簽名者證書將在六個月內過期。

此時，我們可以對簽名後的jar做驗證！
驗證tools.jar，命令如下：

1. jarsigner -verify -verbose -certs tools.jar

控制臺輸出：

1. 402 Sat Jun 20 16:25:14 CST 2009 META-INF/MANIFEST.MF
2. 532 Sat Jun 20 16:25:14 CST 2009 META-INF/WWW_ZLEX.SF
3. 889 Sat Jun 20 16:25:14 CST 2009 META-INF/WWW_ZLEX.RSA
4. sm 590 Wed Dec 10 13:03:42 CST 2008 org/zlex/security/Security.class
6. X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
7. [證書將在 09-9-18 下午3:27 到期]
9. sm 705 Tue Dec 16 18:00:56 CST 2008 org/zlex/tool/Main$1.class
11. X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
12. [證書將在 09-9-18 下午3:27 到期]
14. sm 779 Tue Dec 16 18:00:56 CST 2008 org/zlex/tool/Main$2.class
16. X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
17. [證書將在 09-9-18 下午3:27 到期]
19. sm 12672 Tue Dec 16 18:00:56 CST 2008 org/zlex/tool/Main.class
21. X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
22. [證書將在 09-9-18 下午3:27 到期]
25. s = 已驗證簽名
26. m = 在清單中列出條目
27. k = 在密鑰庫中至少找到了一個證書
28. i = 在身份作用域內至少找到了一個證書
30. jar 已驗證。
32. 警告：
33. 此 jar 包含簽名者證書將在六個月內過期的條目。

代碼簽名認證的用途主要是對發布的軟件做驗證，支持 Sun Java .jar (Java Applet) 文件(J2SE)和 J2ME MIDlet Suite 文件。




相關鏈接：
Java加密技術（一）——BASE64與單向加密算法MD5&SHA&MAC
Java加密技術（二）——對稱加密DES&AES
Java加密技術（三）——PBE算法
Java加密技術（四）——非對稱加密算法RSA
Java加密技術（五）——非對稱加密算法的由來
Java加密技術（六）——數字簽名算法DSA
Java加密技術（七）——非對稱加密算法最高ECC
Java加密技術（八）——數字證書
Java加密技術（九）——初探SSL
Java加密技術（十）——單向認證
Java加密技術（十一）——雙向認證
Java加密技術（十二）——*.PFX(*.p12)&個人信息交換文件

Java加密技術（八）——數字證書