java认证与证书

Posted 2023-03-29 wbo112

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java认证与证书相关的知识，希望对你有一定的参考价值。

本文内容主要来自《Java加密与解密的艺术》

目前主要有JKS和PEM两种编码格式文件。

JKS（Java Key Store），Java原生的密钥库/信任库文件。
**PEM（Privacy Enbanced Mail，隐私增强邮件）**是使用多种加密方法提供机密性、认证和信息完整性的因特网电子邮件，在因特网中却没有被广泛配置，但在OpenSSL中，却是最为常见的密钥库文件。

如何在这两种密钥库文件中进行库文件交换呢？

可以通过PKCS#12格式的证书文件在两种格式的密钥库中进行库文件导出/导入等。

通常使用Base64编码格式作为数字证书文件存储格式。

自签名证书

自签名证书，即证书申请者为自己的证书签名。

这类证书通常应用于软件厂商内部发放的产品中，或约定使用该证书的数据交互双方。数字证书完全充当加密算法的载体，为必要数据做加密/解密和签名/验证等操作。

证书签发

数字证书的颁发流程简述过程如下：

由数字证书需求方产生自己的密钥对。
由数字证书需求方将算法、公钥和证书申请者身份信息传送给认证机构。
由认证机构核实用户的身份，执行相应必要的步骤，确保请求确实由用户发送而来。
由认证机构将数字证书颁发给用户。

加密交互

1、客户端请求服务器的流程如下：

客户端请求服务器将按如下步骤进行：

由客户端使用公钥对数据加密。
由客户端向服务器端发送加密数据。
由服务器端使用私钥对数据解密。

2、服务器端完成客户端请求处理后，需经过以下几个步骤完成响应：

由服务器端使用私钥对待加密数据签名。
由服务器端使用私钥对数据加密。
由服务器向客户端回应加密数据和数字签名。
由客户端使用公钥对数据解密。
由客户端使用公钥和解密数据验证签名。

KeyTool证书管理

KeyTool是Java中的数字证书管理工具，用于数字证书的申请、导入、导出和撤销等证书管理操作。

官方文档https://docs.oracle.com/javase/8/docs/technotes/tools/windows/keytool.html

KeyTool与本地密钥库相关联，将私钥存于密钥库，公钥则以数字证书输出。KeyTool位于%JAVA_HOME%\\bin目录中，需要通过命令行进行相应的操作。

1、构建自签名证书

前面说了证书签发的流程，一般都是需要把公钥等相关信息发送给认证机构，认证机构颁发证书给我们。

如果我们自己给自己颁发证书这种，就被成为自签名证书。

配置了jdk环境变量后就能直接在命令行输入keytool查看具体的命令，如果我们想看具体命令，输入相关命令后面加--help就可以了，如keytool -genkeypair --help。

密钥和证书管理工具

命令:

 -certreq            生成证书请求
 -changealias        更改条目的别名
 -delete             删除条目
 -exportcert         导出证书
 -genkeypair         生成密钥对
 -genseckey          生成密钥
 -gencert            根据证书请求生成证书
 -importcert         导入证书或证书链
 -importpass         导入口令
 -importkeystore     从其他密钥库导入一个或所有条目
 -keypasswd          更改条目的密钥口令
 -list               列出密钥库中的条目
 -printcert          打印证书内容
 -printcertreq       打印证书请求的内容
 -printcrl           打印 CRL 文件的内容
 -storepasswd        更改密钥库的存储口令

使用 "keytool -?, -h, or --help" 可输出此帮助消息
使用 "keytool -command_name --help" 可获取 command_name 的用法。
使用 -conf <url> 选项可指定预配置的选项文件。

在构建证书前，需要生成密钥对，也就是基于某一种非对称加密算法的公私钥。

输入keytool -genkeypair --help就能看到genkeypair命令的相关参数。

keytool -genkeypair [OPTION]...

生成密钥对

选项:

 -alias <alias>          要处理的条目的别名
 -keyalg <alg>           密钥算法名称
 -keysize <size>         密钥位大小
 -groupname <name>       Group name. For example, an Elliptic Curve name.
 -sigalg <alg>           签名算法名称
 -destalias <alias>      目标别名
 -dname <name>           唯一判别名
 -startdate <date>       证书有效期开始日期/时间
 -ext <value>            X.509 扩展
 -validity <days>        有效天数
 -keypass <arg>          密钥口令
 -keystore <keystore>    密钥库名称
 -storepass <arg>        密钥库口令
 -storetype <type>       密钥库类型
 -providername <name>    提供方名称
 -addprovider <name>     按名称 (例如 SunPKCS11) 添加安全提供方
   [-providerarg <arg>]    配置 -addprovider 的参数
 -providerclass <class>  按全限定类名添加安全提供方
   [-providerarg <arg>]    配置 -providerclass 的参数
 -providerpath <list>    提供方类路径
 -v                      详细输出
 -protected              通过受保护的机制的口令

使用 "keytool -?, -h, or --help" 可输出此帮助消息

这里我们使用www.abc.org作为别名，使用RSA作为加密算法，并规定密钥长度为2048位，使用SHA256withRSA作为数字签名算法，欲签发有效期为36000天的数字证书。

完整命令如下:

keytool -genkeypair -keyalg RSA -keysize 2048 -sigalg SHA256withRSA -validity 36000 -alias www.abc.org -keystore abc.p12 -storepass 123456 -dname "CN=www.abc.org,OU=a,O=a,L=BJ,ST=BJ,C=CN"

-genkeypair 生成密钥对。

-keyalg 指定密钥算法，这里指定为RSA算法。

-keysize 指定密钥长度，默认1024位，这里指定为2048位.

-sigalg 指定数字签名算法，这里指定为SHA256withRSA算法。

-validity 指定证书有效期，这里指定为36000天。

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

-keystore 指定密钥库存储位置，这里是abc.keystore.

KeyTool工具支持RSA和DSA共2种算法，且DSA算法为默认算法。

-storepass 参数可以不在命令行输入，回车后就会提示要求输入

-dname参数也可以不在命令行输入，回车后就会提示要求输入

这时就会在当前目录下生成一个abc.p12，这就是创建的数字证书。虽然这时的数字证书并没有经过CA认证，但并不影响我们使用。

下来可以将数字证书导出，发送给需要通信的对方进行加密交互。KeyTool通过-exportcert命令导出证书。

keytool -exportcert [OPTION]...

导出证书

选项:

 -rfc                    以 RFC 样式输出
 -alias <alias>          要处理的条目的别名
 -file <file>            输出文件名
 -keystore <keystore>    密钥库名称
 -cacerts                访问 cacerts 密钥库
 -storepass <arg>        密钥库口令
 -storetype <type>       密钥库类型
 -providername <name>    提供方名称
 -addprovider <name>     按名称 (例如 SunPKCS11) 添加安全提供方
   [-providerarg <arg>]    配置 -addprovider 的参数
 -providerclass <class>  按全限定类名添加安全提供方
   [-providerarg <arg>]    配置 -providerclass 的参数
 -providerpath <list>    提供方类路径
 -v                      详细输出
 -protected              通过受保护的机制的口令

使用 "keytool -?, -h, or --help" 可输出此帮助消息

完整的导出命令如下：

keytool -exportcert -alias www.abc.org -keystore abc.p12 -file abc.cer -rfc  -storepass 123456

-exportcert 证书导出操作。

-alias 指定导别名，这里为www.abc.org。

-keystore 指定密钥库文件，这里为abc.keystore

-file 指定导出文件路径，这里为abc.cer

-rfc 指定以Base64编码格式输出

-storepass 密钥库口令

这时就会在当前目录下生成abc.cer。

我们可以使用keytool -printcert -file abc.cer命令查看abc.cer文件的内容。

我们可以使用keytool -printcert -file abc.cer -rfc 已文本形式查看abc.cer文件的内容。

我们是用notepad++之类的文本工具也可以打开abc.cer。会发现它和上面rfc参数显示的内容是一样的。

我们可以使用keytool -list -alias www.abc.org -keystore abc.p12 -v命令查看abc.p12文件的内容。

-alias www.abc.org指定了要看www.abc.org证书的信息。去掉这个参数，会显示证书中所有的条目。

abc.p12这种数字证书中是可以存储多个证书条目

通过KeyTool工具直接导出的证书，是一个自签名的X.509第三版类型的根证书，并以Base64编码保存。

自签名证书虽然可以使用，但未经过CA机构认证，几乎没有任何法律效力，也毫无安全可言。

abc.p12这个包含私钥和公钥。abc.cer只包含公钥。

echo PFX证书导入JKS密钥库
keytool -importkeystore -v -srckeystore   client.p12 -srcstoretype pkcs12 - srcstorepass 123456 -destkeystore client.keystore -deststoretype jks - deststorepass 123456
#-importkeystore     导入密钥库，通过格式设定可以将PKCS#12文件转换为JKS格式。
#-v                  显示详情。
#-srckeystore        源密钥库，这里是d:\\zlex.pfx。
#-srcstoretype       源密钥库格式，这里为pkcs12。
#-srcstorepass       源密钥库密码，这里为123456。
#-destkeystore       目标密钥库，这里为d:\\zlex.keystore。
#-deststoretype      目标密钥库格式，这里为JKS，默认值也如此。
#-deststorepass      目标密钥库密码，这里为123456。

2、springboot中使用证书

2.1 在springboot的配置文件中添加如下内容:

server.ssl.enabled=true
#NONE?WANT?NEED
server.ssl.client-auth=NONE
#server.ssl.protocol=TLS
server.ssl.key-store=classpath:certs/abc.p12
#server.ssl.key-password=123456
server.ssl.key-store-password=123456
server.ssl.key-store-type=PKCS12
server.ssl.keyAlias=www.abc.org

2.2 将上面生成的abc.p12放置到resources/certs/abc.p12这个位置。

启动工程，再通过https浏览器访问url就可以了。同时我们也可以通过浏览器导出证书。我们对比浏览器导出的证书和我们之前通过命令行导出的abc.cer,会发现两者的内容是一摸一样的。

3、在`java`代码是如何使用这些证书的：

package org.example;

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 javax.crypto.Cipher;
/**
 * 证书组件
 * @author 梁栋
 * @version 1.0
 */
public abstract class CertificateCoder 
    // 类型证书X.509
    public static final String CERT_TYPE = "X.509";
    /**
     * 由KeyStore获得私钥
     * @param keyStorePath 密钥库路径
     * @param alias 别名
     * @param password 密码
     * @return PrivateKey 私钥
     * @throws Exception
     */
    private static PrivateKey getPrivateKeyByKeyStore(String keyStorePath,
    String alias, String password) throws Exception 
           // 获得密钥库
           KeyStore ks = getKeyStore(keyStorePath, password);
           // 获得私钥
           return (PrivateKey) ks.getKey(alias, password.toCharArray());
    
    /**
     * 由Certificate获得公钥
     * @param certificatePath 证书路径
     * @return PublicKey 公钥
     * @throws Exception
     */
    private static PublicKey getPublicKeyByCertificate(String certificatePath)
    throws Exception 
           // 获得证书
           Certificate certificate = getCertificate(certificatePath);
           // 获得公钥
           return certificate.getPublicKey();
    
    /**
     * 获得Certificate
     * @param certificatePath 证书路径
     * @return Certificate 证书
     * @throws Exception
     */
    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;
    
    /**
     * 获得Certificate
     * @param keyStorePath 密钥库路径
     * @param alias 别名
     * @param password 密码
     * @return Certificate 证书
     * @throws Exception
     */
    private static Certificate getCertificate(String keyStorePath, String alias,
    String password) throws Exception 
           // 获得密钥库
           KeyStore ks = getKeyStore(keyStorePath, password);
           // 获得证书
           return ks.getCertificate(alias);
    
    /**
     * 获得KeyStore
     * @param keyStorePath 密钥库路径
     * @param password 密码
     * @return KeyStore 密钥库
     * @throws Exception
     */
    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;
    
    /**
     * 私钥加密
     * @param data 待加密数据
     * @param keyStorePath 密钥库路径
     * @param alias 别名
     * @param password 密码
     * @return byte[] 加密数据
     * @throws Exception
     */
    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);
    
    /**
     * 私钥解密
     * @param data 待解密数据
     * @param keyStorePath 密钥库路径
     * @param alias 别名
     * @param password 密码
     * @return byte[] 解密数据
     * @throws Exception
     */
    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);
    
    /**
     * 公钥加密
     * @param data 待加密数据
     * @param certificatePath 证书路径
     * @return byte[] 加密数据
     * @throws Exception
     */
    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);
    
    /**
     * 公钥解密
     * @param data 待解密数据
     * @param certificatePath 证书路径
     * @return byte[] 解密数据
     * @throws Exception
     */
    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);
    
    /**
     * 签名
     * @param keyStorePath 密钥库路径
     * @param alias 别名
     * @param password 密码
     * @return byte[] 签名
     * @throws Exception
     */
    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();
    
    /**
     * 验证签名
     * @param data 数据
     * @param sign 签名
     * @param certificatePath 证书路径
     * @return boolean 验证通过为真
     * @throws Exception
     */
    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);

测试代码：

import static org.junit.Assert.*;
import org.apache.commons.codec.binary.Hex;
import org.example.CertificateCoder;
import org.testng.annotations.Test;
/**
 * 证书校验
 * @author 梁栋
 * @version 1.0
 */
public class CertificateCoderTest 
    private String password = "123456";
    private String alias = "www.abc.org";
    private String certificatePath = "D:\\\\tmp\\\\a\\\\abc.cer";  //证书位置
    private String keyStorePath = "D:\\\\tmp\\\\a\\\\abc.p12";     //证书位置
    /**
     * 公钥加密—私钥解密
     * @throws Exception
     */
    @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.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以上是关于java认证与证书的主要内容，如果未能解决你的问题，请参考以下文章 
 java-信息安全（十五）-单向认证
 Java访问HTTPS时证书验证问题
 认证域名与SSL证书的区别
 java认证与证书
 kafka使用ssl加密和认证
 java-信息安全-数字签名Java证书体系实现