java keytool使用
使用KeytoolGUI生成Keystore
目录1.启动KeytoolGUI工具 (3)2.信任列表keystore的制作 (3)3.服务器证书keystore的制作 (5)3.1.产生keystore,导入信任根证书 (5)3.2.产生密钥对，生成请求 (6)3.2.1.产生密钥对 (6)3.2.2.导入CA签发的服务器cer证书 (8)3.3.从pfx文件导入 (9)4.注意事项 (11)KeytoolGUI工具是一个Java图形界面的密钥库管理工具，支持JKS、PKCS12（pfx文件）等密钥库格式。
利用该工具可以非常方便的生成信任列表keystore、服务器证书keystore，不必再使用繁琐且易出错的keytool命令行。
1.启动KeytoolGUI工具启动该工具需要有jre环境，最好是1.4版本。
设置好jre/bin路径，达到在命令行中键入java命令可以出现提示的效果后，运行run.cmd即可启动。
启动后界面如下：2.信任列表keystore的制作信任列表keystore的生成就是将根证书导入keystore中。
选择File菜单中的New Keystore，新建一个jks格式的keystore，如图：选择JKS格式，点击OK。
出现如下界面：（和第一张图相比，工具栏图标已经可见）点击工具栏的导入信任根证书图标（如下图），或按Ctrl+T。
出现如下界面，此时即可选择根证书文件执行导入。
导入过程中会提示该证书无法验证信任路径，并将证书信息显示出来，询问是否信任等对话框，一直确定后，给根证书任意取一个别名，即完成了根证书的导入工作。
完成导入工作后，即可将该keystore保存，点击保存按钮后，出现设置Keystore密码的界面，如下图：输入至少六位的密码，选择保存路径后，信任证书列表Keystore即成功生成。
一般来说，在根证书中只需导入顶级根证即可。
客户端浏览器中只要安装了相应的二级根证，二级根证所颁发的证书即可获得信任，出现在证书选择框中。
keytool工具import 语句
keytool工具import 语句keytool工具是Java开发中的一个重要工具，用于管理Java密钥库（Java KeyStore）中的证书和密钥。
下面是关于keytool工具import语句的介绍，希望对您有所帮助。
1. keytool -import：导入证书或密钥到Java密钥库中。
2. keytool -importcert：导入证书到Java密钥库中。
3. keytool -importkeystore：将其他格式的密钥库导入到Java密钥库中。
4. keytool -importpass：导入密码到Java密钥库中。
5. keytool -importprivkey：导入私钥到Java密钥库中。
6. keytool -importtrustcacerts：导入CA证书到Java密钥库中。
7. keytool -importsrckeystore：导入源密钥库到目标密钥库中。
8. keytool -importstorepass：导入密钥库密码到Java密钥库中。
9. keytool -importalias：导入别名到Java密钥库中。
10. keytool -importkeystore：将其他格式的密钥库转换为Java密钥库格式。
以上是关于keytool工具import语句的一些常用命令和功能介绍。
使用这些命令可以方便地导入和管理证书、密钥和密钥库。
通过使用keytool工具，开发人员可以在Java应用程序中使用安全的加密通信，保护敏感数据的安全性。
在使用keytool工具时，需要注意以下几点：1. 确保导入的证书或密钥的有效性和正确性，避免使用过期或不可信任的证书。
2. 密钥库的密码应该足够强壮，以保护密钥和证书的安全。
3. 导入过程中要注意保护隐私信息，避免泄露敏感数据。
4. 导入操作应该在安全可信的环境下进行，避免被恶意攻击或篡改。
keytool工具的import语句提供了便捷的证书和密钥管理功能，可以帮助开发人员实现Java应用程序的安全通信和数据保护。
Java代码签名证书申请和使用方法
文档出处：/support/java_signing_guide.html第1步下载签名工具Step 1: Download Signing Tools如果您还没有签名工具，请到SUN公司网站免费下载：/j2se/，推荐下载JDK1.4.2或以上版本，支持Solaris SPARC/x86, Linux86 和Windows 操作系统。
If you have not already done so, download the Java 2 Software Development Kit (SDK). The latest version is available free of charge for the Solaris SPARC/x86, Linux86, and Microsoft Windows platforms from /j2se/.您将使用签名工具中的keytool, jar, jarsigner 来申请代码签名证书和数字签名您的代码。
You will be using the keytool, jar, and jarsigner to apply for your Code Signing C ertificate and sign your code.第2步申请签名证书Step 2: Enrollment(1) 生成私钥和公钥对(Keystore) Create a Keystore使用以下命令生成私钥和公钥对：To generate a public/private key pair, enter the following command, specifying a name for your keystore and an alias as well.c:\jdk1.5\bin\keytool -genkey -keyalg rsa -keystore <keystore_filename> -alias <alias_name>Keytool 会提示您输入私钥密码、您的姓名(Your name，填单位网址)、您的部门名称、单位名称、所在城市、所在省份和国家缩写(中国填：CN，其他国家填其缩写)，单位名称一定要与证明文件上的名称一致，部门名称(OU)可以不填。
java 签章流程
Java签章流程介绍在现代数字化的时代，电子签名已经成为了一种普遍的方式来确认文件的真实性和完整性。
Java提供了丰富的API和工具来实现电子签名功能。
本文将详细介绍Java签章的流程和步骤，以确保流程清晰且实用。
签章流程Java签章的流程可以分为以下几个步骤：1.准备工作：在开始签章之前，需要准备一些必要的工作，包括获取证书、创建密钥库等。
2.加载证书：需要加载用于签章的证书。
证书是由认证机构（CA）颁发的，用于验证签名者身份和确保文件的完整性。
3.创建数字签名：使用私钥对文件进行加密生成数字签名。
私钥是与公钥配对使用的密钥，只有持有私钥的人才能对文件进行数字签名。
4.将数字签名附加到文件：将生成的数字签名附加到原始文件中。
这可以通过在文件中添加特定标记或在文件末尾添加附加信息来完成。
5.验证数字签名：接收者可以使用公钥来验证文件的数字签名是否有效。
公钥是与之前加载的证书相关联的密钥。
下面将详细介绍每个步骤。
准备工作在开始签章之前，需要进行一些准备工作。
1.获取证书：需要获取一个由认证机构颁发的证书。
可以通过向认证机构申请或购买来获得。
2.创建密钥库：密钥库是用于存储私钥和相关证书的安全文件。
可以使用Java提供的keytool工具来创建密钥库。
以下是创建密钥库的示例命令：keytool -genkeypair -alias mykey -keyalg RSA -keystore keystore.jks这将创建一个名为keystore.jks的密钥库，并生成一个RSA算法的密钥对。
3.导出证书：从生成的密钥库中导出公钥证书。
可以使用以下命令导出证书：keytool -exportcert -alias mykey -keystore keystore.jks -file certificate.crt这将从keystore.jks中导出名为certificate.crt的证书文件。
加载证书在准备工作完成后，可以加载用于签章的证书。
keytool -import -keystore 使用方法
keytool -import -keystore 使用方法keytool是Java 提供的一个用于管理密钥库和证书的命令行工具。
其中，-import -keystore是keytool提供的一组参数，用于导入证书到密钥库中。
本文将深入探讨keytool -import -keystore的使用方法，以及常见的应用场景。
keytool 简介keytool是Java 开发工具包（JDK）中的一部分，主要用于生成密钥对、管理密钥库和证书。
通过keytool，开发人员可以创建和管理用于加密通信的证书和密钥。
使用方法keytool -import -keystore主要用于将证书导入到指定的密钥库中。
以下是基本的使用方法：bashkeytool -import-file certificate.cer -keystore keystore.jks -alias myalias其中各个参数的含义如下：•-import: 表示执行导入操作。
•-file certificate.cer: 指定要导入的证书文件，通常是以.cer或.crt结尾的证书文件。
•-keystore keystore.jks: 指定要导入证书的密钥库文件，可以是已存在的或者新创建的。
•-alias myalias: 指定要为导入的证书指定的别名，用于在密钥库中标识该证书。
示例1. 创建新的密钥库bashkeytool -genkeypair-keyalg RSA -alias mykey -keystore mykeystore.jks -storepass keystorepass word -keypass keypassword这将生成一个新的密钥库mykeystore.jks，并生成一对RSA 密钥对，别名为mykey。
2. 生成证书请求bashkeytool -certreq-alias mykey -keystore mykeystore.jks -file mycertreq.csr -storepass keystorep assword -keypass keypassword这将为先前生成的密钥对生成一个证书请求文件mycertreq.csr。
jks证书格式 -回复
jks证书格式-回复JKS证书格式（Java KeyStore）是一种常用的证书存储格式，用于存储密钥对和数字证书。
在本文中，我们将一步一步回答关于JKS证书格式的问题，并介绍其相关特点、用途以及如何生成和使用JKS证书。
一、什么是JKS证书格式？JKS证书格式是一种Java密钥存储文件的标准格式。
它用于存储密钥对和数字证书，以供Java应用程序使用。
JKS证书格式以二进制形式存储，并使用扩展名.jks。
二、JKS证书格式的主要特点有哪些？1. 安全性：JKS证书格式支持私钥和公钥的存储，以及它们所对应的数字证书。
私钥只能通过密码进行保护，以确保私钥的机密性和完整性。
2. 多种证书存储：JKS证书格式可以同时存储多个密钥对和证书。
这对于管理大量证书和密钥对非常有用。
3. 通用性：由于JKS证书格式是Java的标准格式，因此它可以在各种Java 应用程序和平台上使用。
三、JKS证书格式的用途有哪些？JKS证书格式广泛应用于Java应用程序和服务器中，主要用于以下几个方面：1. 安全访问控制：Java应用程序可以使用JKS证书格式来验证客户端和服务器之间的安全连接，以确保通信安全性。
2. 数字签名与加密：Java应用程序可以使用JKS证书格式来管理和使用私钥和公钥进行数字签名和加密操作。
3. 身份认证：服务器可以使用JKS证书格式存储其数字证书，以便客户端验证服务器的身份。
四、如何生成和使用JKS证书？1. 生成JKS文件：首先，您需要使用Java的keytool命令生成一个JKS 密钥存储文件。
可以使用以下命令生成空的JKS文件：keytool-genkeypair -alias myalias -keypass mypassword -keystore mykeystore.jks -storepass mystorepassword。
2. 生成密钥对：使用keytool命令生成一个密钥对，并将其存储在JKS 文件中：keytool -genkeypair -alias myalias -keypass mypassword -keystore mykeystore.jks -storepass mystorepassword。
JAVA对于数字证书的常用操作方法
System.out.println("签发者:"+t.getIssuerDN());
System.out.println("有效期:"+t.getNotBefore());
System.out.println("签名算法:"+t.getSigAlgName());
byt/签名值
cinfo2.set(X509CertInfo.SERIAL_NUMBER,csn);
(8)设置新证书签发者
cinfo2.set(X509CertInfo.ISSUER+"."+CertificateIssuerName.DN_NAME,issuer);应用第三步的结果
(9)设置新证书签名算法信息
ks.store(output,storepass.toCharArray())将keystore对象内容写入新文件
八:JAVA程序检验别名和删除条目
FileInputStream in=new FileInputStream(".keystore");
KeyStore ks=KeyStore.getInstance("JKS");
PublicKey pk=t.getPublicKey();
byte [] pkenc=pk.getEncoded();
System.out.println("公钥");
for(int i=0;i
五:JAVA程序列出密钥库所有条目
String pass="123456";
CertificateFactory cf=CertificateFactory.getInstance("X.509");
android 系统签名方法
android 系统签名方法Android系统的签名方法涉及到应用程序的数字签名，用于验证应用程序的身份和完整性。
以下是进行Android系统签名的一般步骤：1. 获取密钥库和密钥：首先，您需要一个密钥库和私钥，用于创建应用程序的数字证书。
如果您已经有了一个密钥库和私钥，您可以跳过这一步。
否则，您需要生成一个新的密钥库和私钥。
2. 创建证书：使用`keytool`工具（它是Java Development Kit的一部分）创建证书。
例如，运行以下命令创建一个名为“my_”的证书：```csskeytool -genkey -alias my_certificate -keyalg RSA -keystore my_ -keysize 2048```3. 导出证书：使用`keytool`工具导出证书为`.pem`或`.cer`文件。
4. 签名应用程序：使用`jarsigner`工具（也是Java Development Kit的一部分）来签名您的应用程序。
例如：```bashjarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore my_ my_certificate```5. 优化和打包：在签名之后，您通常会使用`zipalign`工具对应用程序进行优化和打包，以确保其在设备上运行得最好。
例如：```bashzipalign -v 4```6. 配置签名信息：在发布您的应用程序时，确保在Google Play Console中正确配置您的签名信息。
7. 发布：将签名的应用程序上传到Google Play或其他分发渠道。
请注意，具体的命令和参数可能会根据您的具体需求和环境有所不同。
此外，随着Android开发工具的更新，某些工具的位置或命令可能会有所变化。
确保参考最新的官方文档以获得最准确的信息。
keytool -list -v -keystore 用法 -回复
keytool -list -v -keystore 用法-回复keytool是Java开发中的一个命令行工具，用于管理Java密钥库（Keystore）。
它提供了创建、导入、查看和删除密钥库中的密钥对的功能。
在本文中，我们将介绍keytool list v keystore命令的用法，并逐步回答相关问题。
第一步：理解keytoolKeytool是Java开发人员的一个重要工具，用于生成和管理SSL证书、私钥和密钥库。
通过运行keytool命令，您可以执行许多与密钥库相关的任务，包括生成新的密钥对、查看密钥库中的现有密钥对以及导入/导出密钥对。
第二步：keytool命令格式的解释在命令提示符下键入“keytool list v keystore”命令将显示密钥库的详细信息。
以下是命令的结构：keytool list [options] [-v/verbose] [-rfc] [-Joption]在这个命令中，`list`是一个子命令，`-v` or `verbose`选项用于以详细或可读的方式显示密钥库的信息。
`-rfc`选项用于以RFC格式打印证书或CRT文件。
`-Joption`选项用于将选项传递给Java虚拟机进程。
第三步：运行keytool list v keystore命令要运行“keytool list v keystore”命令，您需要在命令提示符下键入以下内容：keytool list -v -keystore [keystore文件路径]其中，`-v`选项用于显示详细信息，`-keystore`选项后面是密钥库文件的路径。
例如，要查看名为“myKeystore.jks”的密钥库的详细信息，请键入以下命令：keytool list -v -keystore myKeystore.jks第四步：回答关于keytool list v keystore的问题下面是关于keytool命令的常见问题的回答：1. Q: keytool list v keystore命令的作用是什么？A: 这个命令用于显示密钥库的详细信息，包括密钥对、证书和其他相关信息。
数字证书中keytool命令使用说明
数字证书中keytool命令使⽤说明这个命令⼀般在JDK\jre\lib\security\⽬录下操作keytool常⽤命令-alias 产⽣别名-keystore 指定密钥库的名称(就像数据库⼀样的证书库，可以有很多个证书，cacerts这个⽂件是jre⾃带的，你也可以使⽤其它⽂件名字，如果没有这个⽂件名字，它会创建这样⼀个)-storepass 指定密钥库的密码-keypass 指定别名条⽬的密码-list 显⽰密钥库中的证书信息-v 显⽰密钥库中的证书详细信息-export 将别名指定的证书导出到⽂件-file 参数指定导出到⽂件的⽂件名-delete 删除密钥库中某条⽬-import 将已签名数字证书导⼊密钥库-keypasswd 修改密钥库中指定条⽬⼝令-dname 指定证书拥有者信息-keyalg 指定密钥的算法-validity 指定创建的证书有效期多少天-keysize 指定密钥长度使⽤说明：导⼊⼀个证书命令可以如下：keytool -import -keystore cacerts -storepass 666666 -keypass 888888 -alias alibabacert -file C:\alibabajava\cert\test_root.cer 其中-keystore cacerts中的cacerts是jre中默认的证书库名字，也可以使⽤其它名字-storepass 666666中的666666是这个证书库的密码-keypass 888888中的888888是这个特定证书的密码-alias alibabacert中的alibabacert是你导⼊证书的别名，在其它操作命令中就可以使⽤它-file C:\alibabajava\cert\test_root.cer中的⽂件路径就是要导⼊证书的路径浏览证书库⾥⾯的证书信息，可以使⽤如下命令：keytool -list -v -alias alibabacert -keystore cacerts -storepass 666666要删除证书库⾥⾯的某个证书，可以使⽤如下命令：keytool -delete -alias alibabacert -keystore cacerts -storepass 666666要导出证书库⾥⾯的某个证书，可以使⽤如下命令：keytool -export -keystore cacerts -storepass 666666 -alias alibabacert -file F:\alibabacert_root.cer要修改某个证书的密码（注意：有些数字认证没有私有密码，只有公匙，这种情况此命令⽆效）这个是交互式的，在输⼊命令后，会要求你输⼊密码keytool -keypasswd -alias alibabacert -keystore cacerts这个不是交互式的，输⼊命令后直接更改Keytool -keypasswd -alias alibabacert -keypass 888888 -new 123456 -storepass 666666 -keystore cacertsOwner: CN=BOCTestCA, O=BOCTest, C=CNIssuer: CN=BOCTestCA, O=BOCTest, C=CNSerial number: 31e60001Valid from: Tue Oct 28 16:54:26 CST 2008 until: Sat Oct 28 16:54:26 CST 2028Certificate fingerprints:MD5: F0:35:F9:69:31:AE:87:01:6C:2D:56:BD:02:0A:16:4ASHA1: 24:EF:84:14:4E:BD:0D:37:59:2D:70:28:79:10:88:EA:0A:06:13:20Signature algorithm name: SHA1withRSAVersion: 3Extensions:#1: ObjectId: 2.5.29.19 Criticality=trueBasicConstraints:[CA:truePathLen:2147483647]#2: ObjectId: 2.5.29.15 Criticality=falseKeyUsage [DigitalSignatureNon_repudiationKey_EnciphermentData_EnciphermentKey_AgreementKey_CertSignCrl_Sign]#3: ObjectId: 2.5.29.14 Criticality=falseSubjectKeyIdentifier [KeyIdentifier [0000: E3 81 66 00 7B C9 8F 3F 5A 77 E0 6D 5C EB 41 42 ..f....?Zw.m\.AB 0010: C7 48 5A 10 .HZ.]]#4: ObjectId: 1.3.6.1.5.5.7.1.1 Criticality=falseAuthorityInfoAccess [[accessMethod: 1.3.6.1.5.5.7.48.1]#5: ObjectId: 2.5.29.31 Criticality=falseCRLDistributionPoints [[DistributionPoint:[CN=crl1, OU=crl, O=BOCTest, C=CN]]]#6: ObjectId: 2.5.29.32 Criticality=falseCertificatePolicies [[CertificatePolicyId: [2.5.29.32.0][PolicyQualifierInfo: [qualifierID: 1.3.6.1.5.5.7.2.182.1190010: 2E 31 37 31 2E 31 30 36 2F 63 70 73 2E 68 74 6D .171.106/cps.htm ]] ]]#7: ObjectId: 2.16.840.1.113730.1.1 Criticality=false NetscapeCertType [SSL CAS/MIME CAObject Signing CA]#8: ObjectId: 2.5.29.35 Criticality=falseAuthorityKeyIdentifier [KeyIdentifier [0000: E3 81 66 00 7B C9 8F 3F 5A 77 E0 6D 5C EB 41 42 ..f....?Zw.m\.AB 0010: C7 48 5A 10 .HZ.]]Trust this certificate? [no]: yesCertificate was added to keystore[root@orange3c bin]#NOTE: (xp: %JAVA_HOME%/jre/lib/security/cacerts, linux: $JAVA_HOME/jre/lib/security/cacerts)验证是否已创建过同名的证书keytool -list -v -alias tomcat -keystore "%JAVA_HOME%/jre/lib/security/cacerts " -storepass changeit删除已创建的证书keytool -delete -alias tomcat -keystore "%%JAVA_HOME%/jre/lib/security/cacerts " -storepass changeitKeytool是⼀个Java数据证书的管理⼯具。
Java使用数字证书加密文件(含代码)
JA V A 使用数字证书加密解密文件总结目录1.编写目的 (3)2.JA V A生产数字证书 (4)2.1.1 keystore(JKS) 的生成 (4)2.1.2 导出公钥 (5)3.使用JKS私钥加密文件 (5)4.转换为PFX格式私钥 (6)5.使用PFX加密文件 (7)6 源代码 (8)6.1 用到的JAR包 (8)6.2 示例代码 (8)6.2.1 Test.java (8)6.2.2 RsaUtil.java (10)6.2.3 Base64.java (19)7.结束语 (26)1.编写目的学习RSA算法,读取数字证书中的私钥对文件进行加密,使用数字证书的公钥解密,这种方式就是RSA算法.自己对RSA算法的理解:⏹私钥加密公钥解密:如果用私钥对文件加密,发给别人,别人用我公布的公钥进行解密,实现这个文件就是我本人制作的,不是别人做的.⏹公钥加密私钥解密:如果别人用我的公钥加密文件,那么只能我一个人看,只有使用我的私钥进行解密,私钥一定是不能告诉其他人的.本文讲解如何用JKS私钥对文件进行加密,用对于CRT公钥进行解密,将JKS私钥转换为PFX格式私钥,并用PFX私钥对文件进行加密解密Jks:是JA V A的keytools证书工具支持的证书私钥格式pfx:是微软支持的私钥格式⏹2.JAVA生产数字证书为了实现数字证书加密文件,我们首先要制作几个数字证书，如果你已经有了pfx格式的数字证书并且知道其密码，以及对应crt或者cer格式的公钥证书则跳过本章.2.1 keytool 创建数字证书Keytool是一个Java数据证书的管理工具,Keytool将密钥（key）和证书（certificates）存在一个称为keystore的文件中在keystore里，包含两种数据：⏹密钥实体（Key entity）：密钥（secret key）又或者是私钥⏹配对公钥（采用非对称加密）：可信任的证书实体（trusted certificate entries），只包含公钥2.1.1 keystore(JKS) 的生成●分阶段生成：命令格式：keytool -genkey -alias yushan(别名) -keypass yushan(别名密码) -keyalg RSA(算法) -keysize 1024(密钥长度) -validity 365(有效期，天单位) -keystore e:\yushan.keystore(指定生成证书的位置和证书名称) -storepass 123456(获取keystore信息的密码)；示例：1）cmd下进入java/bin2）输入命令keytool -genkey -alias myalias-keypass 123456-keyalg RSA-keysize 1024 -validity 365 -keystore d: \myalias.keystore -storepass 123456●一次性生成：keytool -genkey -alias yushan -keypass yushan -keyalg RSA -keysize 1024 -validity 365 -keystore e:\yushan.keystore -storepass 123456 -dname "CN=(名字与姓氏), OU=(组织单位名称), O=(组织名称), L=(城市或区域名称), ST=(州或省份名称), C=(单位的两字母国家代码)";(中英文即可)无例图2.1.2 导出公钥命令：keytool -export -alias myalias -keystore d:\myalias.keystore -file d:\myalias.crt -storepass 123456创建结果：3.使用JKS私钥加密文件//工具类RSAUtil rsa = new RSAUtil();//从jks私钥中获取私钥加密串PrivateKey priKeyFromKs = rsa.getPriKeyFromKS("d:\\myalias.keystore","123456", "myalias", "123456");//从jks私钥中获取公钥解密串PublicKey pubKeyFromKS = rsa.getPubKeyFromKS("d:\\myalias.keystore", "123456", "myalias");//从crt公钥中获取公钥解密串PublicKey pubKeyFromCrt = rsa.getPubKeyFromCRT("d:\\myalias.crt");//用私钥串加密rsa.encryptWithPrv("d:\\file.xml",priKeyFromKs,"d:\\file_encWithKSPri.xml", true);//用jks公钥串解密rsa.decryptWithPub("d:\\file_encWithKSPri.xml", pubKeyFromKS, true,"d:\\file_encWithKSPri_decKs.xml");//用crt公钥串解密rsa.decryptWithPub("d:\\file_encWithKSPri.xml", pubKeyFromCrt, true, "d:\\file_encWithKSPri_decCrt.xml");4.转换为PFX格式私钥如果你已经有了pfx格式的数字证书并且知道其密码，以及对应crt或者cer格式的公钥证书则跳过本章.4.1 转换工具转换工具我使用的是kestore-export下载kestore-export.rar 请百度搜索，我也会往CSDN上上传，请直接搜索kestore-export.rar。
keytool命令
Java keytool命令说明Java 中的 keytool.exe （位于 JDK\Bin 目录下）可以用来创建数字证书，所有的数字证书是以一条一条(采用别名区别)的形式存入证书库的中，证书库中的一条证书包含该条证书的私钥，公钥和对应的数字证书的信息。
证书库中的一条证书可以导出数字证书文件，数字证书文件只包括主体信息和对应的公钥。
Keytool是一个Java数据证书的管理工具。
keystoreKeytool将密钥（key）和证书（certificates）存在一个称为keystore的文件中在keystore里，包含两种数据：密钥实体（Key entity）——密钥（secret key）又或者是私钥和配对公钥（采用非对称加密）可信任的证书实体（trusted certificate entries）——只包含公钥Alias（别名）每个keystore都关联这一个独一无二的alias，这个alias通常不区分大小写keystore的存储位置在没有制定生成位置的情况下，keystore会存在与用户的系统默认目录，如：对于window xp系统，会生成在系统的C:\Documents andSettings\UserName\文件名为“.keystore”keystore的生成引用keytool -genkey -alias tomcat -keyalg RSA -keystore d:\mykeystore -dname "CN=localhost, OU=localhost, O=localhost, L=SH, ST=SH, C=CN" -keypass changeit -storepass -validity 180参数说明：-genkey表示要创建一个新的密钥-dname表示密钥的Distinguished Names，CN=commonNameOU=organizationUnitO=organizationNameL=localityNameS=stateNameC=countryDistinguished Names表明了密钥的发行者身份-keyalg使用加密的算法，这里是RSA-alias密钥的别名-keypass私有密钥的密码，这里设置为changeit-keystore 密钥保存在D:盘目录下的mykeystore文件中-storepass 存取密码，这里设置为changeit，这个密码提供系统从mykeystore 文件中将信息取出-validity该密钥的有效期为 180天 (默认为90天)1，产生一个密钥对keytool -genkey -alias mykeypair -keypass mykeypairpwd 过程如下：liqingfeng@liqingfeng:~/WORK_APP/keytooltest$ keytool -genkey -alias mykeypair -keypass mykeypairpwd输入keystore密码： 123456您的名字与姓氏是什么？[Unknown]： fingki您的组织单位名称是什么？[Unknown]： server您的组织名称是什么？[Unknown]： server您所在的城市或区域名称是什么？[Unknown]： bj您所在的州或省份名称是什么？[Unknown]： bj该单位的两字母国家代码是什么[Unknown]： CNCN=fingki, OU=server, O=server, L=bj, ST=bj, C=CN 正确吗？[否]： yliqingfeng@liqingfeng:~/WORK_APP/keytooltest$这样将产生一个keypair,同时产生一个keystore.默认名是.keystore,存放到user-home目录假如你想修改密码,可以用:keytool -keypasswd -alias mykeypair-keypass mykeypairpwd -new newpass2，产生一个密钥对，存放在指定的keystore中（加上-keystore 参数）keytool -genkey -alias mykeypair -keypass mykeypairpwd -keystore mykeystore过程与上面的相同。
java实现 SSL双向认证
实现技术：JSSE（Java Security Socket Extension）是Sun为了解决在Internet上的实现安全信息传输的解决方案。
它实现了SSL和TSL（传输层安全）协议。
在JSSE中包含了数据加密，服务器验证，消息完整性和客户端验证等技术。
通过使用JSSE，可以在Client和Server之间通过TCP/IP协议安全地传输数据。
为了实现消息认证。
Server需要：1）KeyStore: 其中保存服务端的私钥2）Trust KeyStore:其中保存客户端的授权证书Client需要：1）KeyStore：其中保存客户端的私钥2）Trust KeyStore：其中保存服务端的授权证书使用Java自带的keytool命令，去生成这样信息文件：1）生成服务端私钥，并且导入到服务端KeyStore文件中2）根据私钥，导出服务端证书3）将服务端证书，导入到客户端的Trust KeyStore中采用同样的方法，生成客户端的私钥，客户端的证书，并且导入到服务端的Trust KeyStore中1）keytool -genkey -alias clientkey -keystore kclient.keystore2）keytool -export -alias clientkey -keystore kclient.keystore -file client.crt3）keytool -import -alias clientkey -file client.crt -keystore tserver.keystoreServerJava代码package ssl;import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.InputStream;import java.io.OutputStream;import .Socket;import java.security.KeyStore;import .ssl.KeyManagerFactory;import .ssl.SSLContext;import .ssl.SSLServerSocket;import .ssl.TrustManagerFactory;/**** @author Leo*/public class Server implements Runnable{private static final int DEFAULT_PORT = 7777;private static final String SERVER_KEY_STORE_PASSWORD = "123456";private static final String SERVER_TRUST_KEY_STORE_PASSWORD = "123456"; private SSLServerSocket serverSocket;/*** 启动程序** @param args*/public static void main(String[] args) {Server server = new Server();server.init();Thread thread = new Thread(server);thread.start();}public synchronized void start() {if (serverSocket == null) {System.out.println("ERROR");return;}while (true) {try {Socket s = serverSocket.accept();InputStream input = s.getInputStream();OutputStream output = s.getOutputStream();BufferedInputStream bis = new BufferedInputStream(input);BufferedOutputStream bos = new BufferedOutputStream(output);byte[] buffer = new byte[20];bis.read(buffer);System.out.println("------receive:--------"+new String(buffer).toString());bos.write("yes".getBytes());bos.flush();s.close();} catch (Exception e) {System.out.println(e);}}}public void init() {try {SSLContext ctx = SSLContext.getInstance("SSL");KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");KeyStore ks = KeyStore.getInstance("JKS");KeyStore tks = KeyStore.getInstance("JKS");ks.load(new FileInputStream("src/ssl/kserver.keystore"), SERVER_KEY_STORE_PASSWORD.t oCharArray());tks.load(new FileInputStream("src/ssl/tserver.keystore"), SERVER_TRUST_KEY_STORE_PAS SWORD.toCharArray());kmf.init(ks, SERVER_KEY_STORE_PASSWORD.toCharArray());tmf.init(tks);ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);serverSocket = (SSLServerSocket) ctx.getServerSocketFactory().createServerSocket(DEFAULT _PORT);serverSocket.setNeedClientAuth(true);} catch (Exception e) {System.out.println(e);}}public void run() {// TODO Auto-generated method stubstart();}}package ssl;import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.InputStream;import java.io.OutputStream;import .Socket;import java.security.KeyStore;import .ssl.KeyManagerFactory;import .ssl.SSLContext;import .ssl.SSLServerSocket;import .ssl.TrustManagerFactory;/**** @author Leo*/public class Server implements Runnable{private static final int DEFAULT_PORT = 7777;private static final String SERVER_KEY_STORE_PASSWORD = "123456";private static final String SERVER_TRUST_KEY_STORE_PASSWORD = "123456";private SSLServerSocket serverSocket;/*** 启动程序** @param args*/public static void main(String[] args) {Server server = new Server();server.init();Thread thread = new Thread(server);thread.start();}public synchronized void start() {if (serverSocket == null) {System.out.println("ERROR");return;}while (true) {try {Socket s = serverSocket.accept();InputStream input = s.getInputStream();OutputStream output = s.getOutputStream();BufferedInputStream bis = new BufferedInputStream(input);BufferedOutputStream bos = new BufferedOutputStream(output);byte[] buffer = new byte[20];bis.read(buffer);System.out.println("------receive:--------"+new String(buffer).toString());bos.write("yes".getBytes());bos.flush();s.close();} catch (Exception e) {System.out.println(e);}}}public void init() {try {SSLContext ctx = SSLContext.getInstance("SSL");KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");KeyStore ks = KeyStore.getInstance("JKS");KeyStore tks = KeyStore.getInstance("JKS");ks.load(new FileInputStream("src/ssl/kserver.keys tore"), SERVER_KEY_STORE_PASSWORD.toCharArray());tks.load(new FileInputStream("src/ssl/tserver.keystore"), SERVER_TRUST_KEY_STORE_PASSWORD.toCharArray());kmf.init(ks, SERVER_KEY_STORE_PASSWORD.toCharArray());tmf.init(tks);ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);serverSocket = (SSLServerSocket) ctx.getServerSocketFactory().createServerSocket(DEFAULT_PORT);serverSocket.setNeedClientAuth(true);} catch (Exception e) {System.out.println(e);}}public void run() {// TODO Auto-generated method stubstart();}}Client：Java代码package ssl;import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.security.KeyStore;import .ssl.KeyManagerFactory;import .ssl.SSLContext;import .ssl.SSLSocket;import .ssl.TrustManagerFactory;/*** SSL Client** @author Leo*/public class Client {private static final String DEFAULT_HOST = "127.0.0.1";private static final int DEFAULT_PORT = 7777;private static final String CLIENT_KEY_STORE_PASSWORD = "123456";private static final String CLIENT_TRUST_KEY_STORE_PASSWORD = "123456"; private SSLSocket sslSocket;/*** 启动客户端程序** @param args*/public static void main(String[] args) {Client client = new Client();client.init();client.process();}public void process() {if (sslSocket == null) {System.out.println("ERROR");return;}try {InputStream input = sslSocket.getInputStream();OutputStream output = sslSocket.getOutputStream();BufferedInputStream bis = new BufferedInputStream(input);BufferedOutputStream bos = new BufferedOutputStream(output);bos.write("1234567890".getBytes());bos.flush();byte[] buffer = new byte[20];bis.read(buffer);System.out.println(new String(buffer));sslSocket.close();} catch (IOException e) {System.out.println(e);}}public void init() {try {SSLContext ctx = SSLContext.getInstance("SSL");KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");KeyStore ks = KeyStore.getInstance("JKS");KeyStore tks = KeyStore.getInstance("JKS");ks.load(new FileInputStream("src/ssl/kclient.keystore"), CLIENT_KEY_STORE_PASSWORD.to CharArray());tks.load(new FileInputStream("src/ssl/tclient.keystore"), CLIENT_TRUST_KEY_STORE_PASS WORD.toCharArray());kmf.init(ks, CLIENT_KEY_STORE_PASSWORD.toCharArray());tmf.init(tks);ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);sslSocket = (SSLSocket) ctx.getSocketFactory().createSocket(DEFAULT_HOST, DEFAULT_PO RT);} catch (Exception e) {System.out.println(e);}}}package ssl;import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.security.KeyStore;import .ssl.KeyManagerFactory;import .ssl.SSLContext;import .ssl.SSLSocket;import .ssl.TrustManagerFactory;/*** SSL Client** @author Leo*/public class Client {private static final String DEFAULT_HOST = "127.0.0.1";private static final int DEFAULT_PORT = 7777;private static final String CLIENT_KEY_STORE_PASSWORD = "123456";private static final String CLIENT_TRUST_KEY_STORE_PASSWORD = "123456";private SSLSocket sslSocket;/*** 启动客户端程序** @param args*/public static void main(String[] args) {Client client = new Client();client.init();client.process();public void process() {if (sslSocket == null) {System.out.println("ERROR");return;}try {InputStream input = sslSocket.getInputStream();OutputStream output = sslSocket.getOutputStream();BufferedInputStream bis = new BufferedInputStream(input);BufferedOutputStream bos = new BufferedOutputStream(output);bos.write("1234567890".getBytes());bos.flush();byte[] buffer = new byte[20];bis.read(buffer);System.out.println(new String(buffer));sslSocket.close();} catch (IOException e) {System.out.println(e);}}public void init() {try {SSLContext ctx = SSLContext.getInstance("SSL");KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");KeyStore ks = KeyStore.getInstance("JKS");KeyStore tks = KeyStore.getInstance("JKS");ks.load(new FileInputStream("src/ssl/kclient.keystore"), CLIENT_KEY_STORE_PASSWORD.toCharArray());tks.load(new FileInputStream("src/ssl/tclient.keystore"), CLIENT_TRUST_KEY_STORE_PASSWORD.toCharArray());kmf.init(ks, CLIENT_KEY_STORE_PASSWORD.toCharArray());tmf.init(tks);ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);sslSocket = (SSLSocket) ctx.getSocketFactory().createSocket(DEFAULT_HOST, DEFAULT_PORT);} catch (Exception e) {System.out.println(e);}}}启动Server启动Client，发送信息。
JavaKeyStore用命令生成keystore文件自己生成证书，简介
JavaKeyStore⽤命令⽣成keystore⽂件⾃⼰⽣成证书，简介1.⽣成keyStore⽂件在命令⾏下执⾏以下命令：Shell代码收藏代码keytool -genkey -validity 36000 -alias -keyalg RSA -keystore d:\zlex.keystore其中-genkey表⽰⽣成密钥-validity指定证书有效期，这⾥是36000天-alias指定别名，这⾥是-keyalg指定算法，这⾥是RSA-keystore指定存储位置，这⾥是d:\zlex.keystore在这⾥我使⽤的密码为 123456控制台输出：Console代码收藏代码输⼊keystore密码：再次输⼊新密码:您的名字与姓⽒是什么？[Unknown]： 您的组织单位名称是什么？[Unknown]： zlex您的组织名称是什么？[Unknown]： zlex您所在的城市或区域名称是什么？[Unknown]： BJ您所在的州或省份名称是什么？[Unknown]： BJ该单位的两字母国家代码是什么[Unknown]： CNCN=, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN 正确吗？[否]： Y输⼊<tomcat>的主密码（如果和 keystore 密码相同，按回车）：再次输⼊新密码:这时，在D盘下会⽣成⼀个zlex.keystore的⽂件。
2.⽣成⾃签名证书光有keyStore⽂件是不够的，还需要证书⽂件，证书才是直接提供给外界使⽤的公钥凭证。
导出证书：Shell代码收藏代码keytool -export -keystore d:\zlex.keystore -alias -file d:\zlex.cer -rfc其中-export指定为导出操作-keystore指定keystore⽂件-alias指定导出keystore⽂件中的别名-file指向导出路径-rfc以⽂本格式输出，也就是以BASE64编码输出这⾥的密码是 123456控制台输出：Console代码收藏代码输⼊keystore密码：保存在⽂件中的认证 <d:\zlex.cer>。
JDK自带工具keytool生成ssl证书
JDK自带工具keytool生成ssl证书前言：因为公司项目客户要求使用HTTPS的方式来保证数据的安全，所以木有办法研究了下怎么生成ssl证书来使用https以保证数据安全。
百度了不少资料，看到JAVA的JDK自带生成SSL证书的工具：keytool，外加看了同事的心得体会，自己总结了一下具体的使用方法和使用过程中发现的问题及解决办法。
1:什么是HTTPS？HTTPS其实是有两部分组成：HTTP + SSL / TLS，也就是在HTTP上又加了一层处理加密信息的模块，并且会进行身份的验证。
问题：Firebug和postman之类的浏览器调试工具，为什么获取到的是明文？解答：SSL是对传输的数据进行加密，针对的是传输过程的安全。
firebug之类的浏览器调试工具，因为他们得到的是客户端加密之前/解密之后的数据，因此是明文的。
2:什么是自签名证书？就是自己生成的证书，并不是官方生成的证书。
除非是很正式的项目，否则使用自己签发的证书即可，因为官方生成证书是要花钱滴。
3:进入正题，使用JDK自带工具KeyTool 生成自签发证书！第一步：为服务器生成证书打开CMD命令行工具，cd到C盘根目录或者是jdk的bin目录下，如下图所示：附录1:常用keytool命令使用keytool命令生成证书：keytool-genkey-alias tomcat(别名)-keypass 123456(别名密码)-keyalg RSA(算法)-keysize 1024(密钥长度)-validity 365(有效期，天单位)-keystore D:/keys/tomcat.keystore(指定生成证书的位置和证书名称)-storepass 123456(获取keystore信息的密码)方便复制版：keytool -genkey -alias tomcat -keypass 123456 -keyalg RSA -keysize 1024 -validity 365-keystore D:/keys/tomcat.keystore -storepass 123456图例：回车执行后如下图：点击回车即可在D:/keys/文件夹内生成名为：tomcat.keystore的文件。
利用java代码生成keyStore
利⽤java代码⽣成keyStore在前⾯的章节中介绍了如何利⽤KeyTool⼯具⽣成keyStore：。
但是很多时候，在javaWeb项⽬中，⽐如给每个⽤户加上独特的数字签名，那么我们需要在创建⽤户的时候，给其⽣成独⼀⽆⼆的keystore。
我现在主要的功能是，给每个⽤户下载pdf的时候加上数字签名。
下⾯说⼀下⽣成keystore的主要思想：借助keyTool中的⽣成keyStore的⽅法。
主要利⽤sun.security.tools.keytool包⽂件来处理。
import java.io.FileOutputStream;import java.io.IOException;import java.security.GeneralSecurityException;import java.security.KeyStore;import java.security.KeyStoreException;import java.security.NoSuchAlgorithmException;import java.security.PrivateKey;import java.security.cert.CertificateException;import java.security.cert.X509Certificate;import java.util.Date;import sun.security.tools.keytool.CertAndKeyGen;import sun.security.x509.X500Name;/*** 主要⽤于创建keyStore⽂件，保存起来** @author Xia**/public class KeyStoreCreate2 {public static String filePath = "src/main/resources/pdf0090createEncrypt/new_KeyStore.keystore";private static final int keysize = 1024;private static final String commonName = "";private static final String organizationalUnit = "IT";private static final String organization = "test";private static final String city = "beijing";private static final String state = "beijing";private static final String country = "beijing";private static final long validity = 1096; // 3 yearsprivate static final String alias = "tomcat";private static final char[] keyPassword = "123456".toCharArray();public static void main(String[] args) throws GeneralSecurityException {try {KeyStore ks = KeyStore.getInstance("pkcs12");// char[] password = "123456".toCharArray();ks.load(null, null);CertAndKeyGen keypair = new CertAndKeyGen("RSA", "SHA1WithRSA", null);X500Name x500Name = new X500Name(commonName, organizationalUnit, organization, city, state, country);keypair.generate(keysize);PrivateKey privateKey = keypair.getPrivateKey();X509Certificate[] chain = new X509Certificate[1];chain[0] = keypair.getSelfCertificate(x500Name, new Date(), (long)validity*24*60*60);// store away the key storeFileOutputStream fos = new FileOutputStream(filePath);ks.setKeyEntry(alias, privateKey, keyPassword, chain);ks.store(fos, keyPassword);fos.close();System.out.println("create Success");} catch (KeyStoreException e) {e.printStackTrace();} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (CertificateException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}}。
keytool用法
Keytool是Java平台的一个工具，用于管理密钥库和证书。
以下是Keytool的一些常见用法：1. 生成密钥对：使用“-genkeypair”选项可以生成一对非对称密钥，包括公钥和私钥。
例如：```bashkeytool -genkeypair -alias myalias -keyalg RSA -keysize 2048 -validity 365 -keystore mykeystore.jks```上述命令将生成一个2048位的RSA密钥对，并将其存储在名为“mykeystore.jks”的密钥库中。
该命令还指定了别名为“myalias”，密钥库的有效期为365天。
2. 导入证书：使用“-import”选项可以将证书导入到密钥库中。
例如：```bashkeytool -import -alias myalias -file mycertificate.crt -keystore mykeystore.jks```上述命令将名为“mycertificate.crt”的证书导入到名为“mykeystore.jks”的密钥库中，并将别名为“myalias”。
3. 导出证书：使用“-export”选项可以将密钥库中的证书导出为文件。
例如：```bashkeytool -export -alias myalias -file mycertificate.crt -keystore mykeystore.jks```上述命令将名为“mykeystore.jks”的密钥库中的名为“myalias”的证书导出为名为“mycertificate.crt”的文件。
4. 删除密钥库中的条目：使用“-delete”选项可以删除密钥库中的条目。
例如：```bashkeytool -delete -alias myalias -keystore mykeystore.jks```上述命令将删除名为“mykeystore.jks”的密钥库中名为“myalias”的条目。
Java使用keytool创建CA证书的操作
Java使⽤keytool创建CA证书的操作keytool是⼀个密钥和证书管理⼯具1.keytool⼯具位置keytool⼯具在 JDK 的安装⽬录的 bin ⽬录下⾯2.keytool⼯具命令展⽰打开命令⾏进⼊ bin ⽬录，然后输⼊命令 keytool.exe，就能看见keytool⼯具⽀持哪些命令，如下图所⽰：注意下⾯的⽤法提⽰：使⽤ “keytool -command_name -help” 获取 command_name 的⽤法3.查看具体命令⽤法这⾥我们使⽤ -genkeypair 命令来创建密钥库，先来看看 genkeypair 命令的⽤法，如下图所⽰：4.新建密钥库.\keytool.exe -genkeypair -alias CA -keyalg RSA -validity 30 -keystore D:\keytoolCert\.CAkeystore4.1.参数说明-alias CA： alias表⽰别名的意思，这⾥别名为 CA，如果不写的话，它的默认值为 mykey-keyalg RSA：密钥算法名称，这⾥使⽤RSA算法-validity 30：有效天数为30天-keystore D:\keytoolCert.CAkeystore：指定密钥库存放的位置。
命令输⼊过后会让我们输⼊密码、唯⼀判别名（dname）和密钥⼝令注意密钥库的密码⾄少必须6个字符，可以是纯数字或者字母或者数字和字母的组合等等名字与姓⽒"应该是输⼊域名，⽽不是我们的个⼈姓名，其他的可以不填这条命令的完整含义是：使⽤ keytool.exe ，创建⼀个别名为 CA，算法为 RSA，有效天数为30天的密钥，并将它存放在 D:\keytoolCert\ ⽬录下的⼀个名叫 .CAkeystore 的密钥库中，如果密钥库不存在则⾃动创建。
执⾏完上述命令后，在 D:\keytoolCert\ ⽬录下⽣成了⼀个".CAkeystore"的⽂件，如下图所⽰：5.查看密钥库⾥⾯的信息命令如下：.\keytool.exe -list -keystore D:\keytoolCert\.CAkeystore -v结果如下：5.1.查看密钥库信息其他命令查看密钥库中指定密钥的信息：keytool.exe -list -alias CA -keystore“D:\keytoolCert.CAkeystore” -v6.导出密钥到证书⽂件.\keytool -export -alias CA -file D:\keytoolCert\pendIssueCert_1.cer -keystore D:\keytoolCert\.CAkeystore执⾏完上述命令后，在 D:\keytoolCert\ ⽬录下⽣成了⼀个"pendIssueCert_1.cer"的证书⽂件，如下图所⽰：7.查看指定证书⽂件的信息：keytool.exe -printcert -file D:\keytoolCert\.pendIssueCert_1.cer -v8.导⼊证书将证书⽂件 pendIssueCert_1.cer 导⼊到名为 .pendIssuekeystore 的证书库中keytool -import -keystore D:\keytoolCert\.pendIssuekeystore -file D:\keytoolCert\pendIssueCert_1.cer注意：D:\keytoolCert.pendIssuekeystore 密钥库不存在会⾃动创建导⼊时没有输⼊ -alias 那么它的别名就是 mykey ，如果有需要可以⾃⼰指定别名9.删除密钥库中的条⽬删除密钥库 .pendIssuekeystore 中别名为 mykey 的证书条⽬keytool -delete -keystore D:\keytoolCert\.pendIssuekeystore -alias mykey删除前先查看有⼀个密钥，删除后再查看就没有了，表⽰删除成功。
Keytool工具使用
Keytool工具使用一、生成证书按win键+R，弹出运行窗口，输入cmd回车，打开命令行窗户，输入如下命令：keytool -genkeypair -alias "test1" -keyalg "RSA" -keystore "test.keystore"功能：创建一个别名为test1的证书条目，该条目存放在名为test.keystore的密钥库中，若test.keystore密钥库不存在则创建。
参数说明：-genkeypair：生成一对非对称密钥;-alias：指定密钥对的别名，该别名是公开的;-keyalg：指定加密算法，本例中的采用通用的RAS加密算法;-keystore:密钥库的路径及名称，不指定的话，默认在操作系统的用户目录下(C:\Users\thinkpad)生成一个".keystore"的文件注意：1.在命令行中输入“keytool –genkey”将自动使用默认的算法生成公钥和私钥，这里并未指定使用何算法，将使用默认的DSA算法。
2.由于“.keystore”中包含了私钥，所以是一个需要保密的文件，因此上述操作提示为该文件设置一个密码：“输入密钥库口令”，这里第一次使用该密钥库，因此输入的密码“123456”将成为该默认的密钥库的密码（实际使用时应该设置复杂的口令）。
以后再使用这个密钥库时必须提供这个口令才可以使用。
3.以上操作最后还提示“输入<test1>的主密码”，这里“test1”是默认的别名，使用该名字可以在密钥库“.keystore”中找到对应的公钥、私钥和证书。
此处输入的密码是对应于该别名的私钥的密码，密钥库中每个别名可以使用不同的密码加以保护。
4.密钥库中可以存放多个条目（公钥/私钥对和证书），它们在密钥库中以别名(alias)区分。
在使用keytool工具时没有指定别名，因此系统使用了默认的别名mykey。
使用keytool生成证书
使⽤keytool⽣成证书keytool 简介keytool 是java ⽤于管理密钥和证书的⼯具，其功能包括：创建并管理密钥创建并管理证书作为CA 为证书授权导⼊导出证书主要格式keytool 采⽤ keystore ⽂件来存储密钥及证书，其中可包括私钥、信任证书；keystore ⽂件主要使⽤ JKS格式(也可⽀持其他格式)，带密钥存储；其中私钥的存储也有独⽴的密码；⼀、⽣成私钥和证书keytool -genkeypair -alias serverkey -keystore server.keystore按提⽰输⼊keystore 存储密码、私钥密码、个⼈信息，之后会⽣成 server.keystore⽂件若不想输⼊参数，可提供参数：keytool -genkeypair -alias serverkey -keypass 111111 -storepass 111111 \-dname "C=CN,ST=GD,L=SZ,O=vihoo,OU=dev,CN=" \-keyalg RSA -keysize 2048 -validity 3650 -keystore server.keystore参数说明storepass keystore ⽂件存储密码keypass 私钥加解密密码alias 实体别名(包括证书私钥)dname 证书个⼈信息keyalt 采⽤公钥算法，默认是DSAkeysize 密钥长度(DSA算法对应的默认算法是sha1withDSA，不⽀持2048长度，此时需指定RSA) validity 有效期keystore 指定keystore⽂件⼆、查看keystore详情查看详情命令keytool -list -keystore -storepass 111111 server.keystore输出结果Keystore type: JKSKeystore provider: SUNYour keystore contains 1 entryserverkey, Sep 25, 2016, PrivateKeyEntry,Certificate fingerprint (SHA1): 65:75:C9:08:A0:83:21:A1:D7:8D:DA:CD:3D:FB:C2:E0:50:96:29:62加上-v选项可查看更详细信息Keystore type: JKSKeystore provider: SUNYour keystore contains 1 entryAlias name: serverkeyCreation date: Jul 22, 2017Entry type: PrivateKeyEntryCertificate chain length: 1Certificate[1]:Owner: C=CN, ST=GD, L=SZ, O=vihoo, OU=dev, CN=Issuer: C=CN, ST=GD, L=SZ, O=vihoo, OU=dev, CN=Serial number: 5c5eb42Valid from: Sat Jul 2210:45:45 CST 2017until: Tue Jul 2010:45:45 CST 2027Certificate fingerprints:MD5: 27:ED:70:EF:4C:E3:7F:ED:6A:83:67:32:6D:10:24:38SHA1: 79:08:97:6E:62:EE:0F:E6:81:56:66:43:9C:9D:A4:11:EF:CC:28:0CSHA256: 3B:AC:56:8E:60:C2:C8:07:61:19:C7:4A:D3:AF:1F:60:77:24:94:7C:87:6E:C8:E7:17:14:E4:7A:34:0A:CD:8FSignature algorithm name: SHA256withRSAVersion: 3Extensions:#1: ObjectId: 2.5.29.14 Criticality=falseSubjectKeyIdentifier [KeyIdentifier [0000: B4 10 A9 26 5D 6C 4C 46 B4 69 ED 31 2B 20 D1 F4 ...&]lLF.i.1+ ..0010: 58 3C 8F 94 X<..]]三、证书导⼊导出导出证书keytool -exportcert -keystore server.keystore -file server.cer -alias serverkey -storepass 111111参数说明exportcert 表⽰导出证书alias 指⽰别名file 指⽰导出⽂件storepass 指⽰keystore密钥此时导出的证书为DER编码格式，使⽤openssl 可以输出openssl x509 -in server.cer -inform der -noout -text加上 -rfc选项，可输出PEM编码格式的证书keytool -exportcert -keystore server.keystore -rfc -file server.cer -alias serverkey -storepass 111111输出格式如：-----BEGIN CERTIFICATE-----MIIDUTCCAjmgAwIBAgIEBcXrQjANBgkqhkiG9w0BAQsFADBZMRIwEAYDVQQDEwl2...-----END CERTIFICATE-----导⼊证书⼀般为导⼊信任证书(SSL客户端使⽤)keytool -importcert -keystore client_trust.keystore -file server.cer -alias client_trust_server -storepass 111111 -noprompt 参数说明importcert 表⽰导⼊信任证书file 指⽰导⼊证书，⽀持pem/der格式keystore 指⽰⽬标keystore⽂件storepass 指⽰新的keystore密钥alias 指⽰trust证书在keystore中的别名noprompt 指⽰不弹出提⽰导⼊后的证书为 trustedCertEntry 实体类型，⽽私钥证书为 PrivateKeyEntry四、查看证书打印证书keytool -printcert -file server.cer输出Owner: CN=ZZ, OU=DEV, O=, L=GZ, ST=GD, C=CNIssuer: CN=ZZ, OU=DEV, O=, L=GZ, ST=GD, C=CNSerial number: 797f3140Valid from: Sun Sep 2516:43:55 CST 2016until: Sat Dec 2416:43:55 CST 2016Certificate fingerprints:MD5: FB:7D:29:4C:A9:F3:07:0E:CC:74:0D:9B:D4:D6:4D:91SHA1: 65:75:C9:08:A0:83:21:A1:D7:8D:DA:CD:3D:FB:C2:E0:50:96:29:62SHA256: E9:8B:A5:43:5F:40:FA:C5:64:3B:0A:11:1D:BE:D1:07:3C:A1:E2:50:88:71:A7:5C:EC:43:22:98:1B:AA:B6:EB Signature algorithm name: SHA1withDSAVersion: 3Extensions:#1: ObjectId: 2.5.29.14 Criticality=falseSubjectKeyIdentifier [KeyIdentifier [0000: 0E C3 62 D3 75 3A 3C B7 D9 C4 BD 8E 63 E7 6C EC ..b.u:<.....c.l.0010: AF 8A 2972 ..)r]]五、转换格式jks格式转 pkcs12keytool -importkeystore -srckeystore server.keystore -destkeystore server.p12 -srcalias serverkey -destalias serverkey \-srcstoretype jks -deststoretype pkcs12 -srcstorepass 111111 -deststorepass 111111 -noprompt参数说明importkeystore 指⽰导⼊导出keystore⽂件，可⽤于同类型或不同类型的导⼊导出srckeystore 指⽰源keystore⽂件srcalias 指⽰源实体别名srcstoretype 指⽰源store类型(jks/pkcs12..)srcstorepass 指⽰源store密码noprompt 不弹出提⽰pkcs12 转jks格式与此同理六、场景⽰例1. 制作Java SSL 双向证书storepass=111111keypass=111111server_dname="C=CN,ST=GD,L=SZ,O=vihoo,OU=dev,CN="client_dname="C=CN,ST=GD,L=SZ,O=vihoo,OU=dev,CN="echo"generate server keystore"keytool -genkeypair -alias serverkey -keypass $keypass -storepass $storepass \-dname $server_dname \-keyalg RSA -keysize 2048 -validity 3650 -keystore server.keystoreecho"generate client keystore"keytool -genkeypair -alias clientkey -keypass $keypass -storepass $storepass \-dname $client_dname \-keyalg RSA -keysize 2048 -validity 3650 -keystore client.keystoreecho"export server certificate"keytool -exportcert -keystore server.keystore -file server.cer -alias serverkey -storepass $storepassecho"export client certificate"keytool -exportcert -keystore client.keystore -file client.cer -alias clientkey -storepass $storepassecho"add server cert to client trust keystore"keytool -importcert -keystore client_trust.keystore -file server.cer -alias client_trust_server \-storepass $storepass -nopromptecho"add client cert to server trust keystore"keytool -importcert -keystore server_trust.keystore -file client.cer -alias server_trust_client \-storepass $storepass -noprompt2. Java 证书与 nginx 证书互转Java通常使⽤JKS作为证书存储格式，⽽Nginx往往采⽤PEM证书格式，如何实现互转？Nginx 证书转 JKSA pem证书和私钥合成p12openssl pkcs12 -export -in server.crt -inkey server.key -passin pass:111111 -password pass:111111 \-name server -out server.p12注意定义-name 选项，这将作为keystore识别实体的参数B p12 证书转jks 证书keytool -importkeystore -srckeystore server.p12 -destkeystore server.keystore \-srcstoretype pkcs12 -deststoretype jks -srcalias server -destalias server \-deststorepass 111111 -srcstorepass 111111如果p12 ⽂件中未指定实体名称，使⽤keytool转换时则不需提供srcalias/destalias参数，⽽输出的keystore实体名称默认为1 JKS 证书转 Nginx证书A jks 证书转p12keytool -importkeystore -srckeystore server.keystore -destkeystore server.p12 \-srcstoretype jks -deststoretype pkcs12 -srcalias server -destalias server \-deststorepass 111111 -srcstorepass 111111B p12 证书提取pem证书和私钥openssl pkcs12 -in server.p12 -clcerts -nokeys -password pass:111111 -out server.crtopenssl pkcs12 -in server.p12 -nocerts -password pass:111111 -passout pass:111111 -out server.key 其中得到的私钥⽂件为PKCS#8 加密格式，证书和密钥均为PEM⽂件编码。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
签名算法名称:SHA1withRSA
版本: 3
-----------------------------------------------------------------------
显示：（在windows下可以双击yushan.crt查看）
-----------------------------------------------------------------------
所有者:CN=yushan, OU=xx公司, O=xx协会, L=湘潭, ST=湖南, C=中国
CwwIeHjlhazlj7gxDzANBgNVBAMTBnl1c2hhbjAeFw0wOTA3MjgxNjQwMTNaFw0xMDA3MjgxNjQw
MTNaMGoxDzANBgNVBAYMBuS4reWbvTEPMA0GA1UECAwG5rmW5Y2XMQ8wDQYDVQQHDAbmuZjmva0x
-v 显示密钥库中的证书详细信息
-export 将别名指定的证书导出到文件 keytool -export -alias 需要导出的别名 -keystore 指定keystore -file 指定导出的证书位置及证书名称 -storepass 密码
-file 参数指定导出到文件的文件名
-delete 删除密钥库中某条目 keytool -delete -alias 指定需删除的别 -keystore 指定keystore -storepass 密码
签发人:CN=yushan, OU=xx公司, O=xx协会, L=湘潭, ST=湖南, C=中国
序列号:4a6f29ed
有效期: Wed Jul 29 00:40:13 CST 2009 至Thu Jul 29 00:40:13 CST 2010
证书指纹:
MD5:A3:D7:D9:74:C3:50:7D:10:C9:C2:47:B0:33:90:45:C3
Keystore 类型： JKS
Keystore 提供者： SUN
您的 keys
创建日期： 2009-7-29
项类型: PrivateKeyEntry
认证链长度： 1
认证 [1]:
-----BEGIN CERTIFICATE-----
姓氏), OU=(组织单位名称), O=(组织名称), L=(城市或区域名称), ST=(州或省份名称), C=(单位的两字母国家代码)";(中英文即可)
2、keystore信息的查看：
keytool -list -v -keystore e:\keytool\yushan.keystore -storepass 123456
hjL4wLfOURzUuxxuVQR2jx7QI+XKME+DHQj9r6aAcLBCi/T1jwF8mVYxtpRuTzE/6KEZdhowEe70
liWLVE+hytLBHZ03Zhwcd6q5HUMu27du3MPQvqiwzTY7MrwIvQQ8iQIDAQABMA0GCSqGSIb3DQEB
keytool -genkey -alias yushan(别名) -keypass yushan(别名密码) -keyalg RSA(算法) -keysize 1024(密钥长度) -validity 365(有效期，天单位) -keystore
e:\yushan.keystore(指定生成证书的位置和证书名称) -storepass 123456(获取keystore信息的密码)；回车输入相关信息即可；
-storepasswd 修改keystore口令 keytool -storepasswd -keystore e:\yushan.keystore(需修改口令的keystore) -storepass 123456(原始密码) -new yushan(新密码)
-import 将已签名数字证书导入密钥库 keytool -import -alias 指定导入条目的别名 -keystore 指定keystore -file 需导入的证书
项类型: PrivateKeyEntry
认证链长度： 1
认证 [1]:
所有者:CN=yushan, OU=xx公司, O=xx协会, L=湘潭, ST=湖南, C=中国
签发人:CN=yushan, OU=xx公司, O=xx协会, L=湘潭, ST=湖南, C=中国
序列号:4a6f29ed
下面是各选项的缺省值。
-alias "mykey"
-keyalg "DSA"
-keysize 1024
-validity 90
-keystore 用户宿主目录中名为 .keystore 的文件
-file 读时为标准输入，写时为标准输出
1、keystore的生成：
分阶段生成：
-printcert 查看导出的证书信息 keytool -printcert -file yushan.crt
-keypasswd 修改密钥库中指定条目口令 keytool -keypasswd -alias 需修改的别名 -keypass 旧密码 -new 新密码 -storepass keystore密码 -keystore sage
签名算法名称:SHA1withRSA
版本: 3
--------------------------------------------------------------------
缺省情况下，-list 命令打印证书的 MD5 指纹。而如果指定了 -v 选项，将以可读格式打印证书，如果指定了 -rfc 选项，将以可打印的编码格式输出证书。
BQUAA4GBAGoQQ1/FnTfkpQh+Ni6h3fZdn3sR8ZzDMbOAIYVLAhBb85XDJ8QZTarHbZMJcIdHxAl1
i08ct3E8U87V9t8GZFWVC4BFg/+zeFEv76SFpVE56iX7P1jpsu78z0m69hHlds77VJTdyfMSvtXv
5、证书的导入：
准备一个导入的证书：
keytool -genkey -alias shuany -keypass shuany -keyalg RSA -keysize 1024 -validity 365 -keystore e:\shuany.keystore -storepass 123456 -dname "CN=shuany,
ETAPBgNVBAoMCHh45Y2P5LyaMREwDwYDVQQLDAh4eOWFrOWPuDEPMA0GA1UEAxMGeXVzaGFuMIGf
MA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCJoru1RQczRzTnBWxefVNspQBykS220rS8Y/oX3mZa
有效期: Wed Jul 29 00:40:13 CST 2009 至Thu Jul 29 00:40:13 CST 2010
证书指纹:
MD5:A3:D7:D9:74:C3:50:7D:10:C9:C2:47:B0:33:90:45:C3
SHA1:2B:FC:9E:3A:DF:C6:C4:FB:87:B8:A0:C6:99:43:E9:4C:4A:E1:18:E8
-keypass 指定别名条目的密码(私钥的密码)
-dname 指定证书拥有者信息 例如： "CN=名字与姓氏,OU=组织单位名称,O=组织名称,L=城市或区域名称,ST=州或省份名称,C=单位的两字母国家代码"
-list 显示密钥库中的证书信息 keytool -list -v -keystore 指定keystore -storepass 密码
3、证书的导出：
keytool -export -alias yushan -keystore e:\yushan.keystore -file e:\yushan.crt(指定导出的证书位置及证书名称) -storepass 123456
4、查看导出的证书信息
keytool -printcert -file yushan.crt
-alias 产生别名
-keystore 指定密钥库的名称(产生的各类信息将不在.keystore文件中)
-keyalg 指定密钥的算法 (如 RSA DSA（如果不指定默认采用DSA）)
-validity 指定创建的证书有效期多少天
-keysize 指定密钥长度
-storepass 指定密钥库的密码(获取keystore信息所需的密码)
MIICSzCCAbSgAwIBAgIESm8p7TANBgkqhkiG9w0BAQUFADBqMQ8wDQYDVQQGDAbkuK3lm70xDzAN
BgNVBAgMBua5luWNlzEPMA0GA1UEBwwG5rmY5r2tMREwDwYDVQQKDAh4eOWNj+S8mjERMA8GA1UE
keytool -list -rfc -keystore e:\yushan.keystore -storepass 123456
显示：
-------------------------------------------------------------------------------------------------------
sYHP3fxfzx9WyhipBwd8VPK/NgEP
-----END CERTIFICATE-----