Java加密技能（八）

副标题#e#

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

请各人在阅读本篇内容时先阅读 Java加密技能（四），预先相识RSA加密算法。

在构建Java代码实现前，我们需要完成证书的建造。

1.生成keyStroe文件

在呼吁行下执行以下呼吁：

Shell代码

keytool　-genkey　-alias　www.zlex.org　-keyalg　RSA　-keystore　d:\zlex.keystore

个中

-genkey暗示生成密钥

-alias指定别名，这里是www.zlex.org

-keyalg指定算法，这里是RSA

-keystore指定存储位置，这里是d:\zlex.keystore

在这里我利用的暗码为 123456

节制台输出：

Console代码

输入keystore暗码：再次输入新暗码: 您的名字与姓氏是什么？　 [Unknown]：　www.zlex.org 您的组织单元名称是什么？　 [Unknown]：　zlex 您的组织名称是什么？　 [Unknown]：　zlex 您地址的都市或区域名称是什么？　 [Unknown]：　BJ 您地址的州或省份名称是什么？　 [Unknown]：　BJ 该单元的两字母国度代码是什么　 [Unknown]：　CN CN=www.zlex.org,　OU=zlex,　O=zlex,　L=BJ,　ST=BJ,　C=CN　正确吗？　 [否]：　Y 输入<tomcat>的主暗码　　　　（假如和　keystore　暗码沟通，按回车）：再次输入新暗码:

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

#p#副标题#e#

2.生成自签名证书

光有keyStore文件是不足的，还需要证书文件，证书才是直接提供应外界利用的公钥凭证。

导出证书：

Shell代码

keytool -export -keystore d：\zlex.keystore -alias www.zlex.org -file d：\zlex.cer -rfc

个中

-export指定为导出操纵

-keystore指定keystore文件

-alias指定导出keystore文件中的别名

-file指领导出路径

-rfc以文本名目输出，也就是以BASE64编码输出

这里的暗码是 123456

节制台输出：

Console代码

输入keystore暗码：生存在文件中的认证　<d:\zlex.cer>

虽然，利用方是需要注册证书的！

Ok，筹备事情完成，开始Java实现！

#p#副标题#e#

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

Java代码

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　梁栋

　 *　@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

　　　　　 */

　　　　 private　static　PrivateKey　getPrivateKey(String　keyStorePath,　String　alias,

　　　　　　　　　　　　 String　password)　throws　Exception　{

　　　　　　　　 KeyStore　ks　=　getKeyStore(keyStorePath,　password);

　　　　　　　　 PrivateKey　key　=　(PrivateKey)　ks.getKey(alias,　password.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　alias

　　　　　 *　@param　password

　　　　　 *　@return

　　　　　 *　@throws　Exception

　　　　　 */

　　　　 private　static　Certificate　getCertificate(String　keyStorePath,

　　　　　　　　　　　　 String　alias,　String　password)　throws　Exception　{

　　　　　　　　 KeyStore　ks　=　getKeyStore(keyStorePath,　password);

　　　　　　　　 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　alias

　　　　　 *　@param　password

　　　　　 *　@return

　　　　　 *　@throws　Exception

　　　　　 */

　　　　 public　static　byte[]　encryptByPrivateKey(byte[]　data,　String　keyStorePath,

　　　　　　　　　　　　 String　alias,　String　password)　throws　Exception　{

　　　　　　　　 //　取得私钥

　　　　　　　　 PrivateKey　privateKey　=　getPrivateKey(keyStorePath,　alias,　password);
　　　　　　　　 //　对数据加密

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

　　　　　　　　 cipher.init(Cipher.ENCRYPT_MODE,　privateKey);
　　　　　　　　 return　cipher.doFinal(data);
　　　　 }
　　　　 /**

　　　　　 *　私钥解密

　　　　　 *

　　　　　 *　@param　data

　　　　　 *　@param　keyStorePath

　　　　　 *　@param　alias

　　　　　 *　@param　password

　　　　　 *　@return

　　　　　 *　@throws　Exception

　　　　　 */

　　　　 public　static　byte[]　decryptByPrivateKey(byte[]　data,　String　keyStorePath,

　　　　　　　　　　　　 String　alias,　String　password)　throws　Exception　{

　　　　　　　　 //　取得私钥

　　　　　　　　 PrivateKey　privateKey　=　getPrivateKey(keyStorePath,　alias,　password);
　　　　　　　　 //　对数据加密

　　　　　　　　 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　password

　　　　　 *

　　　　　 *　@return

　　　　　 *　@throws　Exception

　　　　　 */

　　　　 public　static　String　sign(byte[]　sign,　String　keyStorePath,　String　alias,

　　　　　　　　　　　　 String　password)　throws　Exception　{

　　　　　　　　 //　得到证书

　　　　　　　　 X509Certificate　x509Certificate　=　(X509Certificate)　getCertificate(

　　　　　　　　　　　　　　　　 keyStorePath,　alias,　password);

　　　　　　　　 //　获取私钥

　　　　　　　　 KeyStore　ks　=　getKeyStore(keyStorePath,　password);

　　　　　　　　 //　取得私钥

　　　　　　　　 PrivateKey　privateKey　=　(PrivateKey)　ks.getKey(alias,　password

　　　　　　　　　　　　　　　　 .toCharArray());
　　　　　　　　 //　构建签名

　　　　　　　　 Signature　signature　=　Signature.getInstance(x509Certificate

　　　　　　　　　　　　　　　　 .getSigAlgName());

　　　　　　　　 signature.initSign(privateKey);

　　　　　　　　 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); 　　　　 } }

#p#副标题#e#

再给出一个测试类：

#p#分页标题#e#

Java代码

import static org.junit.Assert.*;
import org.junit.Test;
/**
 *
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public class CertificateCoderTest {
    private String password = "123456";
    private String alias = "www.zlex.org";
    private String certificatePath = "d:/zlex.cer";
    private String keyStorePath = "d:/zlex.keystore";
    @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, password);
        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, alias, password);
        byte[] decodedData = CertificateCoder.decryptByPublicKey(encodedData,
                certificatePath);
        String outputStr = new String(decodedData);
        System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
        assertEquals(inputStr, outputStr);
        System.err.println("私钥签名——公钥验证签名");
        // 发生签名
        String sign = CertificateCoder.sign(encodedData, keyStorePath, alias,
                password);
        System.err.println("签名:\r" + sign);
        // 验证签名
        boolean status = CertificateCoder.verify(encodedData, sign,
                certificatePath);
        System.err.println("状态:\r" + status);
        assertTrue(status);
    }
}

节制台输出：

Console代码

#p#分页标题#e#

公钥加密——私钥解密加密前:　Ceritificate 解密后:　Ceritificate 私钥加密——公钥解密加密前:　sign 解密后:　sign 私钥签名——公钥验证签名签名: pqBn5m6PJlfOjH0A6U2o2mUmBsfgyEY1NWCbiyA/I5Gc3gaVNVIdj/zkGNZRqTjhf3+J9a9z9EI7 6F2eWYd7punHx5oh6hfNgcKbVb52EfItl4QEN+djbXiPynn07+Lbg1NOjULnpEd6ZhLP1YwrEAuM OfvX0e7/wplxLbySaKQ= 状态: true

由此完成了证书验证体系！

关键字：