数字证书及安全加密（一）数字证书基础知识

本篇博文内容摘自其他网络资料。

引用

http://www.cnblogs.com/lzjsky/archive/2010/09/29/1838240.html
http://snowolf.iteye.com/blog/735294

1.名词解释
SSL
安全套接层（Secure Sockets Layer，SSL）是一种安全协议，在网景公司（Netscape）推出首版Web浏览器的同时提出，目的是为网络通信提供安全及数据完整性保障，SSL在传输层中对网络通信进行加密。
SSL采用公开密钥技术，保证两个应用间通信的保密性和可靠性，使客户与服务器应用之间的通信不被攻击者窃 听。它在服务器和客户机两端可同时被支持，目前已成为互联网上保密通讯的工业标准。现行的Web浏览器亦普遍将HTTP和SSL相结合，从而实现安全通信。此协议其继任者是TLS。
这种协议在Web上获得了广泛的应用。IETF（www.ietf.org）将SSL作了标准化，即RFC2246，并将其称为TLS（Transport Layer Security），其最新版本是RFC 5246，版本1.2。从技术上讲，TLS1.0与SSL3.0的差异非常微小。
TLS
传输层安全（Transport Layer Security，TLS）利用密钥算法在互联网上提供端点身份认证与通讯保密，其基础是公钥基础设施（public key infrastructure，PKI）。不过在实现的典型例子中，只有网络服务者被可靠身份验证，而其客户端则不一定。这是因为公钥基础设施普遍商业运营，电子签名证书通常需要付费购买。协议的设计在某种程度上能够使主从式架构应用程序通讯本身预防窃 听、干扰（Tampering）和消息伪造。
HTTPS
超文本传输安全协议（缩写：HTTPS，英语：Hypertext Transfer Protocol Secure）是超文本传输协议和SSL/TLS的组合，用以提供加密通讯及对网络服务器身份的鉴定。HTTPS连接经常被用于万维网上的交易支付和企业信息系统中敏感信息的传输。
CA
数字证书认证机构（CA, Certificate Authority），也称为电子商务认证中心、电子商务认证授权机构，是负责发放和管理数字证书的权威机构，并作为电子商务交易中受信任的第三方，承担公钥体系中公钥的合法性检验的责任。
证书的内容包括：电子签证机关的信息、公钥用户信息、公钥、权威机构的签字和有效期等等。

2.证书格式
常见的证书格式有jks,cer,p12,pem等，证书文件后缀名也有.cer,.crt,.keystore,.pfx等多种，每种格式和后缀有什么区别，之间又有什么联系呢？

在Security编程中，有几种典型的密码交换信息文件格式:
DER-encoded certificate: .cer, .crt
PEM-encoded message: .pem
PKCS#12 Personal Information Exchange: .pfx, .p12
PKCS#10 Certification Request: .p10
PKCS#7 cert request response: .p7r
PKCS#7 binary message: .p7b

cer后缀的证书文件有两种编码-->DER二进制编码或者BASE64编码(也就是.pem) 。.cer/.crt是用于存放证书，它是2进制形式存放的，不含私钥。
.pem跟crt/cer的区别是它以Ascii来表示。
pfx/p12用于存放个人证书/私钥，他通常包含保护密码，2进制方式
p10是证书请求
p7r是CA对证书请求的回复，只用于导入
p7b以树状展示证书链(certificate chain)，同时也支持单个证书，不含私钥，里面包括一到多个证书。

X.509定义了两种证书：公钥证书和属性证书  
  PKCS#7和PKCS#12使用的都是公钥证书  
  PKCS＃7的SignedData的一种退化形式可以分发公钥证书和CRL  
  一个SignedData可以包含多张公钥证书  
  PKCS＃12可以包含公钥证书及其私钥，也可包含整个证书链  

如何从p12/pfx文件中提取密钥对及其长度：
1，首先，读取pfx/p12文件（需要提供保护密码）
2，通过别名(Alias,注意，所有证书中的信息项都是通过Alias来提取的)提取你想要分析的证书链
3，再将其转换为一个以X509证书结构体
4，提取里面的项，如果那你的证书项放在第一位（单一证书），直接读取 x509Certs[0]（见下面的代码）这个X509Certificate对象
5，X509Certificate对象有很多方法，读取RSA密钥（公私钥）及其长度如下：
            X509Certificate keyPairCert = x509Certs[0];
            int iKeySize = X509CertUtil.getCertificateKeyLength(keyPairCert);
            System.out.println("证书密钥算法="+keyPairCert.getPublicKey().getAlgorithm());
            System.out.println("证书密钥长度="+iKeySize);
可提取到需要的信息。

3.java keytool
简介
Java自带的keytool工具是个密钥和证书管理工具。它使用户能够管理自己的公钥/私钥对及相关证书，用于（通过数字签名）自我认证（用户向别的用户/服务认证自己）或数据完整性以及认证服务。它还允许用户储存他们的通信对等者的公钥（以证书形式）。
keytool 将密钥和证书储存在一个所谓的密钥仓库（keystore）中。缺省的密钥仓库实现将密钥仓库实现为一个文件。它用口令来保护私钥。
Java KeyStore的类型
JKS和JCEKS是Java密钥库(KeyStore)的两种比较常见类型(共有5种，JKS, JCEKS, PKCS12, BKS，UBER)，java读取KeyStore时缺省类型是JKS。
JKS的Provider是SUN，在每个版本的JDK中都有，JCEKS的Provider是SUNJCE，1.4后我们都能够直接使用它。
JCEKS在安全级别上要比JKS强，使用的Provider是JCEKS(推荐)，尤其在保护KeyStore中的私钥上（使用TripleDes）。
PKCS#12是公钥加密标准，它规定了可包含所有私钥、公钥和证书。其以二进制格式存储，也称为 PFX 文件，在windows中可以直接导入到密钥区，注意，PKCS#12的密钥库保护密码同时也用于保护Key。
BKS 来自BouncyCastle Provider，它使用的也是TripleDES来保护密钥库中的Key，它能够防止证书库被不小心修改（Keystore的keyentry改掉1个 bit都会产生错误），BKS能够跟JKS互操作，读者可以用Keytool去TryTry。
UBER比较特别，当密码是通过命令行提供的时候，它只能跟keytool交互。整个keystore是通过PBE/SHA1/Twofish加密，因此keystore能够防止被误改、察看以及校验。以前，Sun JDK(提供者为SUN)允许你在不提供密码的情况下直接加载一个Keystore，类似cacerts，UBER不允许这种情况。
使用
java keytool位置为<JAVA_HOME>\bin\keytool.exe

cd %JAVA_HOME%/bin

生成P12格式证书

keytool -genkey -v -alias client -keyalg RSA -storetype PKCS12 -keystore D:/lib/client.p12 -storepass client

导出CER格式证书

keytool -export -v -alias client -keystore D:/lib/client.p12 -storetype PKCS12 -rfc -file D:/lib/client.cer -storepass client

导入CER格式证书至JKS证书库

keytool -import -v -file D:/lib/client.cer -keystore D:/lib/servertrust.keystore -alias client -keypass client -storepass servertrust

查看JKS证书库

keytool -list -v -keystore D:/lib/servertrust.keystore -storepass servertrust

参数说明

-genkey 在用户主目录中创建一个默认文件”.keystore”,还会产生一个mykey的别名，mykey中包含用户的公钥、私钥和证书(在没有指定生成位置的情况下,keystore会存在用户系统默认目录)
-alias 产生别名 每个keystore都关联这一个独一无二的alias，这个alias通常不区分大小写
-keystore 指定密钥库的名称(产生的各类信息将不在.keystore文件中)
-keyalg 指定密钥的算法 (如 RSA DSA，默认值为：DSA)
-validity 指定创建的证书有效期多少天(默认 90)
-keysize 指定密钥长度 （默认 1024）
-storepass 指定密钥库的密码(获取keystore信息所需的密码)
-keypass 指定别名条目的密码(私钥的密码)
-dname 指定证书发行者信息 其中： “CN=名字与姓氏,OU=组织单位名称,O=组织名称,L=城市或区域名 称,ST=州或省份名称,C=单位的两字母国家代码”
-list 显示密钥库中的证书信息 keytool -list -v -keystore 指定keystore -storepass 密码
-v 显示密钥库中的证书详细信息
-export 将别名指定的证书导出到文件 keytool -export -alias 需要导出的别名 -keystore 指定keystore -file 指定导出的证书位置及证书名称 -storepass 密码
-file 参数指定导出到文件的文件名
-delete 删除密钥库中某条目 keytool -delete -alias 指定需删除的别 -keystore 指定keystore – storepass 密码
-printcert 查看导出的证书信息 keytool -printcert -file g:\sso\michael.crt
-keypasswd 修改密钥库中指定条目口令 keytool -keypasswd -alias 需修改的别名 -keypass 旧密码 -new 新密码 -storepass keystore密码 -keystore sage
-storepasswd 修改keystore口令 keytool -storepasswd -keystore g:\sso\michael.keystore(需修改口令的keystore) -storepass pwdold(原始密码) -new pwdnew(新密码)
-import 将已签名数字证书导入密钥库 keytool -import -alias 指定导入条目的别名 -keystore 指定keystore -file 需导入的证书

4.其他格式证书导入
p12格式
JKS和PKCS#12都是比较常用的两种密钥库格式/标准。JKS文件（通常为*.jks或*.keystore，扩展名无关）可以通过Java原生工具——KeyTool生成；而后者PKCS#12文件（通常为*.p12或*.pfx，意味个人信息交换文件），则是通过更为常用的OpenSSL工具产生。
两者之间是可以通过导入/导出的方式进行转换的，这种转换需要通过KeyTool工具进行，但keytool也无法直接导入PKCS12文件。
第一种方法是使用IE将pfx证书导入，再导出为cert格式文件。使用上面介绍的方法将其导入到密钥仓库中。这样的话仓库里面只包含了证书信息，没有私钥内容。
第二种方法是将pfx文件导入到IE浏览器中，再导出为pfx文件。
       新生成的pfx不能被导入到keystore中，报错：keytool错误： java.lang.Exception: 所输入的不是一个 X.509 认证。新生成的pfx文件可以被当作keystore使用。但会报个错误as unknown attr1.3.6.1.4.1.311.17.1,查了下资料,说IE导出的就会这样,使用Netscape就不会有这个错误.
第三种方法是将pfx文件当作一个keystore使用。但是通过微软的证书管理控制台生成的pfx文件不能直接使用。keytool不认此格式，报keytool错误： java.io.IOException: failed to decrypt safe contents entry。需要通过OpenSSL转换一下：

openssl pkcs12 -in mycerts.pfx -out mycerts.pem 
openssl pkcs12 -export -in mycerts.pem -out mykeystore.p12

通过keytool的-list命令可检查下密钥仓库中的内容：

keytool -rfc -list -keystore mykeystore.p12 -storetype pkcs12

这里需要指明仓库类型为pkcs12，因为缺省的类型为jks。这样此密钥仓库就即包含证书信息也包含私钥信息。
P7B格式
keytool无法直接导入p7b文件。
需要将证书链RootServer.p7b（包含根证书）导出为根rootca.cer和子rootcaserver.cer 。
将这两个证书导入到可信任的密钥仓库中。

keytool -import -alias rootca -trustcacerts -file rootca.cer -keystore testkeytrust.jks

遇到是否信任该证书提示时，输入y

keytool -import -alias rootcaserver -trustcacerts -file rootcaserver.cer -keystore testkeytrust.jks

5.加解密及签名验证
以下内容引用自snowolf的博文http://snowolf.iteye.com/blog/735294

对于jks格式的数字证书，可以直接使用代码读取证书内信息并使用，但对于p12证书则需要用到上面的导入命令执行以下方案
[list]

a.通过keytool密钥库导入命令importkeystore，将密钥库格式由PKCS#12转换为JKS。

keytool -importkeystore -v  -srckeystore server.pfx -srcstoretype pkcs12 -srcstorepass password -destkeystore server.jks -deststoretype jks -deststorepass password 

b.检索新生成的密钥库文件，提取别名信息。

c.由密钥库文件导出数字证书（这里将用到别名）。

d.通过代码提取公钥/私钥、签名算法等|

[/list]
abc三步使用前文提供的方法，这里直接给出提取公钥/私钥，使用密钥对加解密及签名验证的代码

/**
 * 2010-8-11
 */

import java.io.FileInputStream;
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.util.Date;

import javax.crypto.Cipher;

/**
 * 证书操作类
 * 
 * @author <a href="mailto:[e-mail]">梁栋</a>
 * @since 1.0
 */
public class CertificateCoder {
	/**
	 * 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 keyStorePassword
	 * @param alias
	 * @param aliasPassword
	 * @return
	 * @throws Exception
	 */
	private static PrivateKey getPrivateKey(String keyStorePath,
			String keyStorePassword, String alias, String aliasPassword)
			throws Exception {
		KeyStore ks = getKeyStore(keyStorePath, keyStorePassword);
		PrivateKey key = (PrivateKey) ks.getKey(alias,
				aliasPassword.toCharArray());
		return key;
	}

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

	/**
	 * 获得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 keyStorePassword
	 * @param alias
	 * @return
	 * @throws Exception
	 */
	private static Certificate getCertificate(String keyStorePath,
			String keyStorePassword, String alias) throws Exception {
		KeyStore ks = getKeyStore(keyStorePath, keyStorePassword);
		Certificate certificate = ks.getCertificate(alias);

		return certificate;
	}

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

	/**
	 * 私钥加密
	 * 
	 * @param data
	 * @param keyStorePath
	 * @param keyStorePassword
	 * @param alias
	 * @param aliasPassword
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPrivateKey(byte[] data, String keyStorePath,
			String keyStorePassword, String alias, String aliasPassword)
			throws Exception {
		// 取得私钥
		PrivateKey privateKey = getPrivateKey(keyStorePath, keyStorePassword,
				alias, aliasPassword);

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

		return cipher.doFinal(data);

	}

	/**
	 * 私钥解密
	 * 
	 * @param data
	 * @param keyStorePath
	 * @param alias
	 * @param keyStorePassword
	 * @param aliasPassword
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPrivateKey(byte[] data, String keyStorePath,
			String alias, String keyStorePassword, String aliasPassword)
			throws Exception {
		// 取得私钥
		PrivateKey privateKey = getPrivateKey(keyStorePath, keyStorePassword,
				alias, aliasPassword);

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

		return cipher.doFinal(data);

	}

	/**
	 * 公钥加密
	 * 
	 * @param data
	 * @param certificatePath
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPublicKey(byte[] data, String certificatePath)
			throws Exception {

		// 取得公钥
		PublicKey publicKey = getPublicKey(certificatePath);
		// 对数据加密
		Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, publicKey);

		return cipher.doFinal(data);

	}

	/**
	 * 公钥解密
	 * 
	 * @param data
	 * @param certificatePath
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPublicKey(byte[] data, String certificatePath)
			throws Exception {
		// 取得公钥
		PublicKey publicKey = getPublicKey(certificatePath);

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

		return cipher.doFinal(data);

	}

	/**
	 * 验证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 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 alias
	 * @param keyStorePassword
	 * @param aliasPassword
	 * @return
	 * @throws Exception
	 */
	public static byte[] sign(byte[] sign, String keyStorePath, String alias,
			String keyStorePassword, String aliasPassword) throws Exception {
		// 获得证书
		X509Certificate x509Certificate = (X509Certificate) getCertificate(
				keyStorePath, keyStorePassword, alias);

		// 取得私钥
		PrivateKey privateKey = getPrivateKey(keyStorePath, keyStorePassword,
				alias, aliasPassword);

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

	/**
	 * 验证签名
	 * 
	 * @param data
	 * @param sign
	 * @param certificatePath
	 * @return
	 * @throws Exception
	 */
	public static boolean verify(byte[] data, byte[] 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(sign);

	}

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

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

测试类

import static org.junit.Assert.*;

import java.util.Date;

import org.apache.commons.codec.binary.Hex;
import org.junit.Test;

/**
 * 证书操作验证类
 * 
 * @author <a href="mailto:[e-mail]">梁栋</a>
 * @version 1.0
 * @since 1.0
 */
public class CertificateCoderTest {
	private String certificatePath = "zlex.crt";
	private String keyStorePath = "zlex.keystore";
	private String keyStorePassword = "123456";
	private String aliasPassword = "123456";
	private String alias = "1";

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

		byte[] encrypt = CertificateCoder.encryptByPublicKey(data,
				certificatePath);

		byte[] decrypt = CertificateCoder.decryptByPrivateKey(encrypt,
				keyStorePath, alias, keyStorePassword, aliasPassword);
		String outputStr = new String(decrypt);

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

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

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

	}

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

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

		byte[] encodedData = CertificateCoder.encryptByPrivateKey(data,
				keyStorePath, keyStorePassword, alias, aliasPassword);

		byte[] decodedData = CertificateCoder.decryptByPublicKey(encodedData,
				certificatePath);

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

		System.err.println("私钥签名——公钥验证签名");
		// 产生签名
		byte[] sign = CertificateCoder.sign(encodedData, keyStorePath, alias,
				keyStorePassword, aliasPassword);
		System.err.println("签名:\r" + Hex.encodeHexString(sign));

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

	@Test
	public void testVerify() throws Exception {
		System.err.println("密钥库证书有效期验证");
		boolean status = CertificateCoder.verifyCertificate(new Date(),
				keyStorePath, keyStorePassword, alias);
		System.err.println("证书状态:\r" + status);
		assertTrue(status);
	}
}

修改以下属性
certificatePath：公钥证书路径
keyStorePath：证书库路径
keyStorePassword：证书库密码
alias：别名
aliasPassword：别名密码
运行后可以看到junit测试全部通过，控制台输出加解密信息和签名验证信息。
在CertificateCoder类的getPrivateKey和getPublicKey方法中加入输出信息可以看到私钥和公钥。