使用JAVA keytool工具生成服务器配置SSL使用的密钥存储文件

合集下载

签名验签证书

Resin说明本文使用"keytool"来生成私钥和CSR文件，JDK中一般已经默认安装有keytool，如果您的服务器上没有安装keytool,请先下载安装。

本文还要求安装有JSSE，如果使用JDK1.4及其以上版本，JSSE已经集成到JDK 中，否则请到SUN网站下载和安装JSSE: ，并把 jsse.jar、jcert.jar、 jnet.jar 复制到目录：$JAVA_HOME/jre/lib/ext安装完成后需要添加SSL安全服务提供者：修改 $JAVA_HOME/jre/lib/security/java.security文件中的:security.provider.2=.ssl.internal.ssl.Provider本文Resin安装配置示例使用的版本是2.1.17, 如果进行resin配置时不能成功完成，可能是版本原因，请参考resin帮助文件中SSL相关章节进行配置。

产生CSR重要注意事项在生成CSR文件时同时生成您的私钥，如果您丢了私钥或忘了私钥密码，则颁发证书给您后不能安装成功！您必须重新生成私钥和CSR文件，利用证书补办流程颁发新的证书。

为了避免此情况的发生，请在生成CSR后一定要备份私钥文件和记住私钥密码，最好是在收到证书之前不要再动服务器1. 生成 keystore 和 keyEntry请使用以下命令，并参考下图：keytool -genkey -alias [keyEntry_name] -keyalg RSA -keystore [keystore_name]请注意：keyEntry_name和keystore_name可以根据需要自行输入，但请与下文中内容保持一致。

如果您不指定一个 keystore 名称(不使用参数 -keystore)，则 keystore 文件将保存在您的用户目录中(如：C:\Documents andSettings\your name\.keystore)，文件名为：.keystore系统会提示您输入 keystore 密码，缺省密码为：changeit，您可以指定一个新的密码，但请一定要记住。

使用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即成功生成。

一般来说，在根证书中只需导入顶级根证即可。

客户端浏览器中只要安装了相应的二级根证，二级根证所颁发的证书即可获得信任，出现在证书选择框中。

tomcat配置 ssl单向双向以及keytool使用介绍

1.王华斌本机测试过可行的例子小技巧: keytool -list -v –keystore keystore文件的全路径查看当前keystore文件中包含的证书：*******************************************如下：C:\tomcat5.0.28\jakarta-tomcat-5.0.28\bin>keytool -list -v -keystore "c:\tomcat.keystore"C:\tomcat5.0.28\jakarta-tomcat-5.0.28\bin>keytool -list -v -keystore "C:/ProgramFiles/Java/jdk1.6.0_26/jre/lib/security/cacerts"/kf/201108/100519.htmltomcat ssl单向/双向2011-08-17 13:52:30 我来说两句收藏我要投稿 [字体：小大] tomcat6配置：1.单向认证，就是传输的数据加密过了，但是不会校验客户端的来源2.双向认证，如果客户端浏览器没有导入客户端证书，是访问不了web系统的，找不到地址如果只是加密，我感觉单向就行了。

如果想要用系统的人没有证书就访问不了系统的话，就采用双向单向配置第一步：为服务器生成证书使用keytool 为 tomcat 生成证书，假定目标机器的域名是“ localhost ”， keystore 文件存放在“ c:\tomcat.keystore ”，口令为“ password ”，使用如下命令生成：keytool -genkey -v -alias tomcat -keyalg rsa -validity 3650 -keystorec:\tomcat.keystore -dname "cn=localhost,ou=cn,o=cn,l=cn,st=cn,c=cn" -storepasspassword -keypass password这个tomcat.cer是为了解决不信任时要导入的keytool -export -alias tomcat -keystore c:\tomcat.keystore -file c:\tomcat.cer -storepass password第四步：配置tomcat 服务器打开tomcat 根目录下的 /conf/server.xml ，找到如下配置段，修改如下：<connector port="8443" protocol="http/1.1" sslenabled="true"maxthreads="150" scheme="https" secure="true"clientauth="false" sslprotocol="tls"keystorefile="c:/tomcat.keystore" keystorepass="password" >应用程序的web.xml 可以加上这句话：具体web系统<auth-method>client-cert</auth-method><realm-name>client cert users-only area</realm-name></login-config><security-constraint><web-resource-collection ><web-resource-name >ssl</web-resource-name><url-pattern>/*</url-pattern></web-resource-collection><user-data-constraint><transport-guarantee>confidential</transport-guarantee></user-data-constraint></security-constraint>到这里启动tomcat，输入https://localhost:8443/这时再打开会弹出一个提示框：证书不可信任，有一个警告，说什么需要机构颁发。

tomcat ssl证书格式

Tomcat SSL证书格式SSL证书在保护互联网通信中起着至关重要的作用。

Tomcat作为一种常用的Java Web服务器，也需要配置SSL证书以确保安全性。

在本文中，我们将讨论Tomcat SSL证书的格式。

一、什么是SSL证书SSL证书是一种数字证书，用于确保网站的安全性和数据的保密性。

它通过加密通信数据，确保数据在传输过程中的安全性。

同时，SSL证书还能验证服务器的身份，确保用户与合法服务器建立连接，防止中间人攻击。

二、Tomcat SSL证书配置步骤1. 生成SSL证书在配置Tomcat SSL证书之前，需要先生成SSL证书。

常见的生成方式有使用Java keytool工具或使用第三方工具如OpenSSL。

生成证书时需要指定密钥长度、有效期、域名等信息。

2. 导入证书到密钥库生成证书后，需要将证书导入到Tomcat使用的密钥库中。

密钥库是存储安全证书的地方。

使用keytool工具可以将证书导入到密钥库中。

3. 配置Tomcat的server.xml文件打开Tomcat的server.xml配置文件，在其中找到Connector元素，并添加以下属性：<Connector port="443"protocol="org.apache.coyote.http11.Http11NioProtocol"maxThreads="150" SSLEnabled="true" scheme="https"secure="true" keystoreFile="密钥库文件路径"keystorePass="密钥库密码"clientAuth="false" sslProtocol="TLS"/>其中，keystoreFile属性为密钥库文件路径，keystorePass属性为密钥库密码。

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。

如何应用JDK中的keytool.exe命令工具创建数字证书

ห้องสมุดไป่ตู้
6、导出生成安全证书文件的命令和创建过程
（1）在操作系统的命令行窗口中输入如下的命令 keytool -export -alias yangSB -file F:/server.cer -keystore f:/server.keystore -validity 365
上面的命令的主要功能将实现把位于目录文件中的数字证书库f:/server.keystore中的别名为“yangSB”的证书导出到 F:/server.cer的数字证书文件中。在F:/server.cer的数字证书文件中将包含有证书主体的信息及证书的公钥等方面的信息，但不包括私钥信息。因此，该server.cer数字证书文件可以公开。（2）输入密码然后再输入前面的f:/server.keystore数字证书库文件中存储的keystore密码（本示例为123456），系统将会在F盘的根目录中创建出一个文件名称为server.cer的数字证书文件。其中的“-file F:/server.cer”命令参数即为要求生成.cer 格式文件，如下示图所示：
（3）双击所创建的server.cer的数字证书文件，将能够正常地看到数字证书中相关的信息。
3、熟悉和了解数字证书文件
（1）数字证书库中的一条证书可以导出为数字证书文件，而数字证书文件只包括主体信息和对应的公钥——公共密钥用于加密信息，私用密钥用于解译加密的信息。（2）每一个数字证书库是由一个文件所组成，并保存有访问的密码。在首次创建时，它会自动生成数字证书库，并要求指定访问该数字证书库的密码。
2、数字证书的主要用途
（1）发送安全电子邮件、访问安全站点、网上证券交易、网上招标采购、网上办公、网上保险、网上税务、网上签约和网上银行等安全电子事务处理和安全电子交易等活动中。（2）比如，将服务器端的SSL证书安装于服务器设备上，可以用来证明服务器的身份和进行通信加密。因为，应用服务器端的数字证书可以有效地防止欺诈的“钓鱼”站点。

java keystore 创建证书

在Java中，你可以使用keytool命令行工具来创建和管理密钥库和证书。

下面是如何使用keytool创建一个自签名的证书的步骤：1.首先，打开命令提示符或终端。

2.使用以下命令创建一个新的密钥库（如果该文件已存在，keytool会抛出一个错误）：bash复制代码keytool -genkey -alias mycert -keyalg RSA -keystore keystore.jks -keysize 2048在这个命令中：复制代码* `-genkey`表示生成密钥对。

* `-alias mycert`表示为这个证书设置一个别名"mycert"。

* `-keyalg RSA`表示使用RSA算法生成密钥对。

* `-keystore keystore.jks`表示将生成的密钥对存储在名为"keystore.jks"的文件中。

* `-keysize 2048`表示生成的密钥长度为2048位。

3. 在命令提示符或终端中，你将看到一些提示，要求你输入密钥库和密钥的密码，以及一些证书信息（如你的名字和组织）。

按照提示输入这些信息。

4. 完成后，你会看到一条消息，表示证书已经成功生成并存储在密钥库中。

5. 要查看密钥库中的证书，可以使用以下命令：bash复制代码keytool -list -alias mycert -keystore keystore.jks 这将列出与别名"mycert"关联的所有条目。

请注意，自签名证书只适用于测试和开发环境。

在生产环境中，你应该从受信任的证书颁发机构（CA）获取证书。

JavaSSLTLSSocket实现

JavaSSLTLSSocket实现通信端⽆需向对⽅证明⾃⼰的⾝份，则称该端处于“客户模式”，否则称其处于“服务器模式”，⽆论是客户端还是服务器端，都可处于“客户模式”或者“服务器模式”⾸先⽣成服务器端认证证书，使⽤java⾃带的keytool⼯具：其中：-genkey：⽣成⼀对⾮对称密钥-keyalg：加密算法-keystore：证书存放路径-alias：密钥对别名，该别名是公开的相同的⽅式，⽣成客户端认证证书，不过命名为client_rsa.key，别名为clientkey使⽤jdk1.5，唯⼀需要引⼊的包为log4j-1.2.14.jar客户端认证：package com.test.client.auth;import java.io.FileInputStream;import java.security.KeyStore;import java.util.Properties;import .ssl.KeyManager;import .ssl.KeyManagerFactory;import .ssl.SSLContext;import .ssl.TrustManager;import .ssl.TrustManagerFactory;import com.test.server.config.Configuration;public class Auth {private static SSLContext sslContext;public static SSLContext getSSLContext() throws Exception{Properties p = Configuration.getConfig();String protocol = p.getProperty("protocol");String sCertificateFile = p.getProperty("serverCertificateFile");String sCertificatePwd = p.getProperty("serverCertificatePwd");String sMainPwd = p.getProperty("serverMainPwd");String cCertificateFile = p.getProperty("clientCertificateFile");String cCertificatePwd = p.getProperty("clientCertificatePwd");String cMainPwd = p.getProperty("clientMainPwd");//KeyStore class is used to save certificate.char[] c_pwd = sCertificatePwd.toCharArray();KeyStore keyStore = KeyStore.getInstance("JKS");keyStore.load(new FileInputStream(sCertificateFile), c_pwd);//TrustManagerFactory class is used to create TrustManager class.TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance("SunX509");char[] m_pwd = sMainPwd.toCharArray();trustManagerFactory.init(keyStore);//TrustManager class is used to decide weather to trust the certificate//or not.TrustManager[] tms = trustManagerFactory.getTrustManagers();KeyManager[] kms = null;if(Configuration.getConfig().getProperty("authority").equals("2")){//KeyStore class is used to save certificate.c_pwd = cCertificatePwd.toCharArray();keyStore = KeyStore.getInstance("JKS");keyStore.load(new FileInputStream(cCertificateFile), c_pwd);//KeyManagerFactory class is used to create KeyManager class.KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("SunX509");m_pwd = cMainPwd.toCharArray();keyManagerFactory.init(keyStore, m_pwd);//KeyManager class is used to choose a certificate//to prove the identity of the client side.kms = keyManagerFactory.getKeyManagers();}//SSLContext class is used to set all the properties about secure communication. //Such as protocol type and so on.sslContext = SSLContext.getInstance(protocol);sslContext.init(kms, tms, null);return sslContext;}}客户端主程序：package com.test.client;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.IOException;import .InetSocketAddress;import .SocketAddress;import java.util.Properties;import .ssl.SSLContext;import .ssl.SSLSocket;import .ssl.SSLSocketFactory;import org.apache.log4j.Logger;import com.test.client.auth.Auth;import com.test.server.config.Configuration;import com.test.tools.SocketIO;public class Client {static Logger logger = Logger.getLogger(Client.class);private SSLContext sslContext;private int port = 10000;private String host = "127.0.0.1";private SSLSocket socket;private Properties p;public Client(){try {p = Configuration.getConfig();Integer authority = Integer.valueOf(p.getProperty("authority"));sslContext = Auth.getSSLContext();SSLSocketFactory factory = (SSLSocketFactory) sslContext.getSocketFactory(); socket = (SSLSocket)factory.createSocket();String[] pwdsuits = socket.getSupportedCipherSuites();socket.setEnabledCipherSuites(pwdsuits);//socket可以使⽤所有⽀持的加密套件if(authority.intValue() == 2){socket.setUseClientMode(false);socket.setNeedClientAuth(true);}else{socket.setUseClientMode(true);socket.setWantClientAuth(true);}SocketAddress address = new InetSocketAddress(host, port);socket.connect(address, 0);} catch (Exception e) {e.printStackTrace();logger.error("socket establish failed!");}}public void request(){try{String encoding = p.getProperty("socketStreamEncoding");DataOutputStream output = SocketIO.getDataOutput(socket);String user = "name";byte[] bytes = user.getBytes(encoding);short length = (short)bytes.length;short pwd = (short)123;output.writeShort(length);output.write(bytes);output.writeShort(pwd);DataInputStream input = SocketIO.getDataInput(socket);length = input.readShort();bytes = new byte[length];input.read(bytes);("request result:"+new String(bytes,encoding));}catch(Exception e){e.printStackTrace();logger.error("request error");}finally{try {socket.close();} catch (IOException e) {e.printStackTrace();}}}public static void main(String[] args){Client client = new Client();client.request();}}服务器端认证：package com.test.server.auth;import java.io.FileInputStream;import java.security.KeyStore;import java.util.Properties;import .ssl.KeyManager;import .ssl.KeyManagerFactory;import .ssl.SSLContext;import .ssl.TrustManager;import .ssl.TrustManagerFactory;import com.test.server.config.Configuration;public class Auth {private static SSLContext sslContext;public static SSLContext getSSLContext() throws Exception{Properties p = Configuration.getConfig();String protocol = p.getProperty("protocol");String sCertificateFile = p.getProperty("serverCertificateFile");String sCertificatePwd = p.getProperty("serverCertificatePwd");String sMainPwd = p.getProperty("serverMainPwd");String cCertificateFile = p.getProperty("clientCertificateFile");String cCertificatePwd = p.getProperty("clientCertificatePwd");String cMainPwd = p.getProperty("clientMainPwd");//KeyStore class is used to save certificate.char[] c_pwd = sCertificatePwd.toCharArray();KeyStore keyStore = KeyStore.getInstance("JKS");keyStore.load(new FileInputStream(sCertificateFile), c_pwd);//KeyManagerFactory class is used to create KeyManager class.KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("SunX509");char[] m_pwd = sMainPwd.toCharArray();keyManagerFactory.init(keyStore, m_pwd);//KeyManager class is used to choose a certificate//to prove the identity of the server side.KeyManager[] kms = keyManagerFactory.getKeyManagers();TrustManager[] tms = null;if(Configuration.getConfig().getProperty("authority").equals("2")){//KeyStore class is used to save certificate.c_pwd = cCertificatePwd.toCharArray();keyStore = KeyStore.getInstance("JKS");keyStore.load(new FileInputStream(cCertificateFile), c_pwd);//TrustManagerFactory class is used to create TrustManager class.TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance("SunX509"); m_pwd = cMainPwd.toCharArray();trustManagerFactory.init(keyStore);//TrustManager class is used to decide weather to trust the certificate//or not.tms = trustManagerFactory.getTrustManagers();}//SSLContext class is used to set all the properties about secure communication.//Such as protocol type and so on.sslContext = SSLContext.getInstance(protocol);sslContext.init(kms, tms, null);return sslContext;}}服务器端主程序：package com.test.server;import java.io.IOException;import .InetSocketAddress;import java.util.Properties;import java.util.concurrent.Executor;import java.util.concurrent.Executors;import .ssl.SSLContext;import .ssl.SSLServerSocket;import .ssl.SSLServerSocketFactory;import .ssl.SSLSocket;import org.apache.log4j.Logger;import com.test.server.auth.Auth;import com.test.server.business.Job;import com.test.server.config.Configuration;public class Server {static Logger logger = Logger.getLogger(Server.class);private SSLContext sslContext;private SSLServerSocketFactory sslServerSocketFactory;private SSLServerSocket sslServerSocket;private final Executor executor;public Server() throws Exception{Properties p = Configuration.getConfig();Integer serverListenPort = Integer.valueOf(p.getProperty("serverListenPort"));Integer serverThreadPoolSize = Integer.valueOf(p.getProperty("serverThreadPoolSize"));Integer serverRequestQueueSize = Integer.valueOf(p.getProperty("serverRequestQueueSize")); Integer authority = Integer.valueOf(p.getProperty("authority"));executor = Executors.newFixedThreadPool(serverThreadPoolSize);sslContext = Auth.getSSLContext();sslServerSocketFactory = sslContext.getServerSocketFactory();//Just create a TCP connection.SSL shake hand does not begin.//The first time either side(server or client) try to get a socket input stream//or output stream will case the SSL shake hand begin.sslServerSocket = (SSLServerSocket) sslServerSocketFactory.createServerSocket();String[] pwdsuits = sslServerSocket.getSupportedCipherSuites();sslServerSocket.setEnabledCipherSuites(pwdsuits);//Use client mode.Must prove its identity to the client side.//Client mode is the default mode.sslServerSocket.setUseClientMode(false);if(authority.intValue() == 2){//The communication will stop if the client side doesn't show its identity.sslServerSocket.setNeedClientAuth(true);}else{//The communication will go on although the client side doesn't show its identity.sslServerSocket.setWantClientAuth(true);}sslServerSocket.setReuseAddress(true);sslServerSocket.setReceiveBufferSize(128*1024);sslServerSocket.setPerformancePreferences(3, 2, 1);sslServerSocket.bind(new InetSocketAddress(serverListenPort),serverRequestQueueSize);("Server start up!");("server port is:"+serverListenPort);}private void service(){while(true){SSLSocket socket = null;try{logger.debug("Wait for client request!");socket = (SSLSocket)sslServerSocket.accept();logger.debug("Get client request!");Runnable job = new Job(socket);executor.execute(job);}catch(Exception e){logger.error("server run exception");try {socket.close();} catch (IOException e1) {e1.printStackTrace();}}}}public static void main(String[] args) {Server server;try{server = new Server();server.service();}catch(Exception e){e.printStackTrace();logger.error("server socket establish error!");}}}服务器业务执⾏线程：package com.test.server.business;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.IOException;import .Socket;import java.util.Properties;import org.apache.log4j.Logger;import com.test.server.config.Configuration;import com.test.tools.SocketIO;public class Job implements Runnable {static Logger logger = Logger.getLogger(Job.class);private Socket socket;public Job(Socket socket){this.socket = socket;}public void run() {Properties p = Configuration.getConfig();String encoding = p.getProperty("socketStreamEncoding");DataInputStream input = null;DataOutputStream output = null;try{input = SocketIO.getDataInput(socket);short length = input.readShort();byte[] bytes = new byte[length];input.read(bytes);String user = new String(bytes,encoding);short pwd = input.readShort();String result = null;if(null != user && !user.equals("") && user.equals("name") && pwd == 123){ result = "login success";}else{result = "login failed";}("request user:"+user);("request pwd:"+pwd);output = SocketIO.getDataOutput(socket);bytes = result.getBytes(encoding);length = (short)bytes.length;output.writeShort(length);output.write(bytes);("response info:"+result);}catch(Exception e){e.printStackTrace();logger.error("business thread run exception");}finally{try {socket.close();} catch (IOException e) {e.printStackTrace();logger.error("server socket close error");}}}}配置⽂件类：package com.test.server.config;import java.io.File;import java.io.FileInputStream;import java.io.InputStream;import java.util.Properties;import org.apache.log4j.Logger;public class Configuration {private static Properties config;static Logger logger = Logger.getLogger(Configuration.class);public static Properties getConfig(){try{if(null == config){File configFile = new File("./conf/conf.properties");if(configFile.exists() && configFile.isFile()&& configFile.canRead()){InputStream input = new FileInputStream(configFile);config = new Properties();config.load(input);}}}catch(Exception e){//default setconfig = new Properties();config.setProperty("protocol", "TLSV1");config.setProperty("serverCertificateFile", "./certificate/server_rsa.key");config.setProperty("serverCertificatePwd", "123456");config.setProperty("serverMainPwd", "654321");config.setProperty("clientCertificateFile", "./certificate/client_rsa.key");config.setProperty("clientCertificatePwd", "123456");config.setProperty("clientMainPwd", "654321");config.setProperty("serverListenPort", "10000");config.setProperty("serverThreadPoolSize", "5");config.setProperty("serverRequestQueueSize", "10");config.setProperty("socketStreamEncoding", "UTF-8");}return config;}}接⼝⼯具类：package com.test.tools;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.IOException;import .Socket;public class SocketIO{public static DataInputStream getDataInput(Socket socket) throws IOException{DataInputStream input = new DataInputStream(socket.getInputStream());return input;}public static DataOutputStream getDataOutput(Socket socket) throws IOException{ DataOutputStream out = new DataOutputStream(socket.getOutputStream());return out;}}配置⽂件：#1：单向认证，只有服务器端需证明其⾝份#2：双向认证，服务器端和客户端都需证明其⾝份authority=2#通信协议protocol=TLSV1#服务器证书serverCertificateFile=./certificate/server_rsa.key#服务器证书密码serverCertificatePwd=123456#服务器证书主密码serverMainPwd=654321#客户端证书，如果为双向认证，则必须填写clientCertificateFile=./certificate/client_rsa.key#客户端证书密码clientCertificatePwd=123456#客户端证书主密码clientMainPwd=654321#服务器监听端⼝,注意root权限serverListenPort=10000#服务器线程池线程数(2*核数+1)serverThreadPoolSize=5#服务器Socket请求队列长度serverRequestQueueSize=10#字节流编码socketStreamEncoding=GBK⽇志⽂件：log4j.rootLogger=debug,logOutput,fileLogOutputlog console out putlog4j.appender.logOutput=org.apache.log4j.ConsoleAppenderyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%p%d{[yy-MM-dd HH:mm:ss]}[%c] -> %m%n#log file out putlog4j.appender.fileLogOutput=org.apache.log4j.RollingFileAppenderlog4j.appender.fileLogOutput.File=./log/server.loglog4j.appender.fileLogOutput.MaxFileSize=1000KBlog4j.appender.fileLogOutput.MaxBackupIndex=3yout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%p%d{[yy-MM-dd HH:mm:ss]}[%c] -> %m%n运⾏后的结果：客户端：INFO[13-10-08 09:33:39][com.test.client.Client] -> request result:login success服务端：INFO[13-10-08 09:33:34][com.test.server.Server] -> Server start up!INFO[13-10-08 09:33:34][com.test.server.Server] -> server port is:10000DEBUG[13-10-08 09:33:34][com.test.server.Server] -> Wait for client request!DEBUG[13-10-08 09:33:39][com.test.server.Server] -> Get client request!DEBUG[13-10-08 09:33:39][com.test.server.Server] -> Wait for client request!INFO[13-10-08 09:33:39][com.test.server.business.Job] -> request user:nameINFO[13-10-08 09:33:39][com.test.server.business.Job] -> request pwd:123INFO[13-10-08 09:33:39][com.test.server.business.Job] -> response info:login successPS:1，不能随意的使⽤close()⽅法关闭socket输⼊输出流，使⽤close()⽅法关闭socket输⼊输出流会导致socket本⾝被关闭2，字符串必须按照指定的编码转换为字节数组，字节数组也必须通过相同的编码转换为字符串，否则将会出现乱码String[] pwdsuits = socket.getSupportedCipherSuites();socket.setEnabledCipherSuites(pwdsuits);加密套件（ciphersuits）包括⼀组加密参数，这些参数指定了加密算法、密钥长度等加密等信息。

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证书工具使用小结Keytool是一个Java数据证书的管理工具,Keytool将密钥（key）和证书（certificates）存在一个称为keystore的文件中在keystore里，包含两种数据:密钥实体（Key entity）-密钥（secret key）或者是私钥和配对公钥（采用非对称加密）可信任的证书实体（trusted certificate entries）-只包含公钥.JDK中keytool常用参数说明（不同版本有差异，详细可参见【附录】中的官方文档链接）:∙-genkey在用户主目录中创建一个默认文件”.keystore”,还会产生一个mykey的别名，mykey中包含用户的公钥、私钥和证书(在没有指定生成位置的情况下,keystore会存在用户系统默认目录)∙-alias 产生别名每个keystore都关联这一个独一无二的alias，这个alias通常不区分大小写∙-keystore指定密钥库的名称(产生的各类信息将不在.keystore文件中)∙-keyalg指定密钥的算法(如RSA DSA，默认值为：DSA)∙-validity 指定创建的证书有效期多少天(默认90)∙-keysize指定密钥长度（默认1024）∙-storepass指定密钥库的密码(获取keystore信息所需的密码)∙-keypass指定别名条目的密码(私钥的密码)∙-dname指定证书发行者信息其中：“CN=名字与姓氏,OU=组织单位名称,O=组织名称,L=城市或区域名称,ST=州或省份名称,C=单位的两字母国家代码”∙-list 显示密钥库中的证书信息keytool -list -v -keystore指定keystore -storepass密码∙-v 显示密钥库中的证书详细信息∙-export 将别名指定的证书导出到文件keytool -export -alias 需要导出的别名-keystore指定keystore -file 指定导出的证书位置及证书名称-storepass密码∙-file 参数指定导出到文件的文件名∙-delete 删除密钥库中某条目keytool -delete -alias 指定需删除的别-keystore指定keystore – storepass密码∙-printcert查看导出的证书信息keytool -printcert -file g:\sso\michael.crt∙-keypasswd修改密钥库中指定条目口令keytool -keypasswd -alias 需修改的别名-keypass旧密码-new 新密码-storepasskeystore密码-keystore sage∙-storepasswd修改keystore口令keytool -storepasswd -keystoreg:\sso\michael.keystore(需修改口令的keystore) -storepasspwdold(原始密码) -newpwdnew(新密码)∙-import 将已签名数字证书导入密钥库keytool -import -alias 指定导入条目的别名-keystore指定keystore -file 需导入的证书目录说明：1.生成证书2.查看证书3.证书导出4.附录资料一、生成证书按win键+R，弹出运行窗口，输入cmd回车，打开命令行窗户，输入如下命令：1 keytool -genkey -alias michaelkey -keyalg RSA -keysize 1024 -keypassmichaelpwd -validity 365 -keystore g:\sso\michael.keystore -storepass michaelpwd2截图如下：二、查看证书1 keytool -list -v -keystore g:\sso\michael.keystore -storepass michaelpwd2 回车看到的信息如下：-rfc命令如下：1 keytool -list -rfc -keystore g:\sso\michael.keystore -storepass michaelpwd2 回车看到的信息如下：1 keytool -export -alias michaelkey -keystore g:\sso\michael.keystore -file g:\sso\michael.crt -storepass michaelpwd2回车如下：查看导出的证书信息：1 keytool -printcert -file g:\sso\michael.crt 回车看到信息如下：四：附录官方有关keytool命令的介绍文档：∙jdk1.4.2 ：/javase/1.4.2/docs/tooldocs/windows/keytool.html ∙jdk1.6 ：/javase/6/docs/technotes/tools/windows/keytool.html∙jdk1.7 ：/javase/7/docs/technotes/tools/windows/keytool.htmls。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

使用JA V A keytool工具生成服务器配置SSL使用的密钥存储文件
1.生成密钥存储文件和密钥对
密钥存储文件: keystore文件是密钥存储文件,即后缀为jks的文件,密钥存储文件是存储密钥的容器,用于存储密钥,密钥存储文件在产生的时候可以选择是否产生密钥对,并将密钥对存入密钥存储文件中
keytool -genkey -alias server -keyalg RSA -keysize 1024 -keystore keystore.jks
-genkey[产生密钥对]
-alias[密钥对别名]
-keyalg[密钥算法参数]
-keysize[密钥位数]
-keystore[密钥存储文件路径]
2.通过密钥存储文件(使用密钥对)产生SSL证书请求文件(csr文件)
keytool -certreq -alias server -sigalg MD5withRSA -file server.csr -keypass password -keystore keystore.jks -storepass password
-certreq[产生待签名证书]
-alias[证书别名]
-sigalg[证书算法参数]
-file[产生文件输出路径]
-keypass[密钥保护密码]
-keystore[存储文件路径]
-storepass[存储密码]
3.将SSL证书请求文件发给CA进行签名,生成服务器证书(cer证书)
CA:证书管理机构,所谓CA（Certificate Authority）认证，是指采用PKI（Public Key Infrastructure）公开密钥基础架构技术，专门提供网络身份认证服务，负责签发和管理数字证书，且具有权威性和公正性的第三方信任机构，它的作用就像我们现实生活中颁发证件的公司，如护照办理机构。

目前国内的CA认证中心主要分为区域性CA认证中心和行业性CA认证中心
4.获取生成服务器证书的CA的根证书并导入密钥存储文件
联系CA,获取CA的根证书,将根证书导入密钥存储文件
keytool –import –v –trustcacerts -storepass password -alias my-ca-root -file intermediate.cer -keystore keystore.jks
-import[导入命令]
-v -trustcacerts[导入信任证书]
-storepass[存储密码]
-alias[证书别名]
-file[证书文件路径]
-keystore[导入文件路径]
5.将服务器证书导入密钥存储文件
Keytool –import –v –trustcacerts -storepass password -alias server –file server.cer -keystore keystore.jks
6.将导入了CA根证书和服务器证书的密钥存储文件配置到启用ssl的服务器上
7.查看密钥存储文件
keytool -list -keystore keystore.jks。