Java加密技术（八）

    本篇的主要内容为Java证书体系的实现。

请大家在阅读本篇内容时先阅读 Java加密技术（四），预先了解RSA加密算法。

在构建Java代码实现前，我们需要完成证书的制作。
1.生成keyStroe文件
在命令行下执行以下命令：

Shell代码

1. keytool -genkey -alias tomcat -keyalg RSA -keystore d:\.keystore  

keytool -genkey -alias tomcat -keyalg RSA -keystore d:\.keystore

其中 -genkey表示生成密钥 -alias指定别名，这里是tomcat -keyalg指定算法，这里是RSA -keystore指定存储位置，这里是d:\.keystore
在这里我使用的密码为 123456
控制台输出：

Console代码

1. 输入keystore密码：   
2. 再次输入新密码:   
3. 您的名字与姓氏是什么？   
4.   [Unknown]：  zlex   
5. 您的组织单位名称是什么？   
6.   [Unknown]：  zlex   
7. 您的组织名称是什么？   
8.   [Unknown]：  zlex   
9. 您所在的城市或区域名称是什么？   
10.   [Unknown]：  BJ   
11. 您所在的州或省份名称是什么？   
12.   [Unknown]：  BJ   
13. 该单位的两字母国家代码是什么   
14.   [Unknown]：  CN   
15. CN=zlex, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN 正确吗？   
16.   [否]：  Y   
17.   
18. 输入<tomcat>的主密码   
19.         （如果和 keystore 密码相同，按回车）：   
20. 再次输入新密码:  

输入keystore密码：
再次输入新密码:
您的名字与姓氏是什么？
  [Unknown]：  zlex
您的组织单位名称是什么？
  [Unknown]：  zlex
您的组织名称是什么？
  [Unknown]：  zlex
您所在的城市或区域名称是什么？
  [Unknown]：  BJ
您所在的州或省份名称是什么？
  [Unknown]：  BJ
该单位的两字母国家代码是什么
  [Unknown]：  CN
CN=zlex, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN 正确吗？
  [否]：  Y

输入<tomcat>的主密码
        （如果和 keystore 密码相同，按回车）：
再次输入新密码:

这时，在D盘下会生成一个.keystore的文件。

2.生成证书
光有keyStore文件是不够的，还需要证书文件，证书才是直接提供给外界使用的公钥凭证。
导出证书：

Shell代码

1. keytool -export -keystore d:\.keystore -alias tomcat -file d:\tomcat.cer  

keytool -export -keystore d:\.keystore -alias tomcat -file d:\tomcat.cer

其中 -export指定为导出操作 -keystore指定keystore文件 -alias指定导出keystore文件中的别名 -file指向导出路径

这里的密码是 123456
控制台输出：

Console代码

1. 输入keystore密码：   
2. 保存在文件中的认证 <d:\tomcat.cer>  

输入keystore密码：
保存在文件中的认证 <d:\tomcat.cer>

当然，使用方是需要注册证书的！

Ok，准备工作完成，开始Java实现！

通过java代码实现如下： Coder类见 Java加密技术（一）

Java代码

1. import java.io.FileInputStream;   
2. import java.security.KeyFactory;   
3. import java.security.KeyStore;   
4. import java.security.PrivateKey;   
5. import java.security.PublicKey;   
6. import java.security.Signature;   
7. import java.security.cert.Certificate;   
8. import java.security.cert.CertificateFactory;   
9. import java.security.cert.X509Certificate;   
10. import java.security.spec.PKCS8EncodedKeySpec;   
11. import java.security.spec.X509EncodedKeySpec;   
12. import java.util.Date;   
13.   
14. /**  
15.  * 证书组件  
16.  *   
17.  * @author 梁栋  
18.  * @version 1.0  
19.  * @since 1.0  
20.  */  
21. public abstract class CertificateCoder extends Coder {   
22.   
23.     /**  
24.      * Java密钥库(Java Key Store，JKS)KEY_STORE  
25.      */  
26.     public static final String KEY_STORE = "JKS";   
27.   
28.     public static final String X509 = "X.509";   
29.   
30.     /**  
31.      * 由KeyStore获得私钥  
32.      *   
33.      * @param keyStorePath  
34.      * @param alias  
35.      * @param password  
36.      * @return  
37.      * @throws Exception  
38.      */  
39.     public static String getPrivateKey(String keyStorePath, String alias,   
40.             String password) throws Exception {   
41.         KeyStore ks = getKeyStore(keyStorePath, alias, password);   
42.         PrivateKey key = (PrivateKey) ks.getKey(alias, password.toCharArray());   
43.         return encryptBASE64(key.getEncoded());   
44.     }   
45.   
46.     /**  
47.      * 由Certificate获得公钥  
48.      *   
49.      * @param certificatePath  
50.      * @return  
51.      * @throws Exception  
52.      */  
53.     public static String getPublicKey(String certificatePath) throws Exception {   
54.         Certificate certificate = getCertificate(certificatePath);   
55.         PublicKey key = certificate.getPublicKey();   
56.         return encryptBASE64(key.getEncoded());   
57.     }   
58.   
59.     /**  
60.      * 获得Certificate  
61.      *   
62.      * @param certificatePath  
63.      * @return  
64.      * @throws Exception  
65.      */  
66.     private static Certificate getCertificate(String certificatePath)   
67.             throws Exception {   
68.         CertificateFactory certificateFactory = CertificateFactory   
69.                 .getInstance(X509);   
70.         FileInputStream in = new FileInputStream(certificatePath);   
71.   
72.         Certificate certificate = certificateFactory.generateCertificate(in);   
73.         in.close();   
74.   
75.         return certificate;   
76.     }   
77.   
78.     /**  
79.      * 获得Certificate  
80.      *   
81.      * @param keyStorePath  
82.      * @param alias  
83.      * @param password  
84.      * @return  
85.      * @throws Exception  
86.      */  
87.     private static Certificate getCertificate(String keyStorePath,   
88.             String alias, String password) throws Exception {   
89.         KeyStore ks = getKeyStore(keyStorePath, alias, password);   
90.         Certificate certificate = ks.getCertificate(alias);   
91.   
92.         return certificate;   
93.     }   
94.   
95.     /**  
96.      * 获得KeyStore  
97.      *   
98.      * @param keyStorePath  
99.      * @param alias  
100.      * @param password  
101.      * @return  
102.      * @throws Exception  
103.      */  
104.     private static KeyStore getKeyStore(String keyStorePath, String alias,   
105.             String password) 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.     }   
112.   
113.     /**  
114.      * 验证Certificate  
115.      *   
116.      * @param certificatePath  
117.      * @return  
118.      */  
119.     public static boolean verifyCertificate(String certificatePath) {   
120.         return verifyCertificate(new Date(), certificatePath);   
121.     }   
122.   
123.     /**  
124.      * 验证Certificate是否过期或无效  
125.      *   
126.      * @param date  
127.      * @param certificatePath  
128.      * @return  
129.      */  
130.     public static boolean verifyCertificate(Date date, String certificatePath) {   
131.         boolean status = true;   
132.         try {   
133.             // 取得证书   
134.             Certificate certificate = getCertificate(certificatePath);   
135.             // 验证证书是否过期或无效   
136.             status = verifyCertificate(date, certificate);   
137.         } catch (Exception e) {   
138.             status = false;   
139.         }   
140.         return status;   
141.     }   
142.   
143.     /**  
144.      * 验证公钥是否同属该证书  
145.      *   
146.      * @param publicKey  
147.      * @param certificatePath  
148.      * @return  
149.      */  
150.     public static boolean verifyPublicKey(String publicKey,   
151.             String certificatePath) {   
152.         boolean status = true;   
153.         try {   
154.             Certificate certificate = getCertificate(certificatePath);   
155.   
156.             // 对公钥解密   
157.             byte[] keyBytes = decryptBASE64(publicKey);   
158.   
159.             // 取得公钥   
160.             X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);   
161.             KeyFactory keyFactory = KeyFactory.getInstance(certificate   
162.                     .getPublicKey().getAlgorithm());   
163.             PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);   
164.   
165.             certificate.verify(pubKey);   
166.   
167.         } catch (Exception e) {   
168.             status = false;   
169.         }   
170.         return status;   
171.     }   
172.   
173.     /**  
174.      * 验证证书是否过期或无效  
175.      *   
176.      * @param date  
177.      * @param certificate  
178.      * @return  
179.      */  
180.     private static boolean verifyCertificate(Date date, Certificate certificate) {   
181.         boolean status = true;   
182.         try {   
183.             X509Certificate x509Certificate = (X509Certificate) certificate;   
184.             x509Certificate.checkValidity(date);   
185.         } catch (Exception e) {   
186.             status = false;   
187.         }   
188.         return status;   
189.     }   
190.   
191.     /**  
192.      * 签名  
193.      * @param keyStorePath  
194.      * @param privateKey  
195.      * @param alias  
196.      * @param password  
197.      * @return  
198.      * @throws Exception  
199.      */  
200.     public static String sign(byte[] sign, String keyStorePath, String privateKey,   
201.             String alias, String password) throws Exception {   
202.         // 获得证书   
203.         X509Certificate x509Certificate = (X509Certificate) getCertificate(   
204.                 keyStorePath, alias, password);   
205.         // 解密由base64编码的私钥   
206.         byte[] keyBytes = decryptBASE64(privateKey);   
207.   
208.         // 构造PKCS8EncodedKeySpec对象   
209.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);   
210.   
211.         // 由证书公钥获得对应加密算法   
212.         KeyFactory keyFactory = KeyFactory.getInstance(x509Certificate   
213.                 .getPublicKey().getAlgorithm());   
214.   
215.         // 获取私钥   
216.         PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);   
217.   
218.         // 构建签名   
219.         Signature signature = Signature.getInstance(x509Certificate   
220.                 .getSigAlgName());   
221.         signature.initSign(priKey);   
222.         signature.update(sign);   
223.         return encryptBASE64(signature.sign());   
224.     }   
225.   
226.     /**  
227.      * 验证签名  
228.      *   
229.      * @param data  
230.      * @param sign  
231.      * @param certificatePath  
232.      * @return  
233.      * @throws Exception  
234.      */  
235.     public static boolean verify(byte[] data, String sign,   
236.             String certificatePath) throws Exception {   
237.         // 获得证书   
238.         X509Certificate x509Certificate = (X509Certificate) getCertificate(certificatePath);   
239.         // 获得公钥   
240.         PublicKey publicKey = x509Certificate.getPublicKey();   
241.         // 构建签名   
242.         Signature signature = Signature.getInstance(x509Certificate   
243.                 .getSigAlgName());   
244.         signature.initVerify(publicKey);   
245.         signature.update(data);   
246.   
247.         return signature.verify(decryptBASE64(sign));   
248.   
249.     }   
250.   
251.     /**  
252.      * 验证Certificate  
253.      *   
254.      * @param keyStorePath  
255.      * @param alias  
256.      * @param password  
257.      * @return  
258.      */  
259.     public static boolean verifyCertificate(Date date, String keyStorePath,   
260.             String alias, String password) {   
261.         boolean status = true;   
262.         try {   
263.             Certificate certificate = getCertificate(keyStorePath, alias,   
264.                     password);   
265.             status = verifyCertificate(date, certificate);   
266.         } catch (Exception e) {   
267.             status = false;   
268.         }   
269.         return status;   
270.     }   
271.   
272.     /**  
273.      * 验证Certificate  
274.      *   
275.      * @param keyStorePath  
276.      * @param alias  
277.      * @param password  
278.      * @return  
279.      */  
280.     public static boolean verifyCertificate(String keyStorePath, String alias,   
281.             String password) {   
282.         return verifyCertificate(new Date(), keyStorePath, alias, password);   
283.     }   
284. }  

import java.io.FileInputStream;
import java.security.KeyFactory;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Date;

/**
 * 证书组件
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public abstract class CertificateCoder extends Coder {

	/**
	 * Java密钥库(Java Key Store，JKS)KEY_STORE
	 */
	public static final String KEY_STORE = "JKS";

	public static final String X509 = "X.509";

	/**
	 * 由KeyStore获得私钥
	 * 
	 * @param keyStorePath
	 * @param alias
	 * @param password
	 * @return
	 * @throws Exception
	 */
	public static String getPrivateKey(String keyStorePath, String alias,
			String password) throws Exception {
		KeyStore ks = getKeyStore(keyStorePath, alias, password);
		PrivateKey key = (PrivateKey) ks.getKey(alias, password.toCharArray());
		return encryptBASE64(key.getEncoded());
	}

	/**
	 * 由Certificate获得公钥
	 * 
	 * @param certificatePath
	 * @return
	 * @throws Exception
	 */
	public static String getPublicKey(String certificatePath) throws Exception {
		Certificate certificate = getCertificate(certificatePath);
		PublicKey key = certificate.getPublicKey();
		return encryptBASE64(key.getEncoded());
	}

	/**
	 * 获得Certificate
	 * 
	 * @param certificatePath
	 * @return
	 * @throws Exception
	 */
	private static Certificate getCertificate(String certificatePath)
			throws Exception {
		CertificateFactory certificateFactory = CertificateFactory
				.getInstance(X509);
		FileInputStream in = new FileInputStream(certificatePath);

		Certificate certificate = certificateFactory.generateCertificate(in);
		in.close();

		return certificate;
	}

	/**
	 * 获得Certificate
	 * 
	 * @param keyStorePath
	 * @param alias
	 * @param password
	 * @return
	 * @throws Exception
	 */
	private static Certificate getCertificate(String keyStorePath,
			String alias, String password) throws Exception {
		KeyStore ks = getKeyStore(keyStorePath, alias, password);
		Certificate certificate = ks.getCertificate(alias);

		return certificate;
	}

	/**
	 * 获得KeyStore
	 * 
	 * @param keyStorePath
	 * @param alias
	 * @param password
	 * @return
	 * @throws Exception
	 */
	private static KeyStore getKeyStore(String keyStorePath, String alias,
			String password) throws Exception {
		FileInputStream is = new FileInputStream(keyStorePath);
		KeyStore ks = KeyStore.getInstance(KEY_STORE);
		ks.load(is, password.toCharArray());
		is.close();
		return ks;
	}

	/**
	 * 验证Certificate
	 * 
	 * @param certificatePath
	 * @return
	 */
	public static boolean verifyCertificate(String certificatePath) {
		return verifyCertificate(new Date(), certificatePath);
	}

	/**
	 * 验证Certificate是否过期或无效
	 * 
	 * @param date
	 * @param certificatePath
	 * @return
	 */
	public static boolean verifyCertificate(Date date, String certificatePath) {
		boolean status = true;
		try {
			// 取得证书
			Certificate certificate = getCertificate(certificatePath);
			// 验证证书是否过期或无效
			status = verifyCertificate(date, certificate);
		} catch (Exception e) {
			status = false;
		}
		return status;
	}

	/**
	 * 验证公钥是否同属该证书
	 * 
	 * @param publicKey
	 * @param certificatePath
	 * @return
	 */
	public static boolean verifyPublicKey(String publicKey,
			String certificatePath) {
		boolean status = true;
		try {
			Certificate certificate = getCertificate(certificatePath);

			// 对公钥解密
			byte[] keyBytes = decryptBASE64(publicKey);

			// 取得公钥
			X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
			KeyFactory keyFactory = KeyFactory.getInstance(certificate
					.getPublicKey().getAlgorithm());
			PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

			certificate.verify(pubKey);

		} catch (Exception e) {
			status = false;
		}
		return status;
	}

	/**
	 * 验证证书是否过期或无效
	 * 
	 * @param date
	 * @param certificate
	 * @return
	 */
	private static boolean verifyCertificate(Date date, Certificate certificate) {
		boolean status = true;
		try {
			X509Certificate x509Certificate = (X509Certificate) certificate;
			x509Certificate.checkValidity(date);
		} catch (Exception e) {
			status = false;
		}
		return status;
	}

	/**
	 * 签名
	 * @param keyStorePath
	 * @param privateKey
	 * @param alias
	 * @param password
	 * @return
	 * @throws Exception
	 */
	public static String sign(byte[] sign, String keyStorePath, String privateKey,
			String alias, String password) throws Exception {
		// 获得证书
		X509Certificate x509Certificate = (X509Certificate) getCertificate(
				keyStorePath, alias, password);
		// 解密由base64编码的私钥
		byte[] keyBytes = decryptBASE64(privateKey);

		// 构造PKCS8EncodedKeySpec对象
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

		// 由证书公钥获得对应加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(x509Certificate
				.getPublicKey().getAlgorithm());

		// 获取私钥
		PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 构建签名
		Signature signature = Signature.getInstance(x509Certificate
				.getSigAlgName());
		signature.initSign(priKey);
		signature.update(sign);
		return encryptBASE64(signature.sign());
	}

	/**
	 * 验证签名
	 * 
	 * @param data
	 * @param sign
	 * @param certificatePath
	 * @return
	 * @throws Exception
	 */
	public static boolean verify(byte[] data, String sign,
			String certificatePath) throws Exception {
		// 获得证书
		X509Certificate x509Certificate = (X509Certificate) getCertificate(certificatePath);
		// 获得公钥
		PublicKey publicKey = x509Certificate.getPublicKey();
		// 构建签名
		Signature signature = Signature.getInstance(x509Certificate
				.getSigAlgName());
		signature.initVerify(publicKey);
		signature.update(data);

		return signature.verify(decryptBASE64(sign));

	}

	/**
	 * 验证Certificate
	 * 
	 * @param keyStorePath
	 * @param alias
	 * @param password
	 * @return
	 */
	public static boolean verifyCertificate(Date date, String keyStorePath,
			String alias, String password) {
		boolean status = true;
		try {
			Certificate certificate = getCertificate(keyStorePath, alias,
					password);
			status = verifyCertificate(date, certificate);
		} catch (Exception e) {
			status = false;
		}
		return status;
	}

	/**
	 * 验证Certificate
	 * 
	 * @param keyStorePath
	 * @param alias
	 * @param password
	 * @return
	 */
	public static boolean verifyCertificate(String keyStorePath, String alias,
			String password) {
		return verifyCertificate(new Date(), keyStorePath, alias, password);
	}
}

再给出一个测试类：

Java代码

1. import static org.junit.Assert.*;   
2.   
3. import org.junit.Before;   
4. import org.junit.Test;   
5.   
6. /**  
7.  *   
8.  * @author 梁栋  
9.  * @version 1.0  
10.  * @since 1.0  
11.  */  
12. public class CertificateCoderTest {   
13.     private String publicKey;   
14.     private String privateKey;   
15.     private String password = "123456";   
16.     private String alias = "tomcat";   
17.     private String certificatePath = "D:/tomcat.cer";   
18.     private String keyStorePath = "D:/.keystore";   
19.   
20.     @Before  
21.     public void setUp() throws Exception {   
22.         publicKey = CertificateCoder.getPublicKey(certificatePath);   
23.         privateKey = CertificateCoder.getPrivateKey(keyStorePath, alias,   
24.                 password);   
25.         System.err.println("公钥: \n\r" + publicKey);   
26.         System.err.println("私钥： \n\r" + privateKey);   
27.   
28.     }   
29.   
30.     @Test  
31.     public void test() throws Exception {   
32.         System.err.println("公钥加密——私钥解密");   
33.         String inputStr = "Ceritificate";   
34.         byte[] data = inputStr.getBytes();   
35.   
36.         byte[] encrypt = RSACoder.encryptByPublicKey(data, publicKey);   
37.   
38.         byte[] decrypt = RSACoder.decryptByPrivateKey(encrypt, privateKey);   
39.         String outputStr = new String(decrypt);   
40.   
41.         System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);   
42.   
43.         // 验证数据一致   
44.         assertArrayEquals(data, decrypt);   
45.   
46.         // 验证证书有效   
47.         assertTrue(CertificateCoder.verifyCertificate(certificatePath));   
48.   
49.         // 验证证书公钥匹配   
50.         assertTrue(CertificateCoder.verifyPublicKey(publicKey, certificatePath));   
51.   
52.     }   
53.   
54.     @Test  
55.     public void testSign() throws Exception {   
56.         System.err.println("私钥加密——公钥解密");   
57.   
58.         String inputStr = "sign";   
59.         byte[] data = inputStr.getBytes();   
60.   
61.         byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);   
62.   
63.         byte[] decodedData = RSACoder   
64.                 .decryptByPublicKey(encodedData, publicKey);   
65.   
66.         String outputStr = new String(decodedData);   
67.         System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);   
68.         assertEquals(inputStr, outputStr);   
69.   
70.         System.err.println("私钥签名——公钥验证签名");   
71.         // 产生签名   
72.         String sign = CertificateCoder.sign(encodedData, keyStorePath, privateKey,   
73.                 alias, password);   
74.         System.err.println("签名:\r" + sign);   
75.   
76.         // 验证签名   
77.         boolean status = CertificateCoder.verify(encodedData, sign, certificatePath);   
78.         System.err.println("状态:\r" + status);   
79.         assertTrue(status);   
80.   
81.     }   
82. }  

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

/**
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public class CertificateCoderTest {
	private String publicKey;
	private String privateKey;
	private String password = "123456";
	private String alias = "tomcat";
	private String certificatePath = "D:/tomcat.cer";
	private String keyStorePath = "D:/.keystore";

	@Before
	public void setUp() throws Exception {
		publicKey = CertificateCoder.getPublicKey(certificatePath);
		privateKey = CertificateCoder.getPrivateKey(keyStorePath, alias,
				password);
		System.err.println("公钥: \n\r" + publicKey);
		System.err.println("私钥： \n\r" + privateKey);

	}

	@Test
	public void test() throws Exception {
		System.err.println("公钥加密——私钥解密");
		String inputStr = "Ceritificate";
		byte[] data = inputStr.getBytes();

		byte[] encrypt = RSACoder.encryptByPublicKey(data, publicKey);

		byte[] decrypt = RSACoder.decryptByPrivateKey(encrypt, privateKey);
		String outputStr = new String(decrypt);

		System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);

		// 验证数据一致
		assertArrayEquals(data, decrypt);

		// 验证证书有效
		assertTrue(CertificateCoder.verifyCertificate(certificatePath));

		// 验证证书公钥匹配
		assertTrue(CertificateCoder.verifyPublicKey(publicKey, certificatePath));

	}

	@Test
	public void testSign() throws Exception {
		System.err.println("私钥加密——公钥解密");

		String inputStr = "sign";
		byte[] data = inputStr.getBytes();

		byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);

		byte[] decodedData = RSACoder
				.decryptByPublicKey(encodedData, publicKey);

		String outputStr = new String(decodedData);
		System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
		assertEquals(inputStr, outputStr);

		System.err.println("私钥签名——公钥验证签名");
		// 产生签名
		String sign = CertificateCoder.sign(encodedData, keyStorePath, privateKey,
				alias, password);
		System.err.println("签名:\r" + sign);

		// 验证签名
		boolean status = CertificateCoder.verify(encodedData, sign, certificatePath);
		System.err.println("状态:\r" + status);
		assertTrue(status);

	}
}

控制台输出：

Console代码

1. 公钥:    
2.   
3. MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDBQ/VMxf5Sb+urKceu5Ja4GfxHso+i+CCpQV2c   
4. W/O0yyu6u//7emmbwQGV3BLvaq9hEav1yGdvBteITS+mKMQFr2vFMsxhs+Dh82haQF2CXm11KtOg   
5. 2cjN6zgRmPVdYndVjeq7I9z+lkyHYZsOFUGr+oiPcas2Y9fa07TEfM4LXwIDAQAB   
6.   
7. 私钥：    
8.   
9. MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAMFD9UzF/lJv66spx67klrgZ/Eey   
10. j6L4IKlBXZxb87TLK7q7//t6aZvBAZXcEu9qr2ERq/XIZ28G14hNL6YoxAWva8UyzGGz4OHzaFpA   
11. XYJebXUq06DZyM3rOBGY9V1id1WN6rsj3P6WTIdhmw4VQav6iI9xqzZj19rTtMR8zgtfAgMBAAEC   
12. gYEAlB0y932d5SvlHy5L3JtPbxRrJb+RGUK0NULlLRnDckFq6BeAnQg5u6Z1QpaA5H+MnQXgFeNa   
13. cdp6f/k3lU4UuzgGbt0A31hRlR7J0WjsutkrDJp4h6PD9OIJSblv2T+h7KHzMKY7kx8dn4CIg2Cm   
14. 9NCyJWmhglGaf4Nl/6e4FdECQQD18SLbOxndmyHd5OU88oIY/qAyngQJIqcyHOwgwcLd5G/M3h0H   
15. bEj2fEKa4y2EG1xCH4MQSu0aRrR+ihv+thRjAkEAyStUwkyaNUE06ioGWCYu26QTcLyRwMyuVTcE   
16. jLbD6wRLF7A3gx9dgSV8mO1VqJ1G9y379YenzLz89MFHOTwn1QJBALNEcx3NtIrdexAcuiN0uPOz   
17. Fd4PY+2svqY+grdVxM6spfl0pUA14/EWng38Lb8vmk3wXj5P/we6JfJehQ1idvUCQQCTohkx/sWt   
18. D42ly/Gb/2mkB2W89qaAt7W5FAdivT5K23vAhrI2qG4WuUwXbxXOCJ5sCHNAXa3ns0pw1OdQObWB   
19. AkBm7JAy3jUh6xiEdI+SWnJ9V/k5bqenkN930uDFdqc6FzfOTgd3RVnckfpdCkEmo8AmeUQZwZ3y   
20. g4Xlfjray07N   
21.   
22. 公钥加密——私钥解密   
23. 加密前: Ceritificate   
24.   
25. 解密后: Ceritificate   
26. 公钥:    
27.   
28. MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDBQ/VMxf5Sb+urKceu5Ja4GfxHso+i+CCpQV2c   
29. W/O0yyu6u//7emmbwQGV3BLvaq9hEav1yGdvBteITS+mKMQFr2vFMsxhs+Dh82haQF2CXm11KtOg   
30. 2cjN6zgRmPVdYndVjeq7I9z+lkyHYZsOFUGr+oiPcas2Y9fa07TEfM4LXwIDAQAB   
31.   
32. 私钥：    
33.   
34. MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAMFD9UzF/lJv66spx67klrgZ/Eey   
35. j6L4IKlBX