Java代码产生根证书和签发证书

1. package com.zeph.android.cert;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7. import java.io.InputStream;  
8. import java.security.InvalidKeyException;  
9. import java.security.Key;  
10. import java.security.KeyStore;  
11. import java.security.KeyStoreException;  
12. import java.security.NoSuchAlgorithmException;  
13. import java.security.NoSuchProviderException;  
14. import java.security.PrivateKey;  
15. import java.security.SecureRandom;  
16. import java.security.SignatureException;  
17. import java.security.UnrecoverableKeyException;  
18. import java.security.cert.Certificate;  
19. import java.security.cert.CertificateException;  
20. import java.security.cert.CertificateFactory;  
21. import java.security.cert.X509Certificate;  
22. import java.util.Date;  
23.   
24. import sun.security.x509.AlgorithmId;  
25. import sun.security.x509.CertAndKeyGen;  
26. import sun.security.x509.CertificateAlgorithmId;  
27. import sun.security.x509.CertificateIssuerName;  
28. import sun.security.x509.CertificateSerialNumber;  
29. import sun.security.x509.CertificateSubjectName;  
30. import sun.security.x509.CertificateValidity;  
31. import sun.security.x509.CertificateVersion;  
32. import sun.security.x509.CertificateX509Key;  
33. import sun.security.x509.X500Name;  
34. import sun.security.x509.X509CertImpl;  
35. import sun.security.x509.X509CertInfo;  
36.   
37. public class X509CertTest {  
38.   
39.     private SecureRandom secureRandom;  
40.   
41.     public X509CertTest() {  
42.   
43.         try {  
44.   
45.             secureRandom = SecureRandom.getInstance("SHA1PRNG", "SUN");  
46.   
47.         } catch (NoSuchAlgorithmException e) {  
48.   
49.             e.printStackTrace();  
50.   
51.         } catch (NoSuchProviderException e) {  
52.   
53.             e.printStackTrace();  
54.   
55.         }  
56.   
57.     }  
58.   
59.     /** 
60.      * 颁布证书 
61.      *  
62.      * @param issue 
63.      * @param subject 
64.      * @param issueAlias 
65.      * @param issuePfxPath 
66.      * @param issuePassword 
67.      * @param issueCrtPath 
68.      * @param subjectAlias 
69.      * @param subjectPfxPath 
70.      * @param subjectPassword 
71.      * @param subjectCrtPath 
72.      * @throws NoSuchAlgorithmException 
73.      * @throws NoSuchProviderException 
74.      * @throws InvalidKeyException 
75.      * @throws CertificateException 
76.      * @throws IOException 
77.      * @throws KeyStoreException 
78.      * @throws UnrecoverableKeyException 
79.      * @throws SignatureException 
80.      */  
81.     public void createIssueCert(X500Name issue, X500Name subject,  
82.             String issueAlias, String issuePfxPath, String issuePassword,  
83.             String issueCrtPath, String subjectAlias, String subjectPfxPath,  
84.             String subjectPassword, String subjectCrtPath)  
85.             throws NoSuchAlgorithmException, NoSuchProviderException,  
86.             InvalidKeyException, CertificateException, IOException,  
87.             KeyStoreException, UnrecoverableKeyException, SignatureException {  
88.   
89.         CertAndKeyGen certAndKeyGen = new CertAndKeyGen("RSA", "MD5WithRSA",  
90.                 null);  
91.   
92.         certAndKeyGen.setRandom(secureRandom);  
93.   
94.         certAndKeyGen.generate(1024);  
95.   
96.         String sigAlg = "MD5WithRSA";  
97.         // 1年  
98.         long validity = 3650 * 24L * 60L * 60L;  
99.   
100.         Date firstDate = new Date();  
101.   
102.         Date lastDate;  
103.   
104.         lastDate = new Date();  
105.   
106.         lastDate.setTime(firstDate.getTime() + validity * 1000);  
107.   
108.         CertificateValidity interval = new CertificateValidity(firstDate,  
109.                 lastDate);  
110.   
111.         X509CertInfo info = new X509CertInfo();  
112.   
113.         // Add all mandatory attributes  
114.         info.set(X509CertInfo.VERSION, new CertificateVersion(  
115.                 CertificateVersion.V3));  
116.   
117.         info.set(X509CertInfo.SERIAL_NUMBER, new CertificateSerialNumber(  
118.                 new java.util.Random().nextInt() & 0x7fffffff));  
119.   
120.         AlgorithmId algID = AlgorithmId.get(sigAlg);  
121.   
122.         info.set(X509CertInfo.ALGORITHM_ID, new CertificateAlgorithmId(algID));  
123.   
124.         info.set(X509CertInfo.SUBJECT, new CertificateSubjectName(subject));  
125.   
126.         info.set(X509CertInfo.KEY, new CertificateX509Key(certAndKeyGen  
127.                 .getPublicKey()));  
128.   
129.         info.set(X509CertInfo.VALIDITY, interval);  
130.   
131.         info.set(X509CertInfo.ISSUER, new CertificateIssuerName(issue));  
132.   
133.         PrivateKey privateKey = readPrivateKey(issueAlias, issuePfxPath,  
134.                 issuePassword);  
135.   
136.         X509CertImpl cert = new X509CertImpl(info);  
137.   
138.         cert.sign(privateKey, sigAlg);  
139.   
140.         X509Certificate certificate = (X509Certificate) cert;  
141.   
142.         X509Certificate issueCertificate = readX509Certificate(issueCrtPath);  
143.   
144.         X509Certificate[] X509Certificates = new X509Certificate[] {  
145.                 certificate, issueCertificate };  
146.   
147.         createKeyStore(subjectAlias, certAndKeyGen.getPrivateKey(),  
148.                 subjectPassword.toCharArray(), X509Certificates, subjectPfxPath);  
149.   
150.         FileOutputStream fos = new FileOutputStream(new File(subjectCrtPath));  
151.   
152.         fos.write(certificate.getEncoded());  
153.   
154.         fos.close();  
155.   
156.     }  
157.   
158.     /** 
159.      * 创建根证书（证书有效期10年，私钥保存密码“123456”，公钥算法“RSA”，签名算法“MD5WithRSA”） 
160.      *  
161.      * @param rootPfxPath 
162.      *            Personal Information Exchange 路径 
163.      * @param rootCrtPath 
164.      *            证书路径 
165.      * @param issue 
166.      *            颁发者&接收颁发者 
167.      * @throws NoSuchAlgorithmException 
168.      * @throws NoSuchProviderException 
169.      * @throws InvalidKeyException 
170.      * @throws IOException 
171.      * @throws CertificateException 
172.      * @throws SignatureException 
173.      * @throws KeyStoreException 
174.      */  
175.     public void createRootCert(String issuePfxPath, String issueCrtPath,  
176.             X500Name issue) throws NoSuchAlgorithmException,  
177.             NoSuchProviderException, InvalidKeyException, IOException,  
178.             CertificateException, SignatureException, KeyStoreException {  
179.   
180.         CertAndKeyGen rootCertAndKeyGen = new CertAndKeyGen("RSA",  
181.                 "MD5WithRSA", null);  
182.   
183.         rootCertAndKeyGen.setRandom(secureRandom);  
184.   
185.         rootCertAndKeyGen.generate(1024);  
186.   
187.         X509Certificate rootCertificate = rootCertAndKeyGen.getSelfCertificate(  
188.                 issue, 3650 * 24L * 60L * 60L);  
189.   
190.         X509Certificate[] X509Certificates = new X509Certificate[] { rootCertificate };  
191.   
192.         String password = "123456";  
193.   
194.         createKeyStore("RootCA", rootCertAndKeyGen.getPrivateKey(), password  
195.                 .toCharArray(), X509Certificates, issuePfxPath);  
196.   
197.         FileOutputStream fos = new FileOutputStream(new File(issueCrtPath));  
198.   
199.         fos.write(rootCertificate.getEncoded());  
200.   
201.         fos.close();  
202.   
203.     }  
204.   
205.     /** 
206.      * 证书私钥存储设施 
207.      *  
208.      * @param alias 
209.      *            KeyStore别名 
210.      * @param key 
211.      *            密钥（这里是私钥） 
212.      * @param password 
213.      *            保存密码 
214.      * @param chain 
215.      *            证书链 
216.      * @param filePath 
217.      *            PFX文件路径 
218.      * @throws KeyStoreException 
219.      * @throws NoSuchAlgorithmException 
220.      * @throws CertificateException 
221.      * @throws IOException 
222.      */  
223.     private void createKeyStore(String alias, Key key, char[] password,  
224.             Certificate[] chain, String filePath) throws KeyStoreException,  
225.             NoSuchAlgorithmException, CertificateException, IOException {  
226.   
227.         KeyStore keyStore = KeyStore.getInstance("pkcs12");  
228.   
229.         keyStore.load(null, password);  
230.   
231.         keyStore.setKeyEntry(alias, key, password, chain);  
232.   
233.         FileOutputStream fos = new FileOutputStream(filePath);  
234.   
235.         keyStore.store(fos, password);  
236.   
237.         fos.close();  
238.     }  
239.   
240.     /** 
241.      * 读取PFX文件中的私钥 
242.      *  
243.      * @param alias 
244.      *            别名 
245.      * @param pfxPath 
246.      *            PFX文件路径 
247.      * @param password 
248.      *            密码 
249.      * @return 
250.      * @throws KeyStoreException 
251.      * @throws NoSuchAlgorithmException 
252.      * @throws CertificateException 
253.      * @throws IOException 
254.      * @throws UnrecoverableKeyException 
255.      */  
256.     public PrivateKey readPrivateKey(String alias, String pfxPath,  
257.             String password) throws KeyStoreException,  
258.             NoSuchAlgorithmException, CertificateException, IOException,  
259.             UnrecoverableKeyException {  
260.   
261.         KeyStore keyStore = KeyStore.getInstance("pkcs12");  
262.   
263.         FileInputStream fis = null;  
264.   
265.         fis = new FileInputStream(pfxPath);  
266.   
267.         keyStore.load(fis, password.toCharArray());  
268.   
269.         fis.close();  
270.   
271.         return (PrivateKey) keyStore.getKey(alias, password.toCharArray());  
272.     }  
273.   
274.     /** 
275.      * 读取X.509证书 
276.      *  
277.      * @param crtPath 
278.      *            证书路径 
279.      * @return 
280.      * @throws CertificateException 
281.      * @throws IOException 
282.      */  
283.     public X509Certificate readX509Certificate(String crtPath)  
284.             throws CertificateException, IOException {  
285.   
286.         InputStream inStream = null;  
287.   
288.         inStream = new FileInputStream(crtPath);  
289.   
290.         CertificateFactory cf = CertificateFactory.getInstance("X.509");  
291.   
292.         X509Certificate cert = (X509Certificate) cf  
293.                 .generateCertificate(inStream);  
294.   
295.         inStream.close();  
296.   
297.         return cert;  
298.     }  
299.   
300.     public static void main(String args[]) throws IOException {  
301.   
302.         // CN commonName 一般名字  
303.         // L localityName 地方名  
304.         // ST stateOrProvinceName 州省名  
305.         // O organizationName 组织名  
306.         // OU organizationalUnitName 组织单位名  
307.         // C countryName 国家  
308.         // STREET streetAddress 街道地址  
309.         // DC domainComponent 领域  
310.         // UID user id 用户ID  
311.         X500Name issue = new X500Name("CN=RootCA,OU=ISI,O=BenZeph,L=CD,ST=SC,C=CN");  
312.   
313.         X500Name subject = new X500Name(  
314.                 "CN=subject,OU=ISI,O=BenZeph,L=CD,ST=SC,C=CN");  
315.   
316.         String issuePfxPath = "G://ROOTCA.pfx";  
317.         String issueCrtPath = "G://ROOTCA.crt";  
318.   
319.         String subjectPfxPath = "G://ISSUE.pfx";  
320.         String subjectCrtPath = "G://ISSUE.crt";  
321.   
322.         String issueAlias = "RootCA";  
323.         String subjectAlias = "subject";  
324.   
325.         String issuePassword = "123456";  
326.         String subjectPassword = "123456";  
327.   
328.         X509CertTest test = new X509CertTest();  
329.   
330.         try {  
331.             test.createRootCert(issuePfxPath, issueCrtPath, issue);  
332.         } catch (InvalidKeyException e1) {  
333.             // TODO Auto-generated catch block  
334.             e1.printStackTrace();  
335.         } catch (NoSuchAlgorithmException e1) {  
336.             // TODO Auto-generated catch block  
337.             e1.printStackTrace();  
338.         } catch (NoSuchProviderException e1) {  
339.             // TODO Auto-generated catch block  
340.             e1.printStackTrace();  
341.         } catch (CertificateException e1) {  
342.             // TODO Auto-generated catch block  
343.             e1.printStackTrace();  
344.         } catch (SignatureException e1) {  
345.             // TODO Auto-generated catch block  
346.             e1.printStackTrace();  
347.         } catch (KeyStoreException e1) {  
348.             // TODO Auto-generated catch block  
349.             e1.printStackTrace();  
350.         }  
351.           
352.         try {  
353.             test.createIssueCert(issue, subject, issueAlias, issuePfxPath,  
354.                     issuePassword, issueCrtPath, subjectAlias, subjectPfxPath,  
355.                     subjectPassword, subjectCrtPath);  
356.         } catch (InvalidKeyException e) {  
357.             // TODO Auto-generated catch block  
358.             e.printStackTrace();  
359.         } catch (UnrecoverableKeyException e) {  
360.             // TODO Auto-generated catch block  
361.             e.printStackTrace();  
362.         } catch (NoSuchAlgorithmException e) {  
363.             // TODO Auto-generated catch block  
364.             e.printStackTrace();  
365.         } catch (NoSuchProviderException e) {  
366.             // TODO Auto-generated catch block  
367.             e.printStackTrace();  
368.         } catch (CertificateException e) {  
369.             // TODO Auto-generated catch block  
370.             e.printStackTrace();  
371.         } catch (KeyStoreException e) {  
372.             // TODO Auto-generated catch block  
373.             e.printStackTrace();  
374.         } catch (SignatureException e) {  
375.             // TODO Auto-generated catch block  
376.             e.printStackTrace();  
377.         }  
378.     }  
379. }<span style="font-family:Arial, Verdana, sans-serif;"><span style="white-space: normal;"><strong>  
380. </strong></span></span>  

添加了几个解析字符串的函数，用来获取证书和KeyStore中的公钥和私钥以及模数N等。

[java]  view plain copy

1. package cn.edu.cuit.isi.rsa;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7. import java.io.InputStream;  
8. import java.security.InvalidKeyException;  
9. import java.security.Key;  
10. import java.security.KeyStore;  
11. import java.security.KeyStoreException;  
12. import java.security.NoSuchAlgorithmException;  
13. import java.security.NoSuchProviderException;  
14. import java.security.PrivateKey;  
15. import java.security.PublicKey;  
16. import java.security.SecureRandom;  
17. import java.security.SignatureException;  
18. import java.security.UnrecoverableKeyException;  
19. import java.security.cert.Certificate;  
20. import java.security.cert.CertificateException;  
21. import java.security.cert.CertificateFactory;  
22. import java.security.cert.X509Certificate;  
23. import java.util.Date;  
24.   
25. import sun.security.x509.AlgorithmId;  
26. import sun.security.x509.CertAndKeyGen;  
27. import sun.security.x509.CertificateAlgorithmId;  
28. import sun.security.x509.CertificateIssuerName;  
29. import sun.security.x509.CertificateSerialNumber;  
30. import sun.security.x509.CertificateSubjectName;  
31. import sun.security.x509.CertificateValidity;  
32. import sun.security.x509.CertificateVersion;  
33. import sun.security.x509.CertificateX509Key;  
34. import sun.security.x509.X500Name;  
35. import sun.security.x509.X509CertImpl;  
36. import sun.security.x509.X509CertInfo;  
37.   
38. public class X509CertTest {  
39.   
40.     private SecureRandom secureRandom;  
41.   
42.     public X509CertTest() {  
43.   
44.         try {  
45.   
46.             secureRandom = SecureRandom.getInstance("SHA1PRNG", "SUN");  
47.   
48.         } catch (NoSuchAlgorithmException e) {  
49.   
50.             e.printStackTrace();  
51.   
52.         } catch (NoSuchProviderException e) {  
53.   
54.             e.printStackTrace();  
55.   
56.         }  
57.   
58.     }  
59.   
60.     /** 
61.      * 颁布证书 
62.      *  
63.      * @param issue 
64.      * @param subject 
65.      * @param issueAlias 
66.      * @param issuePfxPath 
67.      * @param issuePassword 
68.      * @param issueCrtPath 
69.      * @param subjectAlias 
70.      * @param subjectPfxPath 
71.      * @param subjectPassword 
72.      * @param subjectCrtPath 
73.      * @throws NoSuchAlgorithmException 
74.      * @throws NoSuchProviderException 
75.      * @throws InvalidKeyException 
76.      * @throws CertificateException 
77.      * @throws IOException 
78.      * @throws KeyStoreException 
79.      * @throws UnrecoverableKeyException 
80.      * @throws SignatureException 
81.      */  
82.     public void createIssueCert(X500Name issue, X500Name subject,  
83.             String issueAlias, String issuePfxPath, String issuePassword,  
84.             String issueCrtPath, String subjectAlias, String subjectPfxPath,  
85.             String subjectPassword, String subjectCrtPath)  
86.             throws NoSuchAlgorithmException, NoSuchProviderException,  
87.             InvalidKeyException, CertificateException, IOException,  
88.             KeyStoreException, UnrecoverableKeyException, SignatureException {  
89.   
90.         CertAndKeyGen certAndKeyGen = new CertAndKeyGen("RSA", "MD5WithRSA",  
91.                 null);  
92.   
93.         certAndKeyGen.setRandom(secureRandom);  
94.   
95.         certAndKeyGen.generate(1024);  
96.   
97.         String sigAlg = "MD5WithRSA";  
98.         // 1年  
99.         long validity = 3650 * 24L * 60L * 60L;  
100.   
101.         Date firstDate = new Date();  
102.   
103.         Date lastDate;  
104.   
105.         lastDate = new Date();  
106.   
107.         lastDate.setTime(firstDate.getTime() + validity * 1000);  
108.   
109.         CertificateValidity interval = new CertificateValidity(firstDate,  
110.                 lastDate);  
111.   
112.         X509CertInfo info = new X509CertInfo();  
113.   
114.         // Add all mandatory attributes  
115.         info.set(X509CertInfo.VERSION, new CertificateVersion(  
116.                 CertificateVersion.V3));  
117.   
118.         info.set(X509CertInfo.SERIAL_NUMBER, new CertificateSerialNumber(  
119.                 new java.util.Random().nextInt() & 0x7fffffff));  
120.   
121.         AlgorithmId algID = AlgorithmId.get(sigAlg);  
122.   
123.         info.set(X509CertInfo.ALGORITHM_ID, new CertificateAlgorithmId(algID));  
124.   
125.         info.set(X509CertInfo.SUBJECT, new CertificateSubjectName(subject));  
126.   
127.         info.set(X509CertInfo.KEY, new CertificateX509Key(certAndKeyGen  
128.                 .getPublicKey()));  
129.   
130.         info.set(X509CertInfo.VALIDITY, interval);  
131.   
132.         info.set(X509CertInfo.ISSUER, new CertificateIssuerName(issue));  
133.   
134.         PrivateKey privateKey = readPrivateKey(issueAlias, issuePfxPath,  
135.                 issuePassword);  
136.   
137.         X509CertImpl cert = new X509CertImpl(info);  
138.   
139.         cert.sign(privateKey, sigAlg);  
140.   
141.         X509Certificate certificate = (X509Certificate) cert;  
142.   
143.         X509Certificate issueCertificate = readX509Certificate(issueCrtPath);  
144.   
145.         X509Certificate[] X509Certificates = new X509Certificate[] {  
146.                 certificate, issueCertificate };  
147.   
148.         createKeyStore(subjectAlias, certAndKeyGen.getPrivateKey(),  
149.                 subjectPassword.toCharArray(), X509Certificates, subjectPfxPath);  
150.   
151.         FileOutputStream fos = new FileOutputStream(new File(subjectCrtPath));  
152.   
153.         fos.write(certificate.getEncoded());  
154.   
155.         fos.close();  
156.   
157.     }  
158.   
159.     /** 
160.      * 创建根证书（证书有效期10年，私钥保存密码“123456”，公钥算法“RSA”，签名算法“MD5WithRSA”） 
161.      *  
162.      * @param rootPfxPath 
163.      *            Personal Information Exchange 路径 
164.      * @param rootCrtPath 
165.      *            证书路径 
166.      * @param issue 
167.      *            颁发者&接收颁发者 
168.      * @throws NoSuchAlgorithmException 
169.      * @throws NoSuchProviderException 
170.      * @throws InvalidKeyException 
171.      * @throws IOException 
172.      * @throws CertificateException 
173.      * @throws SignatureException 
174.      * @throws KeyStoreException 
175.      */  
176.     public void createRootCert(String issuePfxPath, String issueCrtPath,  
177.             X500Name issue) throws NoSuchAlgorithmException,  
178.             NoSuchProviderException, InvalidKeyException, IOException,  
179.             CertificateException, SignatureException, KeyStoreException {  
180.   
181.         CertAndKeyGen rootCertAndKeyGen = new CertAndKeyGen("RSA",  
182.                 "MD5WithRSA", null);  
183.   
184.         rootCertAndKeyGen.setRandom(secureRandom);  
185.   
186.         rootCertAndKeyGen.generate(1024);  
187.   
188.         X509Certificate rootCertificate = rootCertAndKeyGen.getSelfCertificate(  
189.                 issue, 3650 * 24L * 60L * 60L);  
190.   
191.         X509Certificate[] X509Certificates = new X509Certificate[] { rootCertificate };  
192.   
193.         String password = "123456";  
194.   
195.         createKeyStore("RootCA", rootCertAndKeyGen.getPrivateKey(), password  
196.                 .toCharArray(), X509Certificates, issuePfxPath);  
197.   
198.         FileOutputStream fos = new FileOutputStream(new File(issueCrtPath));  
199.   
200.         fos.write(rootCertificate.getEncoded());  
201.   
202.         fos.close();  
203.   
204.     }  
205.   
206.     /** 
207.      * 证书私钥存储设施 
208.      *  
209.      * @param alias 
210.      *            KeyStore别名 
211.      * @param key 
212.      *            密钥（这里是私钥） 
213.      * @param password 
214.      *            保存密码 
215.      * @param chain 
216.      *            证书链 
217.      * @param filePath 
218.      *            PFX文件路径 
219.      * @throws KeyStoreException 
220.      * @throws NoSuchAlgorithmException 
221.      * @throws CertificateException 
222.      * @throws IOException 
223.      */  
224.     private void createKeyStore(String alias, Key key, char[] password,  
225.             Certificate[] chain, String filePath) throws KeyStoreException,  
226.             NoSuchAlgorithmException, CertificateException, IOException {  
227.   
228.         KeyStore keyStore = KeyStore.getInstance("pkcs12");  
229.   
230.         keyStore.load(null, password);  
231.   
232.         keyStore.setKeyEntry(alias, key, password, chain);  
233.   
234.         FileOutputStream fos = new FileOutputStream(filePath);  
235.   
236.         keyStore.store(fos, password);  
237.   
238.         fos.close();  
239.     }  
240.   
241.     /** 
242.      * 读取PFX文件中的私钥 
243.      *  
244.      * @param alias 
245.      *            别名 
246.      * @param pfxPath 
247.      *            PFX文件路径 
248.      * @param password 
249.      *            密码 
250.      * @return 
251.      * @throws KeyStoreException 
252.      * @throws NoSuchAlgorithmException 
253.      * @throws CertificateException 
254.      * @throws IOException 
255.      * @throws UnrecoverableKeyException 
256.      */  
257.     public PrivateKey readPrivateKey(String alias, String pfxPath,  
258.             String password) throws KeyStoreException,  
259.             NoSuchAlgorithmException, CertificateException, IOException,  
260.             UnrecoverableKeyException {  
261.   
262.         KeyStore keyStore = KeyStore.getInstance("pkcs12");  
263.   
264.         FileInputStream fis = null;  
265.   
266.         fis = new FileInputStream(pfxPath);  
267.   
268.         keyStore.load(fis, password.toCharArray());  
269.   
270.         fis.close();  
271.   
272.         return (PrivateKey) keyStore.getKey(alias, password.toCharArray());  
273.     }  
274.   
275.     /** 
276.      * 读取X.509证书 
277.      *  
278.      * @param crtPath 
279.      *            证书路径 
280.      * @return 
281.      * @throws CertificateException 
282.      * @throws IOException 
283.      */  
284.     public X509Certificate readX509Certificate(String crtPath)  
285.             throws CertificateException, IOException {  
286.   
287.         InputStream inStream = null;  
288.   
289.         inStream = new FileInputStream(crtPath);  
290.   
291.         CertificateFactory cf = CertificateFactory.getInstance("X.509");  
292.   
293.         X509Certificate cert = (X509Certificate) cf  
294.                 .generateCertificate(inStream);  
295.   
296.         inStream.close();  
297.   
298.         return cert;  
299.     }  
300.   
301.     /** 
302.      * 读取公钥证书中的公钥（字符串形式） 
303.      *  
304.      * @param crtPath 
305.      * @return 
306.      * @throws CertificateException 
307.      * @throws IOException 
308.      */  
309.     public String readX509CertificatePublicKey(String crtPath)  
310.             throws CertificateException, IOException {  
311.   
312.         X509Certificate x509Certificate = readX509Certificate(crtPath);  
313.   
314.         PublicKey publicKey = x509Certificate.getPublicKey();  
315.   
316.         return publicKey.toString().replace(" ", "");  
317.   
318.     }  
319.   
320.     /** 
321.      * 读取KeyStore里面的私钥（字符串形式） 
322.      *  
323.      * @param alias 
324.      * @param pfxPath 
325.      * @param password 
326.      * @return 
327.      * @throws UnrecoverableKeyException 
328.      * @throws KeyStoreException 
329.      * @throws NoSuchAlgorithmException 
330.      * @throws CertificateException 
331.      * @throws IOException 
332.      */  
333.     public String readPrivateKeyStr(String alias, String pfxPath,  
334.             String password) throws UnrecoverableKeyException,  
335.             KeyStoreException, NoSuchAlgorithmException, CertificateException,  
336.             IOException {  
337.   
338.         PrivateKey privateKey = readPrivateKey(alias, pfxPath, password);  
339.   
340.         return privateKey.toString().replace(" ", "");  
341.   
342.     }  
343.   
344.     /** 
345.      * 根据证书读取 读取模数N 
346.      *  
347.      * @param crtPath 
348.      * @return 
349.      */  
350.     public String getModulusByCrt(String crtPath) {  
351.         String crt = "";  
352.         try {  
353.             crt = readX509CertificatePublicKey(crtPath);  
354.         } catch (CertificateException e) {  
355.             e.printStackTrace();  
356.         } catch (IOException e) {  
357.             e.printStackTrace();  
358.         }  
359.         String modulus = crt.substring(crt.indexOf("modulus:")  
360.                 + "modulus:".length(), crt.indexOf("publicexponent:"));  
361.         return modulus.trim().replace(" ", "");  
362.     }  
363.   
364.     /** 
365.      * 根据证书读取公钥e 
366.      *  
367.      * @param crtPath 
368.      * @return 
369.      */  
370.     public String getPubExponentByCrt(String crtPath) {  
371.   
372.         String crt = "";  
373.         try {  
374.             crt = readX509CertificatePublicKey(crtPath);  
375.         } catch (CertificateException e) {  
376.             e.printStackTrace();  
377.         } catch (IOException e) {  
378.             e.printStackTrace();  
379.         }  
380.         String pubExponent = crt.substring(crt.indexOf("publicexponent:")  
381.                 + "publicexponent:".length(), crt.length());  
382.         return pubExponent.trim().replace(" ", "");  
383.   
384.     }  
385.   
386.     /** 
387.      * 根据KeyStore读取模数N 
388.      *  
389.      * @param alias 
390.      * @param pfxPath 
391.      * @param password 
392.      * @return 
393.      */  
394.     public String getModulusByPfx(String alias, String pfxPath, String password) {  
395.   
396.         String pfx = "";  
397.         try {  
398.             pfx = readPrivateKeyStr(alias, pfxPath, password);  
399.         } catch (UnrecoverableKeyException e) {  
400.             e.printStackTrace();  
401.         } catch (KeyStoreException e) {  
402.             e.printStackTrace();  
403.         } catch (NoSuchAlgorithmException e) {  
404.             e.printStackTrace();  
405.         } catch (CertificateException e) {  
406.             e.printStackTrace();  
407.         } catch (IOException e) {  
408.             e.printStackTrace();  
409.         }  
410.         String modulus = pfx.substring(pfx.indexOf("modulus:")  
411.                 + "modulus:".length(), pfx.indexOf("publicexponent:"));  
412.   
413.         return modulus.trim().replace(" ", "");  
414.   
415.     }  
416.   
417.     /** 
418.      * 根据KeyStore读取公钥e 
419.      *  
420.      * @param alias 
421.      * @param pfxPath 
422.      * @param password 
423.      * @return 
424.      */  
425.     public String getPubExponentByPfx(String alias, String pfxPath,  
426.             String password) {  
427.   
428.         String pfx = "";  
429.         try {  
430.             pfx = readPrivateKeyStr(alias, pfxPath, password);  
431.         } catch (UnrecoverableKeyException e) {  
432.             e.printStackTrace();  
433.         } catch (KeyStoreException e) {  
434.             e.printStackTrace();  
435.         } catch (NoSuchAlgorithmException e) {  
436.             e.printStackTrace();  
437.         } catch (CertificateException e) {  
438.             e.printStackTrace();  
439.         } catch (IOException e) {  
440.             e.printStackTrace();  
441.         }  
442.         String modulus = pfx.substring(pfx.indexOf("publicexponent:")  
443.                 + "publicexponent:".length(), pfx.indexOf("privateexponent:"));  
444.   
445.         return modulus.trim().replace(" ", "");  
446.   
447.     }  
448.   
449.     /** 
450.      * 根据KeyStore读取私钥d 
451.      *  
452.      * @param alias 
453.      * @param pfxPath 
454.      * @param password 
455.      * @return 
456.      */  
457.     public String getPriExponentByPfx(String alias, String pfxPath,  
458.             String password) {  
459.   
460.         String pfx = "";  
461.         try {  
462.             pfx = readPrivateKeyStr(alias, pfxPath, password);  
463.         } catch (UnrecoverableKeyException e) {  
464.             e.printStackTrace();  
465.         } catch (KeyStoreException e) {  
466.             e.printStackTrace();  
467.         } catch (NoSuchAlgorithmException e) {  
468.             e.printStackTrace();  
469.         } catch (CertificateException e) {  
470.             e.printStackTrace();  
471.         } catch (IOException e) {  
472.             e.printStackTrace();  
473.         }  
474.         String modulus = pfx.substring(pfx.indexOf("privateexponent:")  
475.                 + "privateexponent:".length(), pfx.indexOf("primep:"));  
476.   
477.         return modulus.trim().replace(" ", "");  
478.   
479.     }  
480.   
481.     /** 
482.      * 根据KeyStore读取p 
483.      *  
484.      * @param alias 
485.      * @param pfxPath 
486.      * @param password 
487.      * @return 
488.      */  
489.     public String getpByPfx(String alias, String pfxPath, String password) {  
490.   
491.         String pfx = "";  
492.         try {  
493.             pfx = readPrivateKeyStr(alias, pfxPath, password);  
494.         } catch (UnrecoverableKeyException e) {  
495.             e.printStackTrace();  
496.         } catch (KeyStoreException e) {  
497.             e.printStackTrace();  
498.         } catch (NoSuchAlgorithmException e) {  
499.             e.printStackTrace();  
500.         } catch (CertificateException e) {  
501.             e.printStackTrace();  
502.         } catch (IOException e) {  
503.             e.printStackTrace();  
504.         }  
505.         String modulus = pfx.substring(pfx.indexOf("primep:")  
506.                 + "primep:".length(), pfx.indexOf("primeq:"));  
507.   
508.         return modulus.trim().replace(" ", "");  
509.     }  
510.   
511.     /** 
512.      * 根据KeyStore读取q 
513.      *  
514.      * @param alias 
515.      * @param pfxPath 
516.      * @param password 
517.      * @return 
518.      */  
519.     public String getqByPfx(String alias, String pfxPath, String password) {  
520.   
521.         String pfx = "";  
522.         try {  
523.             pfx = readPrivateKeyStr(alias, pfxPath, password);  
524.         } catch (UnrecoverableKeyException e) {  
525.             e.printStackTrace();  
526.         } catch (KeyStoreException e) {  
527.             e.printStackTrace();  
528.         } catch (NoSuchAlgorithmException e) {  
529.             e.printStackTrace();  
530.         } catch (CertificateException e) {  
531.             e.printStackTrace();  
532.         } catch (IOException e) {  
533.             e.printStackTrace();  
534.         }  
535.         String modulus = pfx.substring(pfx.indexOf("primeq:")  
536.                 + "primeq:".length(), pfx.indexOf("primeexponentp:"));  
537.   
538.         return modulus.trim().replace(" ", "");  
539.   
540.     }  
541.   
542.     /** 
543.      * 根据KeyStore读取dp 
544.      *  
545.      * @param alias 
546.      * @param pfxPath 
547.      * @param password 
548.      * @return 
549.      */  
550.     public String getdpByPfx(String alias, String pfxPath, String password) {  
551.   
552.         String pfx = "";  
553.         try {  
554.             pfx = readPrivateKeyStr(alias, pfxPath, password);  
555.         } catch (UnrecoverableKeyException e) {  
556.             e.printStackTrace();  
557.         } catch (KeyStoreException e) {  
558.             e.printStackTrace();  
559.         } catch (NoSuchAlgorithmException e) {  
560.             e.printStackTrace();  
561.         } catch (CertificateException e) {  
562.             e.printStackTrace();  
563.         } catch (IOException e) {  
564.             e.printStackTrace();  
565.         }  
566.         String modulus = pfx.substring(pfx.indexOf("primeexponentp:")  
567.                 + "primeexponentp:".length(), pfx.indexOf("primeexponentq:"));  
568.   
569.         return modulus.trim().replace(" ", "");  
570.   
571.     }  
572.   
573.     /** 
574.      * 根据KeyStore读取dq 
575.      *  
576.      * @param alias 
577.      * @param pfxPath 
578.      * @param password 
579.      * @return 
580.      */  
581.     public String getdqByPfx(String alias, String pfxPath, String password) {  
582.   
583.         String pfx = "";  
584.         try {  
585.             pfx = readPrivateKeyStr(alias, pfxPath, password);  
586.         } catch (UnrecoverableKeyException e) {  
587.             e.printStackTrace();  
588.         } catch (KeyStoreException e) {  
589.             e.printStackTrace();  
590.         } catch (NoSuchAlgorithmException e) {  
591.             e.printStackTrace();  
592.         } catch (CertificateException e) {  
593.             e.printStackTrace();  
594.         } catch (IOException e) {  
595.             e.printStackTrace();  
596.         }  
597.         String modulus = pfx.substring(pfx.indexOf("primeexponentq:")  
598.                 + "primeexponentq:".length(), pfx.indexOf("crtcoefficient:"));  
599.   
600.         return modulus.trim().replace(" ", "");  
601.   
602.     }  
603.   
604.     /** 
605.      * 根据KeyStore读取qInv 
606.      *  
607.      * @param alias 
608.      * @param pfxPath 
609.      * @param password 
610.      * @return 
611.      */  
612.     public String getqInvByPfx(String alias, String pfxPath, String password) {  
613.   
614.         String pfx = "";  
615.         try {  
616.             pfx = readPrivateKeyStr(alias, pfxPath, password);  
617.         } catch (UnrecoverableKeyException e) {  
618.             e.printStackTrace();  
619.         } catch (KeyStoreException e) {  
620.             e.printStackTrace();  
621.         } catch (NoSuchAlgorithmException e) {  
622.             e.printStackTrace();  
623.         } catch (CertificateException e) {  
624.             e.printStackTrace();  
625.         } catch (IOException e) {  
626.             e.printStackTrace();  
627.         }  
628.         String modulus = pfx.substring(pfx.indexOf("crtcoefficient:")  
629.                 + "crtcoefficient:".length(), pfx.length());  
630.   
631.         return modulus.trim().replace(" ", "");  
632.   
633.     }  
634.   
635.     public static void main(String args[]) throws IOException {  
636.   
637.         // CN commonName 一般名字  
638.         // L localityName 地方名  
639.         // ST stateOrProvinceName 州省名  
640.         // O organizationName 组织名  
641.         // OU organizationalUnitName 组织单位名  
642.         // C countryName 国家  
643.         // STREET streetAddress 街道地址  
644.         // DC domainComponent 领域  
645.         // UID user id 用户ID  
646.         X500Name issue = new X500Name(  
647.                 "CN=RootCA,OU=ISI,O=BenZeph,L=CD,ST=SC,C=CN");  
648.   
649.         X500Name subject = new X500Name(  
650.                 "CN=subject,OU=ISI,O=BenZeph,L=CD,ST=SC,C=CN");  
651.   
652.         String issuePfxPath = "G://ROOTCA.pfx";  
653.         String issueCrtPath = "G://ROOTCA.crt";  
654.   
655.         String subjectPfxPath = "G://ISSUE.pfx";  
656.         String subjectCrtPath = "G://ISSUE.crt";  
657.   
658.         String issueAlias = "RootCA";  
659.         String subjectAlias = "subject";  
660.   
661.         String issuePassword = "123456";  
662.         String subjectPassword = "123456";  
663.   
664.         X509CertTest test = new X509CertTest();  
665.   
666.         try {  
667.             System.out.println(test.readX509CertificatePublicKey(issueCrtPath));  
668.         } catch (CertificateException e) {  
669.             e.printStackTrace();  
670.         }  
671.         System.out.println("");  
672.         System.out.println(test.getModulusByCrt(issueCrtPath));  
673.         System.out.println(test.getPubExponentByCrt(issueCrtPath));  
674.         System.out.println("");  
675.         try {  
676.             System.out.println(test.readPrivateKeyStr(issueAlias, issuePfxPath,  
677.                     issuePassword));  
678.         } catch (UnrecoverableKeyException e) {  
679.             e.printStackTrace();  
680.         } catch (KeyStoreException e) {  
681.             e.printStackTrace();  
682.         } catch (NoSuchAlgorithmException e) {  
683.             e.printStackTrace();  
684.         } catch (CertificateException e) {  
685.             e.printStackTrace();  
686.         }  
687.         System.out.println("");  
688.         System.out.println(test.getModulusByPfx(issueAlias, issuePfxPath,  
689.                 issuePassword));  
690.         System.out.println(test.getPubExponentByPfx(issueAlias, issuePfxPath,  
691.                 issuePassword));  
692.         System.out.println(test.getPriExponentByPfx(issueAlias, issuePfxPath,  
693.                 issuePassword));  
694.         System.out.println(test.getpByPfx(issueAlias, issuePfxPath,  
695.                 issuePassword));  
696.         System.out.println(test.getqByPfx(issueAlias, issuePfxPath,  
697.                 issuePassword));  
698.         System.out.println(test.getdpByPfx(issueAlias, issuePfxPath,  
699.                 issuePassword));  
700.         System.out.println(test.getdqByPfx(issueAlias, issuePfxPath,  
701.                 issuePassword));  
702.         System.out.println(test.getqInvByPfx(issueAlias, issuePfxPath,  
703.                 issuePassword));  
704.     }  
705. }