本文试图以通俗易通的方式介绍Https的工作原理，不纠结具体的术语，不考证严格的流程。我相信弄懂了原理之后，到了具体操作和实现的时候，方向就不会错，然后条条大路通罗马。阅读文本需要提前大致了解对称加密、非对称加密、信息认证等密码学知识。如果你不太了解，可以阅读Erlang发明人Joe Armstrong最近写的Cryptography Tutorial。大牛出品，通俗易懂，强力推荐。
Https涉及到的主体
- 客户端。通常是浏览器(Chrome、IE、FireFox等)，也可以自己编写的各种语言的客户端程序。
- 服务端。一般指支持Https的网站，比如github、支付宝。
- CA(Certificate Authorities)机构。Https证书签发和管理机构，比如Symantec、Comodo、GoDaddy、GlobalSign。
下图里我画出了这几个角色：
发明Https的动机
- 认证正在访问的网站。什么叫认证网站？比如你正在访问支付宝，怎样确定你正在访问的是阿里巴巴提供的支付宝而不是假冒伪劣的钓鱼网站呢？
- 保证所传输数据的私密性和完整性。众所周知，Http是明文传输的，所以处在同一网络中的其它用户可以通过网络抓包来窃取和篡改数据包的内容，甚至运营商或者wifi提供者，有可能会篡改http报文，添加广告等信息以达到盈利的目的。
Https的工作流程
这一节通过介绍Https协议的工作流程，来说明Https是如何达成自己的两个目的的。下图我画出了Https的工作流程，注意，这只是原理示意图，并不是详细的协议解析。
可以看到工作流程，基本分为三个阶段：
- 认证服务器。浏览器内置一个受信任的CA机构列表，并保存了这些CA机构的证书。第一阶段服务器会提供经CA机构认证颁发的服务器证书，如果认证该服务器证书的CA机构，存在于浏览器的受信任CA机构列表中，并且服务器证书中的信息与当前正在访问的网站（域名等）一致，那么浏览器就认为服务端是可信的，并从服务器证书中取得服务器公钥，用于后续流程。否则，浏览器将提示用户，根据用户的选择，决定是否继续。当然，我们可以管理这个受信任CA机构列表，添加我们想要信任的CA机构，或者移除我们不信任的CA机构。
- 协商会话密钥。客户端在认证完服务器，获得服务器的公钥之后，利用该公钥与服务器进行加密通信，协商出两个会话密钥，分别是用于加密客户端往服务端发送数据的客户端会话密钥，用于加密服务端往客户端发送数据的服务端会话密钥。在已有服务器公钥，可以加密通讯的前提下，还要协商两个对称密钥的原因，是因为非对称加密相对复杂度更高，在数据传输过程中，使用对称加密，可以节省计算资源。另外，会话密钥是随机生成，每次协商都会有不一样的结果，所以安全性也比较高。
- 加密通讯。此时客户端服务器双方都有了本次通讯的会话密钥，之后传输的所有Http数据，都通过会话密钥加密。这样网路上的其它用户，将很难窃取和篡改客户端和服务端之间传输的数据，从而保证了数据的私密性和完整性。
使用Https的流程
如果你是一个服务器开发者，想使用Https来保护自己的服务和用户数据安全，你可以按照以下流程来操作。
总结
- 说是讨论Https，事实上Https就是Http跑在SSl或者TLS上，所以本文讨论的原理和流程其实是SSL和TLS的流程，对于其它使用SSL或者TLS的应用层协议，本文内容一样有效。
- 本文只讨论了客户端验证服务端，服务端也可以给客户端颁发证书并验证客户端，做双向验证，但应用没有那么广泛，原理类似。
- 由于采用了加密通讯，Https无疑要比Http更耗费服务器资源，这也是很多公司明明支持Https却默认提供Http的原因。
1- 使用HTTPS连接器，需要生成一份Certificate keystore，用于加密和机密浏览器的SSL沟通
# windows:
keytool -genkeypair -alias "tomcat" -keyalg "RSA" -keystore "d:\\1.keystore"# linux:
keytool -genkey -alias tomcat -keyalg RSA# 执行完上述命令后在home目录下多了一个新的.keystore文件
2- 新增属性文件 tomcat.https.properties
类比
<!-- Define an SSL HTTP/1.1 Connector on port 443 -->
<Connector className="org.apache.catalina.connector.http.HttpConnector"
port="443" minProcessors="5" maxProcessors="75"
keystoreFile="path.to.keystore"
enableLookups="true"
acceptCount="10" debug="0" scheme="https" secure="true">
<Factory className="org.apache.catalina.net.SSLServerSocketFactory"
clientAuth="false" protocol="TLS" keystorePass="keystore.password"/>
</Connector>custom.tomcat.https.port=443
custom.tomcat.https.secure=true
custom.tomcat.https.scheme=https
custom.tomcat.https.ssl=true
custom.tomcat.https.keystore=d:\\1.keystore
custom.tomcat.https.keystore-password=xinli2016import java.io.File;
import org.apache.catalina.Context;
import org.apache.catalina.connector.Connector;
import org.apache.tomcat.util.descriptor.web.SecurityCollection;
import org.apache.tomcat.util.descriptor.web.SecurityConstraint;
import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory;
import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
@Configuration
@PropertySource("classpath:/tomcat.https.properties")
@EnableConfigurationProperties(WebConfiguration.TomcatSslConnectorProperties.class)
public class WebConfiguration extends WebMvcConfigurerAdapter {
@Bean
public EmbeddedServletContainerFactory servletContainer(TomcatSslConnectorProperties properties) {
TomcatEmbeddedServletContainerFactory tomcat = new TomcatEmbeddedServletContainerFactory() {
@Override
protected void postProcessContext(Context context) {
// SecurityConstraint必须存在，可以通过其为不同的URL设置不同的重定向策略。
SecurityConstraint securityConstraint = new SecurityConstraint();
securityConstraint.setUserConstraint("CONFIDENTIAL");
SecurityCollection collection = new SecurityCollection();
collection.addPattern("/*");
securityConstraint.addCollection(collection);
context.addConstraint(securityConstraint);
}
};
tomcat.addAdditionalTomcatConnectors(createSslConnector(properties));
return tomcat;
}
private Connector createSslConnector(TomcatSslConnectorProperties properties) {
Connector connector = new Connector();
properties.configureConnector(connector);
return connector;
}
@ConfigurationProperties(prefix = "custom.tomcat.https")
public static class TomcatSslConnectorProperties {
private Integer port;
private Boolean ssl = true;
private Boolean secure = true;
private String scheme = "https";
private File keystore;
private String keystorePassword;
// 省略 get set
public void configureConnector(Connector connector) {
if (port != null) {
connector.setPort(port);
}
if (secure != null) {
connector.setSecure(secure);
}
if (scheme != null) {
connector.setScheme(scheme);
}
if (ssl != null) {
connector.setProperty("SSLEnabled", ssl.toString());
}
if (keystore != null && keystore.exists()) {
connector.setProperty("keystoreFile", keystore.getAbsolutePath());
connector.setProperty("keystorePass", keystorePassword);
}
}
}
}
下面生成的 .keystore文件也可以用 .jks 后缀代替，
jks 的意思就是 Java keystore， 另外需要知道
.cer文件是二进制的，
.pem文件是文本文件， 本质都是一样的， 他们可以互相转换。
java 语言操作的是二进制的文件， 其他的一些脚本语言， 可能操作的是PEM格式的文件。看具体情况吧。
创建服务端keystore
keytool -genkey -v -alias server_ks -keysize 2048 -keyalg RSA -dname "CN=www.abc.com" -keypass 123456 -storepass 123456 -keystore ./server.keystore -validity 36500
创建客户端keystore
keytool -genkey -v -alias client_ks -keysize 2048 -keyalg RSA -dname "CN=www.abc.com" -keypass 123456 -storepass 123456 -keystore ./client.keystore -validity 36500
导出服务端证书
keytool -export -v -alias server_ks -keystore ./server.keystore -storepass 123456 -file ./server.cer
导出客户端证书
keytool -export -v -alias client_ks -keystore ./client.keystore -storepass 123456 -file ./client.cer
将服务端证书导入到客户端trustkeystroe
keytool -import -v -alias xxx -keystore ./clientTrust.jks -storepass 123456 -file ./server.cer
将客户端证书导入到服务端trustkeystroe
keytool -import -v -alias xxx -keystore ./serverTrust.jks -storepass 123456 -file ./client.cer
把二进制的CER文件转换为文本的PEM文件
openssl x509 -in ./xxx.cer -inform der -outform pem -out ./xxx.pem
把文本的PEM文件转换为二进制的CER文件
openssl x509 -in ./xxx.pem -inform pem -outform der -out ./xxx.cer
jks文件(java key store文件)转化为浏览器可以加载的PKCS12格式
keytool -importkeystore -srckeystore ./client.keystore -destkeystore ./browser.p12 -srcstoretype JKS -deststoretype PKCS12 -keypass 123456 -storepass 123456
storetype 类型有 JKS, JCEKS, PKCS12, PKCS11 and DKS
下面的命令查看证书是否已经添加到信任列表中了
keytool -list -keystore ./serverTrust.jks
import org.apache.catalina.Context;
import org.apache.catalina.connector.Connector;
import org.apache.tomcat.util.descriptor.web.SecurityCollection;
import org.apache.tomcat.util.descriptor.web.SecurityConstraint;
import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory;
import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.SocketUtils;
/**
* Created by tangcheng on 5/28/2017.
*/
@Configuration
public class SslConfig {
@Bean
public EmbeddedServletContainerFactory servletContainer() {
TomcatEmbeddedServletContainerFactory tomcat = new TomcatEmbeddedServletContainerFactory() {
@Override
protected void postProcessContext(Context context) {
// SecurityConstraint必须存在，可以通过其为不同的URL设置不同的重定向策略。
SecurityConstraint constraint = new SecurityConstraint();
constraint.setUserConstraint("CONFIDENTIAL");
SecurityCollection collection = new SecurityCollection();
collection.addPattern("/*");
constraint.addCollection(collection);
context.addConstraint(constraint);
}
};
tomcat.addAdditionalTomcatConnectors(httpConnector());
return tomcat;
}
@Bean
public Connector httpConnector() {
Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
connector.setScheme("http");
//Connector监听的http的端口号
connector.setPort(80);
connector.setSecure(false);
//监听到http的端口号后转向到的https的端口号
connector.setRedirectPort(8443);
return connector;
}
@Bean
public Integer port() {
return SocketUtils.findAvailableTcpPort();
}
}
浏览器的地址栏中显示不安全：因为这个证书是不收信任的，传统一般都企业都是需要购买此证书的
http://docs.spring.io/spring-boot/docs/1.5.3.RELEASE/reference/htmlsingle/#howto-configure-ssl
证书颁发机构
- CA机构私钥
openssl genrsa -out ca.key 2048- CA证书
openssl req -x509 -new -key ca.key -out ca.crt注意生成过程中需要输入一些CA机构的信息
服务端
- 生成服务端私钥
openssl genrsa -out server.key 2048- 生成服务端证书请求文件
openssl req -new -key server.key -out server.csr注意生成过程中需要你输入一些服务端信息
- 使用CA证书生成服务端证书
openssl x509 -req -sha256 -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -days 3650 -out server.crt关于sha256，默认使用的是sha1，在新版本的chrome中会被认为是不安全的，因为使用了过时的加密算法。
- 打包服务端的资料为pkcs12格式(非必要，只是换一种格式存储上一步生成的证书)
openssl pkcs12 -export -in server.crt -inkey server.key -out server.pkcs12生成过程中，需要创建访问密码，请记录下来。
- 生成服务端的keystore（.jks文件, 非必要，Java程序通常使用该格式的证书）
keytool -importkeystore -srckeystore server.pkcs12 -destkeystore server.jks -srcstoretype pkcs12生成过程中，需要创建访问密码，请记录下来。
- 把ca证书放到keystore中（非必要）
keytool -importcert -keystore server.jks -file ca.crt客户端
- 导入根证书ca.crt到浏览器受信任的根证书颁发机构列表中
不管通过什么浏览器吧，总之你要找到下面这个页面，点击导入，将上面生成的CA机构的ca.crt导入到收信任的根证书颁发机构列表中。
注意，收信任的根证书颁发机构列表是操作系统级的，不管通过哪个浏览器进入配置，都是只需要配置一次，再使用其它浏览器时，无需重复配置。
Spring Boot
Spring Boot为web容器提供了统一的抽象配置，不管你使用的是Tomcat是Jetty还是其它web容器，如果要在Spring Boot中使用Https，你只需要在你的配置类中，添加如下代码，注册一个EmbeddedServletContainerCustomizer Bean即可。
需要用到上面生成的Server.jks文件
@Configuration
public class WebConfig {
@Bean
public EmbeddedServletContainerCustomizer containerCustomizer() {
return new EmbeddedServletContainerCustomizer() {
@Override
public void customize(ConfigurableEmbeddedServletContainer container) {
Ssl ssl = new Ssl();
ssl.setKeyStore("Server.jks");
ssl.setKeyStorePassword("passwd");
container.setSsl(ssl);
container.setPort(8443);
}
};
}
}Nginx
如果要在Nginx中使用Https，需要用到上面生成的Server.crt，Server.key。
server {
listen 127.0.0.1:443 ssl;
ssl on;
ssl_certificate Server.crt;
ssl_certificate_key Server.key;
#省略无关配置...
}总结
crt、jks、pkcs12都是用来保存证书的不同格式，不同的服务器软件可能会使用不同格式的证书文件。
OpenSSl、Keytool都是可以用来生成Https证书的工具软件，其中OpenSSl功能更多更复杂，Keytool随JDK安装而安装。
证书的格式是多样的，生成证书的软件工具有很多，不同服务器程序的配置方法不尽相同，要达成目的有很多种方法。所以，重要的是弄懂原理，而不是按照教程一步一步敲命令。
跟白话Https一样，本文仍然没有介绍服务端怎么验证客户端，但如果你弄懂了原理，我想你已经可以自己去实现了。
前言：
因为公司项目客户要求使用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目录下，如下图所示：
使用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的文件。
成功后无提示信息
注意：
①D:/keys/ 目录需要提前手动创建好，否则会生成失败
②提示输入域名的时候不能输入IP地址
问题①的错误信息如下：
第二步：为客户端生成证书
为浏览器生成证书，以便让服务器来验证它。
为了能将证书顺利导入至IE和Firefox，证书格式应该是PKCS12，
因此，使用如下命令生成：
keytool
-genkey
-alias client
-keypass 123456
-keyalg RSA
-storetype PKCS12
-keypass 123456
-storepass 123456
-keystore D:/keys/client.p12
方便复制版：
keytool -genkey -alias client1 -keypass 123456 -keyalg RSA -keysize 1024 -validity 365 -storetype PKCS12 -keystore D:/keys/client1.p12 -storepass 123456
图例：
第二步余下操作步骤同第一步。
第三步：让服务器信任客户端证书
1、
由于不能直接将PKCS12格式的证书库导入，
必须先把客户端证书导出为一个单独的CER文件，使用如下命令：
keytool -export -alias client -keystore D:/keys/client.p12 -storetype PKCS12 -keypass 123456 -file D:/keys/client.cer
注意：
Keypass：指定CER文件的密码，但会被忽略，而要求重新输入
2、
将该文件导入到服务器的证书库，添加为一个信任证书：
keytool -import -v -file D:/keys/client.cer -keystore D:/keys/tomcat.keystor
e -storepass 123456
图例：
完成之后通过list命令查看服务器的证书库，
可以看到两个证书，一个是服务器证书，一个是受信任的客户端证书：
keytool -list -v -keystore D:/keys/tomcat.keystore
第四步：让客户端信任服务器证书
1、
由于是双向SSL认证，客户端也要验证服务器证书，
因此，必须把服务器证书添加到浏览器的“受信任的根证书颁发机构”。
由于不能直接将keystore格式的证书库导入，
必须先把服务器证书导出为一个单独的CER文件，使用如下命令：
keytool -keystore D:/keys/tomcat.keystore -export -alias tomcat6 -file D:/keys/server.cer
2、
双击server.cer文件，按照提示安装证书，
将证书填入到“受信任的根证书颁发机构”。
填入方法：
打开浏览器 - 工具 - internet选项-内容- 证书-把中级证书颁发机构里的www.localhost.com(该名称即时你前面生成证书时填写的名字与姓氏)证书导出来-再把导出来的证书导入 受信任的根颁发机构 就OK了。
第五步：配置Tomcat服务器
<Connector port="8443"
protocol="org.apache.coyote.http11.Http11NioProtocol" SSLEnabled="true"
maxThreads="150"
scheme="https"
secure="true"
clientAuth="true"
sslProtocol="TLS"
keystoreFile="D:/keys/tomcat.keystore"
keystorePass="123456"
truststoreFile="D:/keys/tomcat.keystore"
truststorePass="123456" />
属性说明：
clientAuth:设置是否双向验证，默认为false，设置为true代表双向验证
keystoreFile:服务器证书文件路径
keystorePass:服务器证书密码
truststoreFile:用来验证客户端证书的根证书，此例中就是服务器证书
truststorePass:根证书密码
注意：
① 设置clientAuth属性为True时，需要手动导入客户端证书才能访问。
② 要访问https请求 需要访问8443端口，访问http请求则访问Tomcat默认端口（你自己设置的端口，默认8080）即可。
总结：
经过以上五步，你使用HTTPS 端口为8443 进行访问的时候 就是经过SSL信息加密，不怕被截获了。
通话的双方，必须是都拥有证书的端，才能进行会话，换句话说，就是只有安装了咱证书的客户端，才能与服务器通信。
小贴士：
强制 https 访问
在 tomcat /conf/web.xml 中的 </welcome- file-list> 后面加上这
1. <login-config>
2. <!-- Authorization setting for SSL -->
3. <auth-method>CLIENT-CERT</auth-method>
4. <realm-name>Client Cert Users-only Area</realm-name>
5. </login-config>
6. <security-constraint>
7. <!-- Authorization setting for SSL -->
8. <web-resource-collection >
9. <web-resource-name >SSL</web-resource-name>
10. <url-pattern>/*</url-pattern>
11. </web-resource-collection>
12. <user-data-constraint>
13. <transport-guarantee>CONFIDENTIAL</transport-guarantee>
14. </user-data-constraint>
15. </security-constraint>
完成以上步骤后，在浏览器中输入http的访问地址也会自动转换为https了。
附录1:
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 cacerts
1 SSL单向认证概念
当客户端（服务请求方）向服务端（服务提供方）发起请求时，服务器端需要向客户端提供认证。服务端需要生成一个keystore和一个服务器密钥对儿（公钥和私钥），客户端需要生成一个truststore，然后导入服务端的公钥证书。
2 keystore以及服务器密钥对儿的生成
keytool -genkeypair -alias certificatekey -keyalg RSA -validity 365 -keystore shfqkeystore.jks
这条命令会在生成keystore后接着生成一个密钥对儿。RSA是非对称密钥算法，也可以改为 keytool支持的其他密钥算法，365代表的是证书的有效期，可以自己指定，shfqkeystore.jks是keystroe的名称，也可以自己指定。打开cmd命令行,输入：
keytool -genkeypair -alias certificatekey -keyalg RSA -validity 365 -keystore shfqkeystore.jks
会提示输入keystore的密码，接着会提示输入名字等信息，如下图：
补充：输入<certificatekey>的主密码，是指生成服务端证书的私钥。服务端私钥如果和keystore的相同的话，直接按回车。建议直接按回车，即服务端私钥和keystore的密码相同。如果两者的密码不相同的话在服务端tomcat server.xml中配置完毕以后启动tomcat会报一个UnrecoverableKeyException: Cannot recover key的异常（后面会介绍服务端 tomcat server.xml 的配置的）。
keytool会把生成的keystore文件默认保存到C:\Users\lenovo路径下（用户目录下的计算机名称下）接下来生成的所有文件也都保存到此处。
3 验证新生成的keystor文件以及证书信息
可以执行下面的命令：
keytool -list -v -keystore shfqkeystore.jks
会显示出以下信息，如图：
4 导出公钥证书
下面的命令可以导出自签公钥证书：
keytool -export -alias certificatekey -keystore shfqkeystore.jks -rfc -file shfqcert.cer
其中shfqcert.cer是导出证书的名称，可以随便起个名字，shfqkeystore.jks是2中生成的keystore 文件。
执行上面的命令会要求输入shfqkeystore的密码，会显示以下信息，如下图。
5 Truststore的生成以及公钥证书的导入
把4生成的公钥证书shfqcert.cer导入到truststore中
Keytool -import -alias certificatekey -file shfqcert.cer -keystore
shfqtruststore.jks
shfqcert.cer是4导出的公钥证书，shfqtruststore.jks可以随便起，是生成的truststore的文件名。这条命令首先会生成一个truststore，然后导入4生成的公钥证书shfqcert.cer。
执行keytool -import -alias certificatekey -file shfqcert.cer -keystore shfqtruststore.jks后，首先会提示输入truststore的密码，如下图：
6 验证5生成的truststore文件
keytool -list -v -keystore shfqtruststore.jks
shfqtruststore.jks是5生成的truststore文件名。
到此为止，keystore、truststore、公钥证书都已生成完毕。
7 配置服务端的tomcat
找到tomcat安装路径下的conf路径下的server.xml文件
打开server.xml，找到
<!--
<Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true"
maxThreads="150" scheme="https" secure="true"
clientAuth="false" sslProtocol="TLS" />
-->这样一段注释，在这段注释下面添加如下一段代码：
<Connector SSLEnabled="true" acceptCount="100" clientAuth="false"
disableUploadTimeout="true"
enableLookups="false" maxThreads="25"
port="8443" keystoreFile="D:\developTools\apache-tomcat-idm\tomcat.keystore" keystorePass="111111"
protocol="org.apache.coyote.http11.Http11NioProtocol" scheme="https"
secure="true" sslProtocol="TLS" />其中clientAuth=”false”表示是SSL单向认证，即服务端认证，port=”8443”是https的访问端口，keystoreFile="D:\developTools\apache-tomcat-idm\tomcat.keystore"是第一步中生成的keystore的保存路径，keystorePass="111111"是第一步生成的keystore的密码。
到此服务器端已经配置完毕，为了验证是否已经配置正确，我们可以在浏览器中进行验证。首先启动tomcat，然后在浏览器地址输入栏中输入：https://localhost:8443
如果看到如下截图的一个页面则表示服务端已经配置成功了。
之所以会出现“该网站的安全证书不受信任！”的警告是因为证书是自己签发的而不是一个权威的CA机构签发的。
最后还得在hosts文件中配置自己的IP地址，把IP地址映射为一个common name，这个common name就是您在第2步中生成服务器证书时候的“您的名字与姓氏是什么？”输入的名字。
8 客户端配置
在客户端配置服务端的地址时要注意：比如 https://shifengqiang:8443/syn/Users
这个地址协议格式是https主机名是shifengqiang，这个shifengqiang就是在第2步中生成服务器端证书时要求输入的“您的名字与姓氏是什么？”名字。8443是https协议默认的端口。
在客户端向服务器端同步代码前面加入这样一段代码：
System.setProperty("Java.protocol.handler.pkgs", "com.sun.NET.ssl.internal.www.protocol");
System.setProperty("java.protocol.handler.pkgs", "com.ibm.Net.ssl.internal.www.protocol");
String trustStorePath =
“D:\developTools\apache-tomcat-idm\shfqtruststore.jks”;
String trustStorePassword = “client”;
System.setProperty("javax.net.ssl.trustStore", trustStorePath);
System.setProperty("javax.net.ssl.trustStorePassword", trustStorePassword);
其中trustStorePath 是truststore的路径，trustStorePassword 是truststore的密码。至此单向SSL配置完毕。
参考链接：http://zjumty.iteye.com/blog/1885356
