Java实现公钥和私钥进行自签证书_java自签名证书-优快云博客

因为Java标准库本身不提供直接创建证书的方法。需要使用到Bouncy Castle库中的方法。

引入 Bouncy Castle 依赖

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk18on</artifactId>
    <version>1.78.1</version>
</dependency>

具体思路：

创建密钥对：使用私钥和公钥创建一个KeyPair对象。
设置证书主题和签发者信息：使用X500Name来设置证书的主题（Subject）和签发者（Issuer）信息。
创建证书：使用X509v3CertificateBuilder来构建证书，并使用私钥对证书进行签名。
生成证书：使用CertificateFactory生成X509Certificate对象。

实现代码：

import java.io.FileInputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.security.GeneralSecurityException;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import java.security.cert.X509Certificate;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Date;
import org.bouncycastle.asn1.x500.X500Name;
import org.bouncycastle.cert.X509v3CertificateBuilder;
import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.operator.ContentSigner;
import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;

public class KeysConvertToCertificate {

    public static void main(String[] args) throws GeneralSecurityException, IOException {
        // 私钥和公钥的文件路径
        String privateKeyPath = "private_key.pem";
        String publicKeyPath = "public_key.pem";

        // 读取私钥
        PrivateKey privateKey = readPrivateKey(privateKeyPath);
        // 读取公钥
        PublicKey publicKey = readPublicKey(publicKeyPath);

        // 使用私钥和公钥创建证书
        X509Certificate certificate = createCertificate(privateKey, publicKey);

        // 打印证书信息
        System.out.println("Certificate: " + certificate.toString());
    }

    private static PrivateKey readPrivateKey(String path) throws GeneralSecurityException, IOException {
        try (FileInputStream fis = new FileInputStream(path)) {
            // 读取私钥文件并转换为PKCS#8格式的KeySpec
            PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(readAllBytes(fis));
            // 获取KeyFactory实例并生成私钥
            return KeyFactory.getInstance("RSA").generatePrivate(privateKeySpec);
        }
    }

    private static PublicKey readPublicKey(String path) throws GeneralSecurityException, IOException {
        try (FileInputStream fis = new FileInputStream(path)) {
            // 读取公钥文件并转换为X.509格式的KeySpec
            X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(readAllBytes(fis));
            // 获取KeyFactory实例并生成公钥
            return KeyFactory.getInstance("RSA").generatePublic(publicKeySpec);
        }
    }

    private static X509Certificate createCertificate(PrivateKey privateKey, PublicKey publicKey) throws GeneralSecurityException {
        // 添加Bouncy Castle安全提供者
        Security.addProvider(new BouncyCastleProvider());

        // 设置证书的主题和签发者名称
        X500Name subjectName = new X500Name("CN=Self Certificate, OU=SelfUnit, O= Org, L= City, ST= State, C=CN");
        // 设置证书序列号
        BigInteger serialNumber = BigInteger.valueOf(System.currentTimeMillis());
        // 设置证书有效期起始时间
        Date startDate = new Date();
        // 设置证书有效期结束时间，这里设置为1年
        Date endDate = new Date(startDate.getTime() + 365 * 24 * 60 * 60 * 1000L);

        // 创建证书构建器
        X509v3CertificateBuilder certBuilder = new X509v3CertificateBuilder(
                subjectName,
                serialNumber,
                startDate,
                endDate,
                subjectName,
                publicKey);

        // 创建内容签名器，这里使用SHA256withRSA算法
        ContentSigner signer = new JcaContentSignerBuilder("SHA256withRSA").build(privateKey);

        // 构建证书
        org.bouncycastle.cert.X509CertificateHolder certHolder = certBuilder.build(signer);

        // 使用Bouncy Castle的转换器将证书持有者转换为X509Certificate
        JcaX509CertificateConverter certConverter = new JcaX509CertificateConverter().setProvider(new BouncyCastleProvider());
        return certConverter.getCertificate(certHolder);
    }

    // 读取文件的所有字节
    private static byte[] readAllBytes(FileInputStream fis) throws IOException {
        byte[] bytes = new byte[fis.available()];
        int bytesRead = fis.read(bytes);
        if (bytesRead != bytes.length) {
            throw new IOException("Failed to read the complete file");
        }
        return bytes;
    }
}

注释说明：

readPrivateKey 和 readPublicKey 方法分别用于从文件中读取私钥和公钥。它们将文件内容读取为字节数组，并使用 KeyFactory 来生成 PrivateKey 和 PublicKey 对象。
createCertificate 方法用于创建证书。先设置证书的主题和签发者名称、序列号、有效期等信息。然后，它使用私钥对证书进行签名，并生成 X509Certificate 对象。
readAllBytes 用于读取文件中的所有字节到一个字节数组中。

如果没有公钥和私钥，需要生成一个密钥对，包含公钥和私钥，来实现将公钥和私钥转为证书（即实现自签证书 ）

创建密钥对（KeyPair）

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;

public class KeyPairGenerators {
    public static KeyPair generateKeyPair() throws NoSuchAlgorithmException {
        KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
        generator.initialize(2048);
        return generator.generateKeyPair();
    }
    // 从KeyPair中获取公钥和私钥
    // 密钥对
        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();
}