1、环境准备

1.1、 Nginx

Nginx版本：1.12.0

Nginx为了支持Https需要安装http_ SSL _module模块。在编译时需要带上–with-http_ssl_module参数。

 
 ./configure --prefix=/usr/local/nginx --with-http_ssl_module
make && make install

然后通过./nginx -V查看有没有–with-http_ssl_module参数。

1.2、 OpenSSL 生成公私钥

无论是客户端还是服务端，都可以使用openssl命令来生成公私钥，前提是需要安装好openssl。

生成服务端私钥

 openssl genrsa [-out filename] [numbits]

比如：生成一个名为 server .key的私钥，长度1024。


 openssl genrsa -out server.key

生成服务端公钥证书

 openssl req -new -x [-key keyfile] [-out crtfile] [-days numdays]

比如：生成一个名为server.crt的证书，有效期10年。


 openssl req -new -x -key server.key -out server.crt -days 3650

依次会要求输入国家、省市、公司单位、域名、邮箱等信息。

最关键的是域名信息 com mon Name，这里需要填写服务器的域名地址，比如test.com；也可以填写泛域名，比如*.test.com；如果没有域名，可以直接填写服务端ip地址。

通过以上2步，已经生成了私钥server.key，公钥证书server.crt。

生成客户端公私钥

 
 # 生成客户端证书私钥
openssl genrsa -out client.key
# 生成客户端公钥证书
openssl req -new -x -key client.key -out client.crt -days 3650
# 生客户端p格式证书，需要输入一个密码，选一个好记的，比如123456
openssl pkcs -export -clcerts -in client.crt -inkey client.key -out client.p12

最后会将公私钥两个文件合成得到一个p12文件，p12文件主要用于客户端（包括Postman、浏览器、 Java 客户端等）发起https请求提供公私钥。

还可以利用Java自带的keytool工具来生成公私钥，并且可以和open ssl 生成的公私钥进行互相转换。具体可以参考文末的附录。

2、单向认证配置和客户端调用

2.1、Nginx配置

编辑nginx.conf文件在http{…}配置块中新增一个server配置块。

 
 # 负载均衡配置
upstream backend {
    server.168.0.1:10900;
    server.168.0.2:10900;
    server.168.0.3:10900;
}
 
server {
    listen ssl;
    server_name  localhost;
 
    ssl_certificate      ../ssl/server.crt;  # server公钥证书
    ssl_certificate_key  ../ssl/server.key;  # server私钥
 
    ssl_session_cache    shared:SSL:m;
    ssl_session_timeoutm;
 
    ssl_ciphers  HIGH:!aNULL:!MD;
    ssl_prefer_server_ciphers  on;
 
    access_log logs/access.log; # 单独指定输出访问日志
    error_log logs/error.log; # # 单独指定输出错误日志
 
    location / {
        proxy_pass    
    }
}

单向认证只需要配置服务器的公私钥即可，这里的相对路径是相对Nginx的配置文件nginx.conf的路径而言的。而输出日志的相对路径是相对于conf目录的路径而言。

2.2、Postman调用

只需要把原来请求的http替换成https即可，不需要做其它任何改动。

2.3、浏览器调用

也是把http替换成https就行了。

如果浏览器提示有风险NET::ERR_CERT_AUTHORITY_INVALID，这主要是服务端证书是我们自己通过命令生成签发的，不是来自于正规的CA机构签发，所以导致浏览器不信任，可以点击 高级 -> 继续前往 即可。

注意这里最好使用谷歌浏览器测试 ，国内一些浏览器可能会提示NET::ERR_CERT_REVOKED证书已被吊销，达不到测试效果。

2.4、Java客户端调用

网上很多都是采用 httpclient 作为http库，这里比较推荐使用Hutool工具包。

 
 <dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>.2.4</version>
</dependency>
 HttpResponse httpResponse = HttpRequest.post("#;")
                . ContentType ("text/plain")
                .body("requestBody")
                .execute();
System.out.println(httpResponse.getStatus());
System.out.println(httpResponse.body());

只要把原来的http替换成https就行，非常的方便！

3、双向认证配置和客户端调用

3.1、Nginx配置

也是在http{…}配置块中新增一个server配置块。

 
 # 负载均衡配置
upstream backend {
    server.168.0.1:10900;
    server.168.0.2:10900;
    server.168.0.3:10900;
}
 
server {
    listen ssl;
    server_name  a.com;
 
    ssl_certificate      ../ssl/server.crt;  # server公钥证书
    ssl_certificate_key  ../ssl/server.key;  # server私钥
    ssl_client_certificate ../clientcrt/clientA.crt;  # client公钥证书
    ssl_verify_client on;  # 开启客户端证书验证
 
    ssl_session_cache    shared:SSL:m;
    ssl_sess io n_timeout  5m;
 
    ssl_ciphers  HIGH:!aNULL:!MD;
    ssl_prefer_server_ciphers  on;
 
    access_log logs/a_access.log;
    error_log logs/a_error.log;
 
    location / {
        proxy_pass    
    }
}

因为是双向认证，不仅客户端要认证服务端，服务端也需要认证客户端，所以相较于单向认证，会多出以下2个配置参数：

ssl_verify_client on 表示开启双向认证，服务端也要认证客户端，该参数默认是off关闭。
ssl_client_certificate 配置客户端公钥证书存放的路径位置。

3.2、Postman调用

在设置General中先把SSL certificate verification关掉。

然后在Certificates中配置客户端公私钥证书。注意这里的地址和端口要与实际的一致，否则请求时会认证失败。

或者可以只配置p12文件，同时也要配置p12文件的密码。p12文件可以认为是一对公私钥的合体文件，通常会有密码保护；可以通过openssl命令生成（将公私钥两个文件合成得到一个p12文件）。

最后发起请求

3.3、浏览器调用

浏览器一般用单向认证会比较多，双向认证的详细配置步骤这里就不多啰嗦了。主要就是把自己客户端的p12文件导入到自己电脑的证书列表中再访问服务端，如果提示服务端的证书有风险，点击继续就行。

3.4、Java客户端调用

这里我们使用httpclient来发起https的请求进行双向认证。

 
 <dependency>
    <groupId>org. apache .httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>.5.8</version>
</dependency>

不过也分为2种方式：

一种是要把服务端公钥证书导入到客户端JDK的cacerts文件中；
另一种则是把服务端的公钥证书自行生成一个truststore信任库，由客户端程序读取这个信任库然后发起https请求进行双向认证。

3.4.1、导入cacerts进行访问

 
 # 切换到jdk的security目录
cd $JAVA_HOME/jre/lib/security
# 将服务端证书导入cacerts文件中，指定别名myserver，-file参数指定的就是服务端公钥证书的路径
keytool -import -alias myserver -keystore cacerts -storepass changeit -file C:/Users/my/Desktop/cert/server_ssl/server.crt
 
# 查看所有证书
keytool -list -keystore cacerts -storepass changeit
# 删除指定别名的证书
keytool -delete -alias myserver -keystore cacerts -storepass changeit

示例代码

 
 import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods. close ableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;
import org.junit.Test;
 
import javax.net.ssl.SSLContext;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.security.KeyStore;
 
public class SSLTestCase {
    /**
     * 客户端p证书路径
     */
    private String pfxPath = "C:/Users/my/Desktop/cert/client.p";
    /**
     * 客户端p证书密码
     */
    private String pfxPasswd = "";
 
    private String url = "#;;
 
    @Test
    public void SSLTestCase() throws Exception {
        /**
         *.加载P12证书
         */
        KeyStore keyStore = KeyStore. getInstance ("PKCS12");
        InputStream instream = new FileInputStream(new File(pfxPath));
        try {
            keyStore.load(instream, pfxPasswd.toCharArray());
        } finally {
            instream.close();
        }
        SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(keyStore, pfxPasswd.toCharArray()).build();
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext,
                new String[]{"TLSv"}, // supportedProtocols ,这里可以根据实际情况设置
                null,
                SSLConnectionSocketFactory.getDefaultHostnameVerifier());
        /**
         *.使用httpclient4.5.8发送post请求
         */
        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
        // 设置超时时间
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectTimeout()
                .setSocketTimeout().build();
        CloseableHttpResponse response = null;
        try {
            HttpPost httpPost = new HttpPost(url);
            httpPost.setConfig(requestConfig);
//            httpPost.addHeader("Connection", "keep-alive"); // 设置一些header等
            String requestBody = "requestBody";
//            StringEntity stringEntity = new StringEntity(requestBody, "UTF-");
            StringEntity stringEntity = new StringEntity(requestBody, ContentType.create("text/plain", "UTF-"));
            httpPost.setEntity(stringEntity);
            response = httpclient.execute(httpPost);
            HttpEntity entity = response.getEntity();
            String respBody = EntityUtils.toString(response.getEntity(), "UTF-");
            EntityUtils.consume(entity);
            System.out.println(respBody);
        } finally {
            if (httpclient != null) {
                httpclient.close();
            }
            if (response != null) {
                response.close();
            }
        }
    }
}

3.4.2、自行生成truststore信任库文件进行访问

如果服务器的JDK/JRE不能随便改动，我们还可以自行生成truststore信任库，由程序来读取这个信任库中的证书。

 
 # -keystore参数指定生成后的truststore文件，-file参数指定服务公钥证书路径
keytool -keystore C:/Users/my/Desktop/cert/server_ssl/server.truststore -keypass -storepass 654321 -alias myservertruststore -import -trustcacerts -file C:/Users/my/Desktop/cert/server_ssl/server.crt

示例代码

 
 import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.junit.Test;
 
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.security.KeyStore;
import java.security.SecureRandom;
 
public class SSLTestCase {
    /**
     * 客户端p证书路径
     */
    private String pfxPath = "C:/Users/my/Desktop/cert/client.p";
    /**
     * 客户端p证书密码
     */
    private String pfxPasswd = "";
    /**
     * 信任库路径
     */
    private String trustStroreFile = "C:/Users/my/Desktop/cert/server_ssl/server.truststore";
    /**
     * 信任库密码
     */
    private String trustStorePwd = "";
 
    private String url = "#;;
 
    @Test
    public void SSLTestCase() throws Exception {
        /**
         *.初始化密钥库
         */
        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("SunX");
        KeyStore keyStore = getKeyStore(pfxPath, pfxPasswd, "PKCS");
        keyManagerFactory.init(keyStore, pfxPasswd.toCharArray());
 
        /**
         *.初始化信任库
         */
        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance("SunX");
        KeyStore trustkeyStore = getKeyStore(trustStroreFile, trustStorePwd, "JKS");
        trustManagerFactory.init(trustkeyStore);
 
        SSLContext sslContext = SSLContext.getInstance("SSL");
        sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), new SecureRandom());
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext,
                new String[]{"TLSv"}, // supportedProtocols ,这里可以根据实际情况设置
                null,
                SSLConnectionSocketFactory.getDefaultHostnameVerifier());
 
        /**
         *.使用httpclient4.5.8发送post请求
         */
        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
        // 设置超时时间
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectTimeout()
                .setSocketTimeout().build();
        CloseableHttpResponse response = null;
        try {
            HttpPost httpPost = new HttpPost(url);
            httpPost.setConfig(requestConfig);
//            httpPost.addHeader("Connection", "keep-alive"); // 设置一些header等
            String requestBody = "requestBody";
//            StringEntity stringEntity = new StringEntity(requestBody, "UTF-");
            StringEntity stringEntity = new StringEntity(requestBody, ContentType.create("text/plain", "UTF-"));
            httpPost.setEntity(stringEntity);
            response = httpclient.execute(httpPost);
            HttpEntity entity = response.getEntity();
            String respBody = EntityUtils.toString(response.getEntity(), "UTF-");
            EntityUtils.consume(entity);
            System.out.println(respBody);
        } finally {
            if (httpclient != null) {
                httpclient.close();
            }
            if (response != null) {
                response.close();
            }
        }
    }
 
    private KeyStore getKeyStore(String pfxPath, String pfxPasswd, String type) throws Exception {
        KeyStore keyStore = KeyStore.getInstance(type);
        InputStream instream = new FileInputStream(new File(pfxPath));
        try {
            keyStore.load(instream, pfxPasswd.toCharArray());
        } finally {
            instream.close();
        }
        return keyStore;
    }
}

总结双向认证的几种客户端调用方式，可以发现只有Java客户端调用时会需要用到服务端证书；而用Postman、浏览器这些客户端工具时我们并没有配置服务端证书，是因为在一开始建立连接时，服务端本来就会把自己的证书发给客户端去进行认证。

3.5、客户端获取服务端公钥证书

有时候，产线环境的服务端公钥证书并不能很方便地拿出来给客户端去使用，这时候需要客户端通过执行openssl的一个命令来获取服务端的公钥证书，当然前提是Nginx服务需要启动。


 openssl s_client -connect.9.127.172:21000 </dev/null | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' >./server.crt

-connect：Nginx服务器的ip和端口。
服务端公钥证书最后输出到客户端本地目录的server.crt文件。

4、双向认证接入多个客户端

很多时候作为服务端要对接多个客户端，每个客户端都有自己的证书，Nginx服务端需要为每一个接入的客户端渠道配置一个server块来进行双向认证。既然是多个server配置块，那就会涉及到对接入的客户端匹配哪个server块来进行双向认证的问题。

首先Nginx会根据不同的监听端口来匹配，但是这样会为每个接入的客户端渠道新开放一个端口。如何统一用一个监听端口接入所有客户端的https请求并验证各个渠道的证书合法性，主要有以下2种方式。

4.1、SNI 多域名匹配不同证书

这里就需要使用到SNI功能。如果编译Nginx开启了http_ssl_module模块，一般默认也是启用SNI功能的，可以通过./nginx -V命令查看。

Nginx配置多个vhost

 
 # 负载均衡配置
upstream backend {
    server.168.0.1:10900;
    server.168.0.2:10900;
    server.168.0.3:10900;
}
 
# 渠道A
server {
    listen ssl;
    server_name  a.test.com;
 
    ssl_certificate      ../ssl/server.crt;  # server公钥证书
    ssl_certificate_key  ../ssl/server.key;  # server私钥
    ssl_client_certificate ../clientcrt/clientA.crt;  # client公钥证书
    ssl_verify_client on;  # 开启客户端证书验证
 
    ssl_session_cache    shared:SSL:m;
    ssl_session_timeoutm;
 
    ssl_ciphers  HIGH:!aNULL:!MD;
    ssl_prefer_server_ciphers  on;
 
    access_log logs/a_access.log;
    error_log logs/a_error.log;
 
    location / {
        proxy_pass    
    }
}
 
# 渠道B
server {
    listen ssl;
    server_name  b.test.com;
 
    ssl_certificate      ../ssl/server.crt;  # server公钥证书
    ssl_certificate_key  ../ssl/server.key;  # server私钥
    ssl_client_certificate ../clientcrt/clientB.crt;  # client公钥证书
    ssl_verify_client on;  # 开启客户端证书验证
 
    ssl_session_cache    shared:SSL:m;
    ssl_session_timeoutm;
 
    ssl_ciphers  HIGH:!aNULL:!MD;
    ssl_prefer_server_ciphers  on;
 
    access_log logs/b_access.log;
    error_log logs/b_error.log;
 
    location / {
        proxy_pass    
    }
}

配置的listen端口是一样的，但每个vhost的server_name不同，这里其实是通过配置不同的server_name来匹配各个不同的客户端，需要客户端请求的url中的域名（Http请求头中的Host字段值）与配置的server_name一致。比如：

a.test.com/senddata 客户端渠道A请求url
b.test.com/senddata 客户端渠道B请求url

客户端的域名解析可以通过域名解析服务器或者可以在本地hosts文件中配置。

需要注意的是：如果使用SNI功能，服务器签发公钥证书时，填写的域名信息Common Name需要是泛域名，比如*.test.com。这样客户端在验证服务器域名时才会通过。

另外，Nginx在同一个端口下匹配多个vhost时，如果找不到匹配的server_name，则会使用默认的vhost（默认第一个）来进行认证。为了防止隐式匹配带来的一些问题困扰，可以通过default_server显式地指定一个默认的vhost，一律返回401。

 
 server {
    listen ssl default_server;
 
    ssl_certificate      ../ssl/server.crt;  # server公钥证书
    ssl_certificate_key  ../ssl/server.key;  # server私钥
 
    access_log logs/default_access.log;
    error_log logs/default_error.log;
 
    location / {
        return;
    }
}

4.2、CA根证书统一签发客户端证书

先统一生成CA根证书，然后由根证书派生出服务端和各个客户端的证书。

生成root根证书

 
 # 创建根证书私钥
openssl genrsa -out root.key
# 创建根证书请求文件
openssl req -new -key root.key -out root.csr
# 创建根证书
openssl x -req -in root.csr -out root.crt -signkey root.key -CAcreateserial -days 3650

生成服务端证书

 
 # 生成服务器端证书私钥
openssl genrsa -out server.key
# 生成服务器证书请求文件
openssl req -new -key server.key -out server.csr
# 生成服务器端公钥证书
openssl x -req -in server.csr -out server.crt -signkey server.key -CA root.crt -CAkey root.key -CAcreateserial -days 3650

生成客户端证书

 
 # 生成客户端证书私钥
openssl genrsa -out client.key
# 生成客户端证书请求文件
openssl req -new -key client.key -out client.csr
# 生成客户端证书
openssl x -req -in client.csr -out client.crt -signkey client.key -CA root.crt -CAkey root.key -CAcreateserial -days 3650
# 生客户端p格式证书，需要输入一个密码，选一个好记的，比如123456
openssl pkcs -export -clcerts -in client.crt -inkey client.key -out client.p12

一定要注意的是，根证书的域名信息Common Name这个字段和客户端证书、服务器端证书不能一样 。

然后在Nginx中ssl_client_certificate字段配置根证书的路径，这样就可以验证所有它颁发的客户端证书。不需要再为每个客户端渠道创建一个server配置块去认证。

 
 # 根证书统一认证
server {
    listen ssl;
    server_name  localhost;
 
    ssl_certificate      ../ssl/server.crt;  # server公钥证书
    ssl_certificate_key  ../ssl/server.key;  # server私钥
    ssl_client_certificate ../ssl/root.crt;  # 根证书，可以验证所有它颁发的客户端证书
    ssl_verify_client on;  # 开启客户端证书验证
 
    ssl_session_cache    shared:SSL:m;
    ssl_session_timeoutm;
 
    ssl_ciphers  HIGH:!aNULL:!MD;
    ssl_prefer_server_ciphers  on;
 
    access_log logs/access.log;
    error_log logs/error.log;
 
    location / {
        proxy_pass    
    }
}

参考文章

如何使用Java访问双向认证的Https资源
HTTPS双向认证指南
KeyTool 和 OpenSSL 相互转换

个人网站

Github Pages
Gitee Pages

附录

keytool相关命令

keytool生成证书

 
 # 生成服务端jks
keytool -genkey -alias servertest -keysize -validity 3650 -keyalg RSA -dname "CN=client.test.com, OU=R & D department, O="BJ SOS Software Tech Co., Ltd", L=Beijing, S=Beijing, C=CN" -keypass 123456 -storepass 123456 -keystore server.jks
# -storepass 指定密钥库的密码(获取keystore信息所需的密码) 
# -keypass 指定别名条目的密码(私钥的密码) 
# keystore信息的查看
keytool -list -v -keystore server.jks -storepass
 
# 从jks中导出公钥证书
keytool -export -alias servertest -keystore server.jks -storepass -file server.crt
# 查看导出的证书信息
keytool -printcert -file server.crt
 
# 生成客户端jks
keytool -genkey -alias clienttest -keysize -validity 3650 -keyalg RSA -dname "CN=client.test.com, OU=R & D department, O="BJ SOS Software Tech Co., Ltd", L=Beijing, S=Beijing, C=CN" -keypass 123456 -storepass 123456 -keystore client.jks
# 将服务端公钥证书导入的客户端jks信任库中
keytool -import -trustcacerts -alias servertest -file server.crt -storepass -keystore client.jks
# keystore信息的查看
keytool -list -v -keystore client.jks -storepass

openssl 2 keytool

 
 # 生成私钥
openssl genrsa -out client.key
# 生成公钥证书
openssl req -new -x -key client.key -out client.crt -days 3650
# 合成p文件
openssl pkcs -export -clcerts -in client.crt -inkey client.key -out client.p12 -passout pass:123456 -name clienttest
# p文件转jks
keytool -importkeystore -srcstoretype PKCS -srckeystore client.p12 -srcstorepass 123456 -srcalias clienttest -deststoretype JKS -destalias clienttest -deststorepass 123456 -destkeypass 123456 -destkeystore client.jks

keytool 2 openssl

 
 # 生成jks
keytool -genkey -alias clienttest -keysize -validity 3650 -keyalg RSA -dname "CN=client.test.com, OU=R & D department, O="BJ SOS Software Tech Co., Ltd", L=Beijing, S=Beijing, C=CN" -keypass 123456 -storepass 123456 -keystore client.jks
# 从jks中导出公钥证书
keytool -export -alias clienttest -keystore client.jks -storepass -file client.crt
# jks转p文件
keytool -importkeystore -srcstoretype JKS -srckeystore client.jks -srcstorepass -srcalias clienttest -srckeypass 123456 -deststoretype PKCS12 -destkeystore client.p12 -deststorepass 123456 -destalias clienttest -destkeypass 123456 -noprompt
# p文件转pem格式
openssl pkcs -in client.p12 -out client.pem.p12 -passin pass:123456 -passout pass:123456
# 从pem格式文件单独输出私钥
openssl rsa -in client.pem.p -passin pass:123456 -out client.key -passout pass:123456

	./configure --prefix=/usr/local/nginx --with-http_ssl_module
	make && make install

	# 生成客户端证书私钥
	openssl genrsa -out client.key
	# 生成客户端公钥证书
	openssl req -new -x -key client.key -out client.crt -days 3650
	# 生客户端p格式证书，需要输入一个密码，选一个好记的，比如123456
	openssl pkcs -export -clcerts -in client.crt -inkey client.key -out client.p12

	# 负载均衡配置
	upstream backend {
	server.168.0.1:10900;
	server.168.0.2:10900;
	server.168.0.3:10900;
	}

	server {
	listen ssl;
	server_name localhost;

	ssl_certificate ../ssl/server.crt; # server公钥证书
	ssl_certificate_key ../ssl/server.key; # server私钥

	ssl_session_cache shared:SSL:m;
	ssl_session_timeoutm;

	ssl_ciphers HIGH:!aNULL:!MD;
	ssl_prefer_server_ciphers on;

	access_log logs/access.log; # 单独指定输出访问日志
	error_log logs/error.log; # # 单独指定输出错误日志

	location / {
	proxy_pass
	}
	}

	<dependency>
	<groupId>cn.hutool</groupId>
	<artifactId>hutool-all</artifactId>
	<version>.2.4</version>
	</dependency>
	HttpResponse httpResponse = HttpRequest.post("#;")
	. ContentType ("text/plain")
	.body("requestBody")
	.execute();
	System.out.println(httpResponse.getStatus());
	System.out.println(httpResponse.body());

	<dependency>
	<groupId>org. apache .httpcomponents</groupId>
	<artifactId>httpclient</artifactId>
	<version>.5.8</version>
	</dependency>

	# 切换到jdk的security目录
	cd $JAVA_HOME/jre/lib/security
	# 将服务端证书导入cacerts文件中，指定别名myserver，-file参数指定的就是服务端公钥证书的路径
	keytool -import -alias myserver -keystore cacerts -storepass changeit -file C:/Users/my/Desktop/cert/server_ssl/server.crt

	# 查看所有证书
	keytool -list -keystore cacerts -storepass changeit
	# 删除指定别名的证书
	keytool -delete -alias myserver -keystore cacerts -storepass changeit

	import org.apache.http.HttpEntity;
	import org.apache.http.client.config.RequestConfig;
	import org.apache.http.client.methods. close ableHttpResponse;
	import org.apache.http.client.methods.HttpPost;
	import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
	import org.apache.http.entity.ContentType;
	import org.apache.http.entity.StringEntity;
	import org.apache.http.impl.client.CloseableHttpClient;
	import org.apache.http.impl.client.HttpClients;
	import org.apache.http.ssl.SSLContexts;
	import org.apache.http.util.EntityUtils;
	import org.junit.Test;

	import javax.net.ssl.SSLContext;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.InputStream;
	import java.security.KeyStore;

	public class SSLTestCase {
	/**
	* 客户端p证书路径
	*/
	private String pfxPath = "C:/Users/my/Desktop/cert/client.p";
	/**
	* 客户端p证书密码
	*/
	private String pfxPasswd = "";

	private String url = "#;;

	@Test
	public void SSLTestCase() throws Exception {
	/**
	*.加载P12证书
	*/
	KeyStore keyStore = KeyStore. getInstance ("PKCS12");
	InputStream instream = new FileInputStream(new File(pfxPath));
	try {
	keyStore.load(instream, pfxPasswd.toCharArray());
	} finally {
	instream.close();
	}
	SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(keyStore, pfxPasswd.toCharArray()).build();
	SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext,
	new String[]{"TLSv"}, // supportedProtocols ,这里可以根据实际情况设置
	null,
	SSLConnectionSocketFactory.getDefaultHostnameVerifier());
	/**
	*.使用httpclient4.5.8发送post请求
	*/
	CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
	// 设置超时时间
	RequestConfig requestConfig = RequestConfig.custom()
	.setConnectTimeout()
	.setSocketTimeout().build();
	CloseableHttpResponse response = null;
	try {
	HttpPost httpPost = new HttpPost(url);
	httpPost.setConfig(requestConfig);
	// httpPost.addHeader("Connection", "keep-alive"); // 设置一些header等
	String requestBody = "requestBody";
	// StringEntity stringEntity = new StringEntity(requestBody, "UTF-");
	StringEntity stringEntity = new StringEntity(requestBody, ContentType.create("text/plain", "UTF-"));
	httpPost.setEntity(stringEntity);
	response = httpclient.execute(httpPost);
	HttpEntity entity = response.getEntity();
	String respBody = EntityUtils.toString(response.getEntity(), "UTF-");
	EntityUtils.consume(entity);
	System.out.println(respBody);
	} finally {
	if (httpclient != null) {
	httpclient.close();
	}
	if (response != null) {
	response.close();
	}
	}
	}
	}

	# -keystore参数指定生成后的truststore文件，-file参数指定服务公钥证书路径
	keytool -keystore C:/Users/my/Desktop/cert/server_ssl/server.truststore -keypass -storepass 654321 -alias myservertruststore -import -trustcacerts -file C:/Users/my/Desktop/cert/server_ssl/server.crt

	import org.apache.http.HttpEntity;
	import org.apache.http.client.config.RequestConfig;
	import org.apache.http.client.methods.CloseableHttpResponse;
	import org.apache.http.client.methods.HttpPost;
	import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
	import org.apache.http.entity.ContentType;
	import org.apache.http.entity.StringEntity;
	import org.apache.http.impl.client.CloseableHttpClient;
	import org.apache.http.impl.client.HttpClients;
	import org.apache.http.util.EntityUtils;
	import org.junit.Test;

	import javax.net.ssl.KeyManagerFactory;
	import javax.net.ssl.SSLContext;
	import javax.net.ssl.TrustManagerFactory;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.InputStream;
	import java.security.KeyStore;
	import java.security.SecureRandom;

	public class SSLTestCase {
	/**
	* 客户端p证书路径
	*/
	private String pfxPath = "C:/Users/my/Desktop/cert/client.p";
	/**
	* 客户端p证书密码
	*/
	private String pfxPasswd = "";
	/**
	* 信任库路径
	*/
	private String trustStroreFile = "C:/Users/my/Desktop/cert/server_ssl/server.truststore";
	/**
	* 信任库密码
	*/
	private String trustStorePwd = "";

	private String url = "#;;

	@Test
	public void SSLTestCase() throws Exception {
	/**
	*.初始化密钥库
	*/
	KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("SunX");
	KeyStore keyStore = getKeyStore(pfxPath, pfxPasswd, "PKCS");
	keyManagerFactory.init(keyStore, pfxPasswd.toCharArray());

	/**
	*.初始化信任库
	*/
	TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance("SunX");
	KeyStore trustkeyStore = getKeyStore(trustStroreFile, trustStorePwd, "JKS");
	trustManagerFactory.init(trustkeyStore);

	SSLContext sslContext = SSLContext.getInstance("SSL");
	sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), new SecureRandom());
	SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext,
	new String[]{"TLSv"}, // supportedProtocols ,这里可以根据实际情况设置
	null,
	SSLConnectionSocketFactory.getDefaultHostnameVerifier());

	/**
	*.使用httpclient4.5.8发送post请求
	*/
	CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
	// 设置超时时间
	RequestConfig requestConfig = RequestConfig.custom()
	.setConnectTimeout()
	.setSocketTimeout().build();
	CloseableHttpResponse response = null;
	try {
	HttpPost httpPost = new HttpPost(url);
	httpPost.setConfig(requestConfig);
	// httpPost.addHeader("Connection", "keep-alive"); // 设置一些header等
	String requestBody = "requestBody";
	// StringEntity stringEntity = new StringEntity(requestBody, "UTF-");
	StringEntity stringEntity = new StringEntity(requestBody, ContentType.create("text/plain", "UTF-"));
	httpPost.setEntity(stringEntity);
	response = httpclient.execute(httpPost);
	HttpEntity entity = response.getEntity();
	String respBody = EntityUtils.toString(response.getEntity(), "UTF-");
	EntityUtils.consume(entity);
	System.out.println(respBody);
	} finally {
	if (httpclient != null) {
	httpclient.close();
	}
	if (response != null) {
	response.close();
	}
	}
	}

	private KeyStore getKeyStore(String pfxPath, String pfxPasswd, String type) throws Exception {
	KeyStore keyStore = KeyStore.getInstance(type);
	InputStream instream = new FileInputStream(new File(pfxPath));
	try {
	keyStore.load(instream, pfxPasswd.toCharArray());
	} finally {
	instream.close();
	}
	return keyStore;
	}
	}

	server {
	listen ssl default_server;

	ssl_certificate ../ssl/server.crt; # server公钥证书
	ssl_certificate_key ../ssl/server.key; # server私钥

	access_log logs/default_access.log;
	error_log logs/default_error.log;

	location / {
	return;
	}
	}

	# 创建根证书私钥
	openssl genrsa -out root.key
	# 创建根证书请求文件
	openssl req -new -key root.key -out root.csr
	# 创建根证书
	openssl x -req -in root.csr -out root.crt -signkey root.key -CAcreateserial -days 3650

	# 生成服务器端证书私钥
	openssl genrsa -out server.key
	# 生成服务器证书请求文件
	openssl req -new -key server.key -out server.csr
	# 生成服务器端公钥证书
	openssl x -req -in server.csr -out server.crt -signkey server.key -CA root.crt -CAkey root.key -CAcreateserial -days 3650

	# 生成客户端证书私钥
	openssl genrsa -out client.key
	# 生成客户端证书请求文件
	openssl req -new -key client.key -out client.csr
	# 生成客户端证书
	openssl x -req -in client.csr -out client.crt -signkey client.key -CA root.crt -CAkey root.key -CAcreateserial -days 3650
	# 生客户端p格式证书，需要输入一个密码，选一个好记的，比如123456
	openssl pkcs -export -clcerts -in client.crt -inkey client.key -out client.p12

	# 根证书统一认证
	server {
	listen ssl;
	server_name localhost;

	ssl_certificate ../ssl/server.crt; # server公钥证书
	ssl_certificate_key ../ssl/server.key; # server私钥
	ssl_client_certificate ../ssl/root.crt; # 根证书，可以验证所有它颁发的客户端证书
	ssl_verify_client on; # 开启客户端证书验证

	ssl_session_cache shared:SSL:m;
	ssl_session_timeoutm;

	ssl_ciphers HIGH:!aNULL:!MD;
	ssl_prefer_server_ciphers on;

	access_log logs/access.log;
	error_log logs/error.log;

	location / {
	proxy_pass
	}
	}

	# 生成服务端jks
	keytool -genkey -alias servertest -keysize -validity 3650 -keyalg RSA -dname "CN=client.test.com, OU=R & D department, O="BJ SOS Software Tech Co., Ltd", L=Beijing, S=Beijing, C=CN" -keypass 123456 -storepass 123456 -keystore server.jks
	# -storepass 指定密钥库的密码(获取keystore信息所需的密码)
	# -keypass 指定别名条目的密码(私钥的密码)
	# keystore信息的查看
	keytool -list -v -keystore server.jks -storepass

	# 从jks中导出公钥证书
	keytool -export -alias servertest -keystore server.jks -storepass -file server.crt
	# 查看导出的证书信息
	keytool -printcert -file server.crt

	# 生成客户端jks
	keytool -genkey -alias clienttest -keysize -validity 3650 -keyalg RSA -dname "CN=client.test.com, OU=R & D department, O="BJ SOS Software Tech Co., Ltd", L=Beijing, S=Beijing, C=CN" -keypass 123456 -storepass 123456 -keystore client.jks
	# 将服务端公钥证书导入的客户端jks信任库中
	keytool -import -trustcacerts -alias servertest -file server.crt -storepass -keystore client.jks
	# keystore信息的查看
	keytool -list -v -keystore client.jks -storepass

	# 生成私钥
	openssl genrsa -out client.key
	# 生成公钥证书
	openssl req -new -x -key client.key -out client.crt -days 3650
	# 合成p文件
	openssl pkcs -export -clcerts -in client.crt -inkey client.key -out client.p12 -passout pass:123456 -name clienttest
	# p文件转jks
	keytool -importkeystore -srcstoretype PKCS -srckeystore client.p12 -srcstorepass 123456 -srcalias clienttest -deststoretype JKS -destalias clienttest -deststorepass 123456 -destkeypass 123456 -destkeystore client.jks

	# 生成jks
	keytool -genkey -alias clienttest -keysize -validity 3650 -keyalg RSA -dname "CN=client.test.com, OU=R & D department, O="BJ SOS Software Tech Co., Ltd", L=Beijing, S=Beijing, C=CN" -keypass 123456 -storepass 123456 -keystore client.jks
	# 从jks中导出公钥证书
	keytool -export -alias clienttest -keystore client.jks -storepass -file client.crt
	# jks转p文件
	keytool -importkeystore -srcstoretype JKS -srckeystore client.jks -srcstorepass -srcalias clienttest -srckeypass 123456 -deststoretype PKCS12 -destkeystore client.p12 -deststorepass 123456 -destalias clienttest -destkeypass 123456 -noprompt
	# p文件转pem格式
	openssl pkcs -in client.p12 -out client.pem.p12 -passin pass:123456 -passout pass:123456
	# 从pem格式文件单独输出私钥
	openssl rsa -in client.pem.p -passin pass:123456 -out client.key -passout pass:123456

Nginx配置Https单向认证、双向认证以及多证书配置