数字证书

[b]KeyTool证书管理[/b]
KeyTool是Java中的数字证书管理工具，用于数字证书的申请、导入、导出和撤销等操作。KeyTool与本地密钥库相关联，将私钥存于密钥库，公钥则以数字证书输出。KeyTool位于%JDK_HOME%\bin目录中，需要通过命令行进行相应的操作。

1. 构建自签名证书
keytool -genkeypair -keyalg RSA -keysize 2048 -sigalg SHA1withRSA -validity
36000 -alias www.zlex.org -keystore zlex.keystore

各参数的含义如下所示：
-genkeypair 表示生成密钥。
-keyalg 指定密钥算法，这里指定为RSA算法。
-keysize 指定密钥长度，默认1024位，这里指定为2048位。
-sigalg 指定数字签名算法，这里指定为SHA1withRSA算法。
-validity 指定证书有效期，这里指定为36000天。
-alias 指定别名，这里是www.zlex.org。
-keystore 指定密钥库存储位置，这里是zlex.keystore。
KeyTool工具支持RSA和DSA共2种算法，且DSA算法为默认算法。


[b]导出数字证书[/b]
keytool -exportcert -alias www.zlex.org -keystore zlex.keystore -file zlex.cer -rfc

各参数的含义如下所示：
-exportcert 表示证书导出操作。
-alias 指定导别名，这里为www.zlex.org。
-keystore 指定密钥库文件，这里为zlex.keystore。
-file 指定导出文件路径，这里为zlex.cer。
-rfc 指定以Base64编码格式输出。


这里通过KeyTool工具直接导出的证书，是一个自签名的X.509第三版类型的根证书，并以
Base64编码保存。自签名证书虽然可以使用，但未经过CA机构认证，几乎没有任何法律效力。


[b]构建CA签发证书[/b]
如果要获取CA机构认证的数字证书，需要将数字证书签发申请（CSR）导出，经由CA机
构认证并颁发，同时将认证后的证书导入本地密钥库和信任库。

导出数字证书签发申请
keytool -certreq -alias www.zlex.org -keystore zlex.keystore -file zlex.csr -v

-certreq 表示数字证书申请操作。
-alias 指定别名，这里为www.zlex.org。
-keystore 指定密钥库文件，这里为zlex.keystore。
-file 指定导出文件路径，这里为zlex.csr。
-v 详细信息。


获得签发后的数字证书后，需要将其导入信任库。导入数字证书操作

导入数字证书
keytool -importcert -trustcacerts -alias www.zlex.org -file zlex.cer -keystore zlex.keystore


导入证书后，我们可以通过相关命令查看该证书，命令如下：
keytool -list -alias www.zlex.org -keystore zlex.keystore

各参数的含义如下所示：
-list 表示导入数字证书。
-alias 指定别名，这里为www.zlex.org。
-keystore 指定密钥库文件，这里为zlex.keystore。


[b]证书使用：[/b]
Java 6提供了完善的数字证书管理实现，仅通过操作密钥库和数字证书就可完成相应的加密/解密和签名/验证操作。密钥库管理私钥，数字证书管理公钥，私钥和密钥分属消息传递两方，进行加密消息传递

	public static PrivateKey getPrivateKeyByKeyStore(String keyStorePath,String alias,String password)

		throws Exception
    {

		//获取密钥库
		KeyStore ks=getKeyStore(keyStorePath, password);

		//获得私钥
		return (PrivateKey)ks.getKey(alias, password.toCharArray());


	}

// 由Certificate获得公钥

private static PublicKey getPublicKeyByCertificate(String certificatePath)
		throws Exception
	{

		//获得证书
		Certificate certificate=getCertificate(certificatePath);

		//获得公钥
		return certificate.getPublicKey();
	}

//获得Certificate

private static Certificate getCertificate(String certificatePath)
		throws Exception
	{

		CertificateFactory certificateFactory=CertificateFactory.getInstance(CERT_TYPE);

		FileInputStream in=new FileInputStream(certificatePath);

		Certificate certificate=certificateFactory.generateCertificate(in);

		in.close();

		return certificate;
	}

private static KeyStore getKeyStore(String keyStorePath,String password)

		throws Exception{

		//实例化密钥库
		KeyStore ks=KeyStore.getInstance(KeyStore.getDefaultType());

		//获得密钥库文件流
		FileInputStream is=new FileInputStream(keyStorePath);

		//加载密钥库
		ks.load(is,password.toCharArray());

		//关闭密钥库文件流
		is.close();

		return ks;
	}

私钥加密：

public static byte[] encryptByPrivateKey(byte[] data,String keyStorePath,String alias,String password)
		throws Exception
	{
		//获取私钥
		PrivateKey privateKey=getPrivateKeyByKeyStore(keyStorePath, alias, password);

		//对数据加密
		Cipher cipher=Cipher.getInstance(privateKey.getAlgorithm());

		cipher.init(Cipher.ENCRYPT_MODE, privateKey);

		return cipher.doFinal(data);

	}

//私钥解密

public static byte[] decryptByPrivateKey(byte[] data,String keyStorePath,String alias,String password)
		throws Exception
	{

		//获取私钥
		PrivateKey privateKey=getPrivateKeyByKeyStore(keyStorePath, alias, password);

		//对数据解密
		Cipher cipher=Cipher.getInstance(privateKey.getAlgorithm());

		cipher.init(Cipher.DECRYPT_MODE, privateKey);

		return cipher.doFinal(data);

	}

//公钥加密

public static byte[] encryptByPublicKey(byte[] data,String certificatePath)
		throws Exception
	{
		//取得公钥 
		PublicKey publicKey=getPublicKeyByCertificate(certificatePath);

		//对数据加密
		Cipher cipher=Cipher.getInstance(publicKey.getAlgorithm());

		cipher.init(Cipher.ENCRYPT_MODE, publicKey);

		return cipher.doFinal(data);

	}

//公钥解密

public static byte[] decryptByPublicKey(byte[] data,String certificatePath)
		throws Exception
	{
		//取得公钥
		PublicKey publicKey=getPublicKeyByCertificate(certificatePath);

		Cipher cipher=Cipher.getInstance(publicKey.getAlgorithm());

		cipher.init(Cipher.DECRYPT_MODE, publicKey);

		return cipher.doFinal(data);


	}

//签名

	public static byte[] sign(byte[] sign,String keyStorePath,String alias,String password)
		throws Exception
	{
		//获得证书
		X509Certificate x509Certificate=(X509Certificate)getCertificate(keyStorePath, alias, password);

		//构建签名，由证书指定签名算法
		Signature signature=Signature.getInstance(x509Certificate.getSigAlgName());

		//获取私钥
		PrivateKey privateKey=getPrivateKeyByKeyStore(keyStorePath, alias, password);

		//初始化签名，由私钥构建
		signature.initSign(privateKey);

		signature.update(sign);

		return signature.sign();



	}

//验证签名

public static boolean verify(byte[] data,byte[] sign,String certificatePath)
		throws Exception
	{

		//获得证书
		X509Certificate x509Certificate=(X509Certificate)getCertificate(certificatePath);

		//由证书构建签名
		Signature signature=Signature.getInstance(x509Certificate.getSigAlgName());

		//由证书初始化签名，实际上用到了证书中的公钥
		signature.initVerify(x509Certificate);

		signature.update(data);

		return signature.verify(sign);


	}

测试用例如下：

public class CertificateCoderTest {

	private String password = "100889";
	private String alias = "www.zlex.org";
	private String certificatePath = "E:/jdk1.6/bin/zlex.cer";
	private String keyStorePath = "E:/jdk1.6/bin/zlex,keystore";

	@Test
	public void test1() throws Exception
	{
		System.err.println("公钥加密-----私钥解密");
		String inputStr="数字签名";

		byte[] data=inputStr.getBytes();

		//公钥加密
		byte[] encrypt=CertificateCoder.encryptByPublicKey(data, certificatePath);

		//私钥解密
		byte[] decrypt=CertificateCoder.decryptByPrivateKey(encrypt, keyStorePath, alias, password); 

		String outputStr=new String(decrypt);

		System.out.println("--"+outputStr);
		System.err.println("加密前:\n"+inputStr);

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

		assertArrayEquals(data, decrypt);

	}



	/**
	* 私钥加密—公钥解密
	* @throws Exception
	*/
	@Test
	public void test2() throws Exception {
		System.err.println("私钥加密—公钥解密");
		String inputStr = "数字签名";
		byte[] data = inputStr.getBytes();
		// 私钥加密
		byte[] encodedData = CertificateCoder.encryptByPrivateKey(data,
		keyStorePath, alias, password);
		// 公钥加密
		byte[] decodedData = CertificateCoder.decryptByPublicKey(encodedData,
		certificatePath);
		String outputStr = new String(decodedData);
		System.err.println("加密前:\n" + inputStr);
		System.err.println("解密后:\n" + outputStr);
		assertEquals(inputStr, outputStr);
	}



	/**
	* 签名验证
	* @throws Exception
	*/
	@Test
	public void testSign() throws Exception 
	{
		String inputStr = "签名";
		byte[] data = inputStr.getBytes();
		System.err.println("私钥签名—公钥验证");
		// 产生签名
		byte[] sign = CertificateCoder.sign(data, keyStorePath, alias, password);
		System.err.println("签名:\n" + Hex.encodeHexString(sign));

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


		// 校验
		assertTrue(status);
	}

}