java 生成证书和签发证书(纯代码,编译通过)

最新推荐文章于 2025-06-28 23:15:59 发布
原创 最新推荐文章于 2025-06-28 23:15:59 发布 · 8.5k 阅读 · 15 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种使用Java实现的数字证书生成与管理方法，包括为不同主体生成PKCS12和JKS类型的证书库，并提供了添加新证书、导出公钥证书的功能。通过实例演示了如何生成自签名证书及签发证书。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

package com.xiuye.cert;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.SecureRandom;
import java.security.SignatureException;
import java.security.UnrecoverableKeyException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Date;
import java.util.Random;

import com.xiuye.cert.bean.KeyStoreInfo;
import com.xiuye.cert.bean.SignedCertInfo;

import sun.security.x509.AlgorithmId;
import sun.security.x509.CertAndKeyGen;
import sun.security.x509.CertificateAlgorithmId;
import sun.security.x509.CertificateIssuerName;
import sun.security.x509.CertificateSerialNumber;
import sun.security.x509.CertificateSubjectName;
import sun.security.x509.CertificateValidity;
import sun.security.x509.CertificateVersion;
import sun.security.x509.CertificateX509Key;
import sun.security.x509.X500Name;
import sun.security.x509.X509CertImpl;
import sun.security.x509.X509CertInfo;

public class DigitalCertificateGenerator {

	public static final String KEY_STORE_TYPE_JKS = "jks";
	public static final String KEY_STORE_TYPE_PKCS12 = "pkcs12";
	public static final String SECURE_RANDOM_ALGORITHM = "SHA1PRNG";
	public static final String SECURE_RANDOM_PROVIDER = "SUN";
	public static final String SIGN_ALGORITHM_SHA256 = "sha256WithRSA";
	public static final String SIGN_ALGORITHM_MD5 = "MD5WithRSA";
	public static final String KEY_PAIR_ALGORITHM_RSA = "RSA";

	public static void signCertPFXForSubject(SignedCertInfo signedCertInfo) {
		try {
			X500Name subject = new X500Name("CN=" + signedCertInfo.getCN()
					+ ",OU=" + signedCertInfo.getOU() + ",O="
					+ signedCertInfo.getO() + ",L=" + signedCertInfo.getL()
					+ ",ST=" + signedCertInfo.getST() + ",C="
					+ signedCertInfo.getC());

			issueSignedCert(signedCertInfo.getKeyStorePath(),
					signedCertInfo.getKeyStorePass(), KEY_STORE_TYPE_PKCS12,
					signedCertInfo.getIssuerAlias(),
					signedCertInfo.getIssuerAliasPass(),
					signedCertInfo.getSubjectAlias(),
					signedCertInfo.getSubjectAliasPass(), subject,
					signedCertInfo.getValidity(),
					signedCertInfo.getSubjectPath());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void signCertJKSForSubject(SignedCertInfo signedCertInfo) {
		try {
			X500Name subject = new X500Name("CN=" + signedCertInfo.getCN()
					+ ",OU=" + signedCertInfo.getOU() + ",O="
					+ signedCertInfo.getO() + ",L=" + signedCertInfo.getL()
					+ ",ST=" + signedCertInfo.getST() + ",C="
					+ signedCertInfo.getC());

			issueSignedCert(signedCertInfo.getKeyStorePath(),
					signedCertInfo.getKeyStorePass(), KEY_STORE_TYPE_JKS,
					signedCertInfo.getIssuerAlias(),
					signedCertInfo.getIssuerAliasPass(),
					signedCertInfo.getSubjectAlias(),
					signedCertInfo.getSubjectAliasPass(), subject,
					signedCertInfo.getValidity(),
					signedCertInfo.getSubjectPath());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void issueSignedCert(String keyStorePath,
			String keyStorePass, String keyStoreType, String issuerAlias,
			String issuerAliasPass, String subjectAlias,
			String subjectAliasPass, X500Name subject, int validity,
			String subjectPath) {

		FileOutputStream fos = null;
		FileOutputStream keyStoreFos = null;

		FileInputStream fis = null;

		try {
			fis = new FileInputStream(keyStorePath);
			KeyStore ks = KeyStore.getInstance(keyStoreType);
			ks.load(fis, keyStorePass.toCharArray());

			X509Certificate issuerCert = (X509Certificate) ks
					.getCertificate(issuerAlias);
			X509CertImpl issuerCertImpl = new X509CertImpl(
					issuerCert.getEncoded());
			X509CertInfo issuerCertInfo = (X509CertInfo) issuerCertImpl
					.get(X509CertImpl.NAME + "." + X509CertImpl.INFO);

			X500Name issuer = (X500Name) issuerCertInfo
					.get(X509CertInfo.SUBJECT + "."
							+ CertificateIssuerName.DN_NAME);
			PrivateKey pk = (PrivateKey) ks.getKey(issuerAlias,
					issuerAliasPass.toCharArray());

			CertAndKeyGen cakg = new CertAndKeyGen(KEY_PAIR_ALGORITHM_RSA,
					SIGN_ALGORITHM_SHA256);
			SecureRandom sr = SecureRandom.getInstance(SECURE_RANDOM_ALGORITHM,
					SECURE_RANDOM_PROVIDER);
			cakg.setRandom(sr);
			cakg.generate(2048);

			X509CertInfo info = new X509CertInfo();
			info.set(X509CertInfo.VERSION, new CertificateVersion(
					CertificateVersion.V3));
			info.set(X509CertInfo.SERIAL_NUMBER, new CertificateSerialNumber(
					new Random().nextInt() & 0x7fffffff));

			AlgorithmId aid = AlgorithmId.get(SIGN_ALGORITHM_SHA256);
			info.set(X509CertInfo.ALGORITHM_ID, new CertificateAlgorithmId(aid));
			info.set(X509CertInfo.SUBJECT, new CertificateSubjectName(subject));
			info.set(X509CertInfo.ISSUER, new CertificateIssuerName(issuer));
			info.set(X509CertInfo.KEY,
					new CertificateX509Key(cakg.getPublicKey()));
			Date fistDate = new Date();
			Date lastDate = new Date();
			lastDate.setTime(fistDate.getTime()
					+ (validity * 24L * 60L * 60L * 1000));
			CertificateValidity interval = new CertificateValidity(fistDate,
					lastDate);
			info.set(X509CertInfo.VALIDITY, interval);

			X509CertImpl cert = new X509CertImpl(info);

			cert.sign(pk, SIGN_ALGORITHM_SHA256);

			X509Certificate subjectCert = cert;

			X509Certificate[] chain = new X509Certificate[] { subjectCert,
					issuerCert };

			ks.setKeyEntry(subjectAlias, cakg.getPrivateKey(),
					subjectAliasPass.toCharArray(), chain);

			keyStoreFos = new FileOutputStream(keyStorePath);

			ks.store(keyStoreFos, keyStorePass.toCharArray());

			fos = new FileOutputStream(subjectPath);

			fos.write(cert.getEncoded());
			fos.flush();

		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchProviderException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (CertificateException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (SignatureException e) {
			e.printStackTrace();
		} catch (KeyStoreException e) {
			e.printStackTrace();
		} catch (UnrecoverableKeyException e) {
			e.printStackTrace();
		}

		finally {
			try {
				if (fos != null) {
					fos.close();
				}
				if (fis != null) {
					fis.close();
				}
				if (keyStoreFos != null) {
					keyStoreFos.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static void exportPFXPublicKeyCertificate(
			String keyStorePathAndFileName, String keyStorePass, String alias,
			String exportPathAndFileName) {

		exportPublicKeyCertificate(keyStorePathAndFileName, keyStorePass,
				KEY_STORE_TYPE_PKCS12, alias, exportPathAndFileName);

	}

	public static void exportJKSPublicKeyCertificate(
			String keyStorePathAndFileName, String keyStorePass, String alias,
			String exportPathAndFileName) {

		exportPublicKeyCertificate(keyStorePathAndFileName, keyStorePass,
				KEY_STORE_TYPE_JKS, alias, exportPathAndFileName);

	}

	public static void exportPublicKeyCertificate(
			String keyStorePathAndFileName, String keyStorePass,
			String keyStoreType, String alias, String exportPathAndFileName) {
		FileOutputStream fos = null;
		FileInputStream fis = null;
		try {
			KeyStore ks = KeyStore.getInstance(keyStoreType);
			fis = new FileInputStream(keyStorePathAndFileName);
			ks.load(fis, keyStorePass.toCharArray());
			Certificate cert = ks.getCertificate(alias);
			fos = new FileOutputStream(exportPathAndFileName);
			fos.write(cert.getEncoded());
			fos.flush();

		} catch (KeyStoreException e) {
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (CertificateException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (fos != null) {
					fos.close();
				}
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static void generatePFX(String alias, String keyStorePass,
			String certPass, String CN, String OU, String O, String L,
			String ST, String C, Date start, long validityDays,
			String pathAndFileName) {
		generateDigitalCert(KEY_STORE_TYPE_PKCS12, SIGN_ALGORITHM_SHA256,
				KEY_PAIR_ALGORITHM_RSA, SECURE_RANDOM_ALGORITHM,
				SECURE_RANDOM_PROVIDER, alias, keyStorePass, certPass, CN, OU,
				O, L, ST, C, start, validityDays, pathAndFileName, true);

	}

	public static void addNewCert2PFX(String alias, String keyStorePass,
			String certPass, String CN, String OU, String O, String L,
			String ST, String C, Date start, long validityDays,
			String pathAndFileName) {
		generateDigitalCert(KEY_STORE_TYPE_PKCS12, SIGN_ALGORITHM_SHA256,
				KEY_PAIR_ALGORITHM_RSA, SECURE_RANDOM_ALGORITHM,
				SECURE_RANDOM_PROVIDER, alias, keyStorePass, certPass, CN, OU,
				O, L, ST, C, start, validityDays, pathAndFileName, false);

	}

	public static void addNewCert2PFX(KeyStoreInfo certInfo) {
		generateDigitalCert(KEY_STORE_TYPE_PKCS12, SIGN_ALGORITHM_SHA256,
				KEY_PAIR_ALGORITHM_RSA, SECURE_RANDOM_ALGORITHM,
				SECURE_RANDOM_PROVIDER, certInfo.getAlias(),
				certInfo.getKeyStorePass(), certInfo.getCertPass(),
				certInfo.getCN(), certInfo.getOU(), certInfo.getO(),
				certInfo.getL(), certInfo.getST(), certInfo.getC(),
				certInfo.getStart(), certInfo.getValidityDays(),
				certInfo.getPathAndFileName(), false);
	}

	public static void generatePFX(KeyStoreInfo certInfo) {
		generateDigitalCert(KEY_STORE_TYPE_PKCS12, SIGN_ALGORITHM_SHA256,
				KEY_PAIR_ALGORITHM_RSA, SECURE_RANDOM_ALGORITHM,
				SECURE_RANDOM_PROVIDER, certInfo.getAlias(),
				certInfo.getKeyStorePass(), certInfo.getCertPass(),
				certInfo.getCN(), certInfo.getOU(), certInfo.getO(),
				certInfo.getL(), certInfo.getST(), certInfo.getC(),
				certInfo.getStart(), certInfo.getValidityDays(),
				certInfo.getPathAndFileName(), true);
	}

	public static void generateJKS(String alias, String keyStorePass,
			String certPass, String CN, String OU, String O, String L,
			String ST, String C, Date start, long validityDays,
			String pathAndFileName) {
		generateDigitalCert(KEY_STORE_TYPE_JKS, SIGN_ALGORITHM_SHA256,
				KEY_PAIR_ALGORITHM_RSA, SECURE_RANDOM_ALGORITHM,
				SECURE_RANDOM_PROVIDER, alias, keyStorePass, certPass, CN, OU,
				O, L, ST, C, start, validityDays, pathAndFileName, true);
	}

	public static void addNewCert2JKS(String alias, String keyStorePass,
			String certPass, String CN, String OU, String O, String L,
			String ST, String C, Date start, long validityDays,
			String pathAndFileName) {
		generateDigitalCert(KEY_STORE_TYPE_JKS, SIGN_ALGORITHM_SHA256,
				KEY_PAIR_ALGORITHM_RSA, SECURE_RANDOM_ALGORITHM,
				SECURE_RANDOM_PROVIDER, alias, keyStorePass, certPass, CN, OU,
				O, L, ST, C, start, validityDays, pathAndFileName, false);
	}

	public static void generateJKS(KeyStoreInfo certInfo) {
		generateDigitalCert(KEY_STORE_TYPE_JKS, SIGN_ALGORITHM_SHA256,
				KEY_PAIR_ALGORITHM_RSA, SECURE_RANDOM_ALGORITHM,
				SECURE_RANDOM_PROVIDER, certInfo.getAlias(),
				certInfo.getKeyStorePass(), certInfo.getCertPass(),
				certInfo.getCN(), certInfo.getOU(), certInfo.getO(),
				certInfo.getL(), certInfo.getST(), certInfo.getC(),
				certInfo.getStart(), certInfo.getValidityDays(),
				certInfo.getPathAndFileName(), true);
	}

	public static void addNewCert2JKS(KeyStoreInfo certInfo) {
		generateDigitalCert(KEY_STORE_TYPE_JKS, SIGN_ALGORITHM_SHA256,
				KEY_PAIR_ALGORITHM_RSA, SECURE_RANDOM_ALGORITHM,
				SECURE_RANDOM_PROVIDER, certInfo.getAlias(),
				certInfo.getKeyStorePass(), certInfo.getCertPass(),
				certInfo.getCN(), certInfo.getOU(), certInfo.getO(),
				certInfo.getL(), certInfo.getST(), certInfo.getC(),
				certInfo.getStart(), certInfo.getValidityDays(),
				certInfo.getPathAndFileName(), false);
	}

	public static void generateDigitalCert(String keyStoreType,
			String signAlgorithm, String keyPairAlgorithm,
			String secureRandomAlgorithm, String secureRandomProvider,
			String alias, String keyStorePass, String certPass, String CN,
			String OU, String O, String L, String ST, String C, Date start,
			long validityDays, String pathAndFileName, boolean createNew) {
		FileOutputStream out = null;
		try {
			SecureRandom sr = SecureRandom.getInstance(secureRandomAlgorithm,
					secureRandomProvider);
			CertAndKeyGen cakg = new CertAndKeyGen(keyPairAlgorithm,
					signAlgorithm);
			cakg.setRandom(sr);
			cakg.generate(2048);
			X500Name subject = new X500Name("CN=" + CN + ",OU=" + OU + ",O="
					+ O + ",L=" + L + ",ST=" + ST + ",C=" + C);

			X509Certificate certificate = cakg.getSelfCertificate(subject,
					start, validityDays * 24L * 60L * 60L);
			KeyStore outStore = KeyStore.getInstance(keyStoreType);
			if (createNew) {
				outStore.load(null, keyStorePass.toCharArray());
				outStore.setKeyEntry(alias, cakg.getPrivateKey(),
						certPass.toCharArray(),
						new Certificate[] { certificate });
			} else {
				File f = new File(pathAndFileName);
				if (!f.exists()) {
					throw new FileNotFoundException("证书库文件不存在,不能把新的证书加入到证书库.");
				}

				FileInputStream fis = new FileInputStream(f);
				outStore.load(fis, keyStorePass.toCharArray());
				fis.close();
				outStore.setKeyEntry(alias, cakg.getPrivateKey(),
						certPass.toCharArray(),
						new Certificate[] { certificate });

			}
			out = new FileOutputStream(pathAndFileName);
			outStore.store(out, keyStorePass.toCharArray());

		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchProviderException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (CertificateException e) {
			e.printStackTrace();
		} catch (SignatureException e) {
			e.printStackTrace();
		} catch (KeyStoreException e) {
			e.printStackTrace();
		} finally {

			try {
				if (out != null) {
					out.close();
					out = null;
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

}

package com.xiuye.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SignatureException;
import java.security.UnrecoverableKeyException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.util.Date;
import java.util.Enumeration;

import com.xiuye.cert.DigitalCertificateGenerator;
import com.xiuye.cert.bean.KeyStoreInfo;
import com.xiuye.cert.bean.SignedCertInfo;
import com.xiuye.cert.util.CertUtil;

public class DigitalCertificateGeneratorMain {

	public static void main(String[] args) throws KeyStoreException,
			NoSuchAlgorithmException, CertificateException, IOException,
			UnrecoverableKeyException, InvalidKeyException,
			NoSuchProviderException, SignatureException {

		KeyStoreInfo certInfo = new KeyStoreInfo("荆轲2", "123", "456", "1", "2",
				"3", "4", "5", "6", new Date(), 365, "CurrentTest.pfx");
		DigitalCertificateGenerator.generatePFX(certInfo);
		DigitalCertificateGenerator.addNewCert2PFX(certInfo);

		certInfo = new KeyStoreInfo("无名5", "789", "101", "7", "8", "9", "10",
				"11", "12", new Date(), 365, "CurrentTest.keystore");
		DigitalCertificateGenerator.generateJKS(certInfo);
		DigitalCertificateGenerator.addNewCert2JKS(certInfo);
		certInfo = new KeyStoreInfo("无名3", "789", "101", "7", "8", "9", "10",
				"11", "12", new Date(), 365, "CurrentTest.keystore");
		DigitalCertificateGenerator.generateJKS(certInfo);
		DigitalCertificateGenerator.addNewCert2JKS(certInfo);

		File f = new File("CurrentTest.keystore");
		if (!f.exists()) {
			System.out.println("not exist!");
		}
		KeyStore outStore = KeyStore.getInstance("jks");
		FileInputStream fis = new FileInputStream(f);
		outStore.load(fis, "789".toCharArray());

		Enumeration<String> e = outStore.aliases();

		// while(e.hasMoreElements()){
		// String alias = e.nextElement();

		Key key = outStore.getKey("中原", "中原".toCharArray());

		System.out.println("===========================");
		System.out.println(" key := " + key);
		System.out.println("===========================");

		key = outStore.getKey("无名3", "101".toCharArray());

		System.out.println("===========================");
		System.out.println(" key := " + key);
		System.out.println("===========================");

		// }
		//
		DigitalCertificateGenerator.exportJKSPublicKeyCertificate(
				"CurrentTest.keystore", "789", "无名3", "wuming3.cer");
		DigitalCertificateGenerator.exportPFXPublicKeyCertificate(
				"CurrentTest.pfx", "123", "荆轲2", "jingke2.cer");
		SignedCertInfo signedCertInfo = new SignedCertInfo();
		String s = "中原";
		signedCertInfo.setC(s);
		signedCertInfo.setCN(s);
		signedCertInfo.setIssuerAlias("无名3");
		signedCertInfo.setIssuerAliasPass("101");
		signedCertInfo.setKeyStorePass("789");
		signedCertInfo.setKeyStorePath("CurrentTest.keystore");
		signedCertInfo.setL(s);
		signedCertInfo.setO(s);
		signedCertInfo.setOU(s);
		signedCertInfo.setST(s);
		signedCertInfo.setSubjectAlias(s);
		signedCertInfo.setSubjectAliasPass(s);
		signedCertInfo.setSubjectPath("signed.cer");
		signedCertInfo.setValidity(365);

		System.out.println(signedCertInfo.getKeyStorePath());

		DigitalCertificateGenerator.signCertJKSForSubject(signedCertInfo);

		Certificate c1 = CertUtil.cert("wuming3.cer");
		Certificate c = CertUtil.cert("signed.cer");
		c.verify(c1.getPublicKey());
		System.out.println(c);
		System.out.println("end");

	}

}




[密码学实战]基于Java生成国密SM2与Dilithium的混合证书（十四）
曼岛_的博客
03-26 195
抗量子密码学实践：基于Java生成国密SM2与Dilithium的混合证书（专利实现）
网络安全--Java代码生成自颁发 cer证书、base64 cer证书文件
JustinQin
11-12 2万+
目录 一、说明 二、实现代码 三、结果分析 一、说明 最近在做一个项目，涉及到数字证书这一块的内容，其中有一个需求是，根据前端维护上送参数， 后台Java实现生成cer自签名证书，证书要求跟openssl命令生成的一样 ，我的java环境是JDK1.8。 网络--keytool CA签名SSL证书（收费）网络--keytool自签名SSL证书（免费）以及私钥签名、公钥验签 二、实现代...
Java生成CSR创建证书
热门推荐
Jinhill's Blog
12-27 2万+
Java生成CSR，签发证书package com.jinhill.cert; import java.io.ByteArrayInputStream; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileWriter; import java.io.IOException; im
怎么通过 java 生成 pfx 格式的证书链？
最新发布
Java的专栏
06-28 510
要在 Java 中生成一个包含证书链的 PFX 文件（也称为 PKCS#12 文件），你可以使用keytool工具，它是 JDK 自带的一个密钥和证书管理工具。此外，你也可以通过编程方式使用 Java 的KeyStoreAPI 来完成这一任务。
JAVA程序签发数字证书
cyy089074316的专栏
06-10 1864
/*  * Title:  *  * Description:  *  * Copyright: Copyright (c) 2007  *  * Company:  *  * @author ifwater  * @version 1.0  */ /*CA签发数字证书应该使用自己的私钥，CA自身的证书并不包含私钥的信息，因此需要从密钥库mykeystore中提取。此
java生成证书
xituzi的专栏
05-08 2368
import java.io.BufferedInputStream;  import java.io.ByteArrayInputStream;  import java.io.ByteArrayOutputStream;  import java.io.IOException;  import java.io.InputStream;  import java.io.OutputStream;
SM2 SM3 X.509 Cert 国密 数字签名 算法 国密证书 生成 签发 证书请求 keystore 纯java.zip
03-14
它的设计目标是“一次编写，到处运行（Write Once, Run Anywhere）”，这意味着开发者可以使用Java编写应用程序，并在支持Java的任何平台上无需重新编译即可运行，这得益于其独特的跨平台性，通过Java虚拟机（JVM）...
java源码加密-SourceCodeProtection:用CA生成的证书对Java源代码进行加密和签名
05-19
本文将详细介绍如何使用证书（由证书颁发机构，即CA生成）对Java源代码进行加密和签名，确保代码的完整性和安全性。 首先，理解源码加密的目的。Java源代码通常以`.java`文件的形式存在，这些文件是可读的文本格式...
界面化实现https证书生成和nginx配置
07-31
“动态修改nginx.conf文件，启用nginx中的https功能”这部分说明了该工具不仅生成证书，还能自动更新Nginx服务器的配置文件`nginx.conf`，以包含新生成的证书信息。Nginx是一个高性能的HTTP和反向代理服务器，广泛...
获取证书和证书信息以及检测证书是否有效demo-java
12-18
在Java中，`java.security.KeyPairGenerator`类可以用来生成RSA或SM2的密钥对，而`java.security.Signature`类则可用于执行签名和验证操作。 5. **IDEA编译**： IntelliJ IDEA是一款流行的Java集成开发环境，它...
Java 生成证书工具类 https
04-10
java生成https安全证书，解决httpClient访问https出错 编译：javac InstallCert.java 运行：java InstallCert 要访问的网址 结果：Enter certificate to add to trusted keystore or 'q' to quit: [1] 输入1确认生成jssecacerts文件，将证书copy到$JAVA_HOME/jre/lib/security目录下
生成证书的代码
11-12
目前访问https需要证书，上述代码是生成https证书的代码可以参考
java 生成证书,使用Java生成证书，公钥和私钥
weixin_29689845的博客
02-12 616
I'm looking for a java library or code to generate certificates, public and private keyson the fly without to use third party programs (such as openssl).I think something that is doeing keytool+openss...
java x509certificate javax_使用Java生成带有BouncyCastle的X509Certificate
weixin_40005887的博客
03-02 612
这就是我现在生成的数字证书.现在我能够生成一个密码保护私钥的数字证书.public static void main(String[] args) throws Exception {Security.addProvider(new BouncyCastleProvider());testKeyStore();}public static void testKeyStore() throws Ex...
用java实现签发数字证书
zymx(u010820135)的专栏
09-07 6753
from  http://renhl169.blog.163.com/blog/static/20365322201023194724282/ 最近研究了一下数字签名和关于证书相关。 证书必须通过CA权威机构签发，但在开发期间有多种途径实现签发证书用于测试： 1）去相关ca获取测试证书，一般有效期在15-30天 2)用keytool工具可以生成证书，但不能实现签发.
java的证书签名_java编程方式用CA给证书进行签名/签发证书
weixin_39529128的博客
02-12 445
这些代码首先加载CA证书，然后分别用CA给Alice和Bob签发一个证书并保存到resource/目录下面，用jks格式存储。CA证书也是用java编程方式制作的，制作过程请看我的上一篇博客。public static void main(String[] args) throws KeyStoreException,NoSuchAlgorithmException, CertificateExc...
如何用JAVA代码签发数字证书
weixin_34174422的博客
11-14 844
2019独角兽企业重金招聘Python工程师标准>>> ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值