Java加密技术（十二）——*.PFX(*.p12)&个人信息交换文件

今天来点实际工作中的硬通货！

与计费系统打交道，少不了用到加密/解密实现。为了安全起见，通过非对称加密交换对称加密密钥更是不可或缺。那么需要通过什么载体传递非对称算法公钥/私钥信息？数字证书是公钥的载体，而密钥库可以包含公钥、私钥信息。

JKS和
PKCS#12都是比较常用的两种密钥库格式/标准。对于前者，搞Java开发，尤其是接触过HTTPS平台的朋友，并不陌生。
JKS文件（通常为*.jks或*.keystore，扩展名无关）可以通过Java原生工具——KeyTool生成；而后者
PKCS#12文件（通常为*.p12或*.pfx，意味个人信息交换文件），则是通过更为常用的OpenSSL工具产生。

当然，这两者之间是可以通过导入/导出的方式进行转换的！当然，这种转换需要通过KeyTool工具进行！

回归正题，计费同事遇到一个难题：合作方交给他们一个*.pfx文件，需要他们从中提取密钥，然后进行加密交互。其实，通过Java直接操作密钥库文件（或个人信息交换文件）对于一般Java开发人员来说，这都是个冷门。不接触数字安全，根本不知所云。况且，Java原生的密钥库文件格式为JKS，如何操作*.pfx文件？密钥库操作需要获知密钥库别名，*.pfx别名是什么？！接下来就解决这些问题！

方案：

  1. 通过keytool密钥库导入命令importkeystore，将密钥库格式由PKCS#12转换为JKS。
  2. 检索新生成的密钥库文件，提取别名信息。
  3. 由密钥库文件导出数字证书（这里将用到别名）。
  4. 通过代码提取公钥/私钥、签名算法等

先看格式转换：

Cmd代码
 

  1. echo 格式转换
  2. keytool -importkeystore -v  -srckeystore zlex.pfx -srcstoretype pkcs12 -srcstorepass 123456 -destkeystore zlex.keystore -deststoretype jks -deststorepass 123456
echo 格式转换
keytool -importkeystore -v  -srckeystore zlex.pfx -srcstoretype pkcs12 -srcstorepass 123456 -destkeystore zlex.keystore -deststoretype jks -deststorepass 123456

-importkeystore导入密钥库，通过格式设定，我们可以将PKCS#12文件转换为JKS格式。

-v显示详情

-srckeystore源密钥库，这里是zlex.pfx

-srcstoretype源密钥库格式，这里为pkcs12

-srcstorepass源密钥库密码，这里为123456

-destkeystore目标密钥库，这里为zlex.keystore

-deststoretype目标密钥库格式，这里为jks，默认值也如此

-deststorepass目标密钥库密码，这里为123456

通过这个操作，我们能够获得所需的密钥库文件zlex.keystore。

这时，我们已经获得了密钥库文件，只要确定对应的别名信息，就可以提取公钥/私钥，以及数字证书，进行加密交互了！

Cmd代码
 

  1. echo 查看证书
  2. keytool -list -keystore zlex.keystore -storepass 123456 -v
echo 查看证书
keytool -list -keystore zlex.keystore -storepass 123456 -v

-list列举密钥库

-keystore密钥库，这里是zlex.keystore

-storepass密钥库密码，这里是123456

-v显示详情

这里需要细致观察一下别名信息！！！就是红框中的数字1！！！

现在，我们把证书导出！

Cmd代码
 

  1. echo 导出证书
  2. keytool -exportcert -alias 1 -keystore zlex.keystore -file zlex.crt -storepass 123456
echo 导出证书
keytool -exportcert -alias 1 -keystore zlex.keystore -file zlex.crt -storepass 123456

-exportcert导出证书

-alias别名，这里是1

-keystore密钥库，这里是zlex.keystore

-file证书文件，这里是zlex.crt

-storepass密钥库密码，这里是123456

现在证书也导出了，我们可以提取公钥/私钥，进行加密/解密，签名/验证操作了！当然，即便没有证书，我们也能够通过密钥库（JKS格式）文件获得证书，以及公钥/私钥、签名算法等。

补充代码， 其实就是对
Java加密技术（八）的修改！

Java代码
 

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

相信上述代码已经帮朋友们解决了相当多的问题！

给出测试类：

Java代码
 

  1. import static org.junit.Assert.*;
  2. import java.util.Date;
  3. import org.apache.commons.codec.binary.Hex;
  4. import org.junit.Test;
  5. /**
  6. * 证书操作验证类
  7. *
  8. * @author <a href="mailto:[email protected]">梁栋</a>
  9. * @version 1.0
  10. * @since 1.0
  11. */
  12. public class CertificateCoderTest {
  13. private String certificatePath = "zlex.crt";
  14. private String keyStorePath = "zlex.keystore";
  15. private String keyStorePassword = "123456";
  16. private String aliasPassword = "123456";
  17. private String alias = "1";
  18. @Test
  19. public void test() throws Exception {
  20. System.err.println("公钥加密——私钥解密");
  21. String inputStr = "Ceritifcate";
  22. byte[] data = inputStr.getBytes();
  23. byte[] encrypt = CertificateCoder.encryptByPublicKey(data,
  24. certificatePath);
  25. byte[] decrypt = CertificateCoder.decryptByPrivateKey(encrypt,
  26. keyStorePath, alias, keyStorePassword, aliasPassword);
  27. String outputStr = new String(decrypt);
  28. System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
  29. // 验证数据一致
  30. assertArrayEquals(data, decrypt);
  31. // 验证证书有效
  32. assertTrue(CertificateCoder.verifyCertificate(certificatePath));
  33. }
  34. @Test
  35. public void testSign() throws Exception {
  36. System.err.println("私钥加密——公钥解密");
  37. String inputStr = "sign";
  38. byte[] data = inputStr.getBytes();
  39. byte[] encodedData = CertificateCoder.encryptByPrivateKey(data,
  40. keyStorePath, keyStorePassword, alias, aliasPassword);
  41. byte[] decodedData = CertificateCoder.decryptByPublicKey(encodedData,
  42. certificatePath);
  43. String outputStr = new String(decodedData);
  44. System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
  45. assertEquals(inputStr, outputStr);
  46. System.err.println("私钥签名——公钥验证签名");
  47. // 产生签名
  48. byte[] sign = CertificateCoder.sign(encodedData, keyStorePath, alias,
  49. keyStorePassword, aliasPassword);
  50. System.err.println("签名:\r" + Hex.encodeHexString(sign));
  51. // 验证签名
  52. boolean status = CertificateCoder.verify(encodedData, sign,
  53. certificatePath);
  54. System.err.println("状态:\r" + status);
  55. assertTrue(status);
  56. }
  57. @Test
  58. public void testVerify() throws Exception {
  59. System.err.println("密钥库证书有效期验证");
  60. boolean status = CertificateCoder.verifyCertificate(new Date(),
  61. keyStorePath, keyStorePassword, alias);
  62. System.err.println("证书状态:\r" + status);
  63. assertTrue(status);
  64. }
  65. }
import static org.junit.Assert.*;

import java.util.Date;

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

/**
 * 证书操作验证类
 *
 * @author <a href="mailto:[email protected]">梁栋</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);
	}
}

第一个测试方法，用于提取公钥/私钥进行加密/解密操作。

第二个测试方法，用于提取签名算法进行签名/验证操作。

第三个测试方法，用于测试密钥库该别名对应的证书，当前日期下，是否有效。

OK，任务完成，密钥成功提取，剩下的都是代码基本功了！

Java加密技术（十二）——*.PFX(*.p12)&个人信息交换文件

时间： 2024-08-19 07:30:33

Java加密技术（十二）——*.PFX(*.p12)&个人信息交换文件的相关文章

Java加密技术（二）——对称加密算法DES&AES

接下来我们介绍对称加密算法,最常用的莫过于DES数据加密算法. DES DES-Data Encryption Standard,即数据加密算法.是IBM公司于1975年研究成功并公开发表的.DES算法的入口参数有三个:Key.Data.Mode.其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密. DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位. 通过java

Java加密技术（二）对称加密算法DES&amp;AES

接下来我们介绍对称加密算法,最常用的莫过于DES数据加密算法. DES  DES-Data Encryption Standard,即数据加密算法.是IBM公司于1975年研究成功并公开发表的.DES算法的入口参数有三个:Key.Data.Mode.其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密. DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位. 通过jav

Java加密技术（一）——BASE64与单向加密算法MD5&amp;SHA&amp;MAC

http://snowolf.iteye.com/blog/379860 加密解密,曾经是我一个毕业设计的重要组件.在工作了多年以后回想当时那个加密.解密算法,实在是太单纯了.     言归正传,这里我们主要描述Java已经实现的一些加密解密算法,最后介绍数字证书.     如基本的单向加密算法: BASE64 严格地说,属于编码格式,而非加密算法 MD5(Message Digest algorithm 5,信息摘要算法) SHA(Secure Hash Algorithm,安全散列算法) H

Java加密技术（七）——非对称加密算法最高级ECC

ECC ECC-Elliptic Curves Cryptography,椭圆曲线密码编码学,是目前已知的公钥体制中,对每比特所提供加密强度最高的一种体制.在软件注册保护方面起到很大的作用,一般的序列号通常由该算法产生. 当我开始整理<Java加密技术(二)>的时候,我就已经在开始研究ECC了,但是关于Java实现ECC算法的资料实在是太少了,无论是国内还是国外的资料,无论是官方还是非官方的解释,最终只有一种答案--ECC算法在jdk1.5后加入支持,目前仅仅只能完成密钥的生成与解析. 如果想

Java加密技术（十）——单向认证

在 Java 加密技术(九)中,我们使用自签名证书完成了认证.接下来,我们使用第三方CA签名机构完成证书签名. 这里我们使用 thawte提供的测试用21天免费ca证书. 1.要在该网站上注明你的域名,这里使用 www.zlex.org作为测试用域名(请勿使用该域名作为你的域名地址,该域名受法律保护!请使用其他非注册域名!). 2.如果域名有效,你会收到邮件要求你访问 https://www.thawte.com/cgi/server/try.exe获得ca证书. 3.复述密钥库的创建. She

疯狂JAVA讲义---第十二章：Swing编程（五）进度条和滑动条

http://blog.csdn.net/terryzero/article/details/3797782 疯狂JAVA讲义---第十二章:Swing编程(五)进度条和滑动条 标签: swing编程java任务timerstring 2009-01-16 21:12 6722人阅读 评论(0) 收藏 举报  分类: J2SE(63)  版权声明:本文为博主原创文章,未经博主允许不得转载. 前几天讲了Swing基本的控件,今天开始讲特殊控件.一天讲2个吧,首先讲用JProgressBar,Pro

Java压缩技术（二） ZIP压缩——Java原生实现

原文:http://snowolf.iteye.com/blog/642298 去年整理了一篇ZLib算法Java实现(Java压缩技术(一) ZLib),一直惦记却没时间补充.今天得空,整理一下ZIP的java原生实现. 看了几篇zip压缩算法的帖子,讲的算是比较细致了,但就是没有对应的解压缩实现,太惜败了! 我就喜欢没事做总结,稍作整理,将其收纳! 相关链接: Java压缩技术(一) ZLib Java压缩技术(二) ZIP压缩——Java原生实现 Java压缩技术(三) ZIP解压缩——J

Java加密技术（八）——数字证书

本篇的主要内容为Java证书体系的实现. 请大家在阅读本篇内容时先阅读 Java加密技术(四),预先了解RSA加密算法. 在构建Java代码实现前,我们需要完成证书的制作. 1.生成keyStroe文件 在命令行下执行以下命令: Shell代码   keytool -genkey -validity 36000 -alias www.zlex.org -keyalg RSA -keystore d:\zlex.keystore keytool -genkey -validity 36000 -a

Java进阶(三十二) HttpClient使用详解

Java进阶(三十二) HttpClient使用详解 Http协议的重要性相信不用我多说了,HttpClient相比传统JDK自带的URLConnection,增加了易用性和灵活性(具体区别,日后我们再讨论),它不仅是客户端发送Http请求变得容易,而且也方便了开发人员测试接口(基于Http协议的),即提高了开发的效率,也方便提高代码的健壮性.因此熟练掌握HttpClient是很重要的必修内容,掌握HttpClient后,相信对于Http协议的了解会更加深入. 一.简介 HttpClient是A