https双向认证

已于 2023-02-14 11:29:24 修改
阅读量1.6w 收藏 67
点赞数 12
分类专栏： java 文章标签： https ssl
于 2022-08-07 23:11:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014644574/article/details/126190061
版权

一、概念

根证书：是生成服务器证书和客户端证书的基础，是信任的源头，也可以叫自签发证书，即CA证书。

服务器证书：由根证书签发，并发送给客户，让客户安装在浏览器里的证书。主要包含服务端的公钥、域名和公司信息，浏览器客户端会验证自己请求的地址是否和证书里面的地址是否相同。

客户端证书：由根证书签发，需要导入到服务器的信任库中。主要包含客户端公钥、域名和公司信息。

二、目标

1、单向验证：如果是你客户端，你需要拿到服务器的证书，并放到你的信任库中；如果是服务端，你要生成私钥和证书，并将这两个放到你的密钥库中，并且将证书发给所有客户端。

2、双向验证：如果你是客户端，你要生成客户端的私钥和证书，将它们放到密钥库中，并将证书发给服务端，同时，在信任库中导入服务端的证书。如果你是服务端，除了在密钥库中保存服务器的私钥和证书，还要在信任库中导入客户端的证书。

3、使用单向验证还是双向验证，是服务器决定的。

单向认证是只在客户端侧做证书校验，双向认证客户端和服务端都要做对方的证书校验。

三、生成密钥、证书

openssl 参数：

-x509：创建自签名证书。
-days：指定自签名证书的有效期限，默认30天，需要和"-x509"一起使用。

-name可用于指定server证书别名；
-caname用于指定ca证书别名

-chain指示同时添加证书链

1、服务器端密钥

# 生成服务器端私钥
openssl genrsa -out server.key 2048
# 生成服务器端公钥
openssl rsa -in server.key -pubout -out server.pem

2、客户端密钥

# 生成客户端私钥
openssl genrsa -out client.key 2048
# 生成客户端公钥
openssl rsa -in client.key -pubout -out client.pem

下面这一步转换编码可以省略，这一步是后面用在java代码中作为客户端使用。若不需要不用转换编码。
私钥在使用前为pkcs1格式，而java在不引用第三方包的情况下无法直接使用pkcs1格式的秘钥，需要将其转化为pkcs8编码。

#将私钥进行pkcs8编码
openssl pkcs8 -topk8 -inform PEM -in client.key -outform PEM -out client_private.pem -nocrypt

3、CA机构密钥（这一步是CA机构操作，我们自己代劳而已）

# 生成 CA 私钥
openssl genrsa -out ca.key 2048
# X.509证书签署请求管理。
openssl req -new -key ca.key -out ca.csr
# X.509证书数据管理。
openssl x509 -req -in ca.csr -signkey ca.key -out ca.crt -days 3650

这里是填写，颁发者的信息，即CA机构的信息（这里我们代劳了其实也是填写自己公司的信息）：

Country Name (2 letter code) [XX]:CN
State or Province Name (full name) []:省份拼音，比如 SiChuan
Locality Name (eg, city) [Default City]:地市拼音，比如 ChengDu
Organization Name (eg, company) [Default Company Ltd]:公司名称拼音，比如 Google
Organizational Unit Name (eg, section) []:你所在公司的部门拼音，比如 YanFa
Common Name (eg, your name or your server's hostname) []:域名或者ip，比如 192.168.111.201
Email Address []:邮箱地址，比如 xiao@qq.com
A challenge password []:密码，比如 123456
An optional company name []:不填，直接回车

4、颁发证书（这一步是CA机构操作，我们自己代劳而已）

颁发证书，即签名服务器证书，生成crt文件

颁发服务端证书

# 服务器端需要向 CA 机构申请签名证书
openssl req -new -key server.key -out server.csr
# 向 CA 机构申请证书，签名过程需要 CA 的证书和私钥参与，最终颁发一个带有 CA 签名的证书
openssl x509 -req -CA ca.crt -CAkey ca.key -CAcreateserial -in server.csr -out server.crt -days 3650

颁发客户端证书

# client 端
openssl req -new -key client.key -out client.csr
# client 端到 CA 签名
openssl x509 -req -CA ca.crt -CAkey ca.key -CAcreateserial -in client.csr -out client.crt -days 3650

这里是填写，使用者的信息，即自己公司的信息：

Country Name (2 letter code) [XX]:CN
State or Province Name (full name) []:省份拼音，比如 SiChuan
Locality Name (eg, city) [Default City]:地市拼音，比如 ChengDu
Organization Name (eg, company) [Default Company Ltd]:公司名称拼音，比如 Google
Organizational Unit Name (eg, section) []:你所在公司的部门拼音，比如 YanFa
Common Name (eg, your name or your server's hostname) []:域名或者ip，比如 192.168.111.201
Email Address []:邮箱地址，比如 xiao@qq.com
A challenge password []:密码，比如 123456
An optional company name []:不填，直接回车

5、生成pkcs12格式证书（这一步也不是必须，只是用在某些场合方便而已）

生成pkcs12格式证书（该格式证书包含CA证书，私钥和自己的证书）
在tomcat中实现双向认证有时需要pkcs12格式的证书（该证书包含根证书、服务器端或客户端的证书和密钥文件）

生成pkcs12服务器证书 server.p12，需要输入2次密码，设置密码为123456

openssl pkcs12 -export -in server.crt -inkey server.key -out server.p12 -name server -CAfile ca.crt -caname ca

生成pkcs12客户端证书 client.p12，需要输入2次密码，设置密码为123456

openssl pkcs12 -export -in client.crt -inkey client.key -out client.p12 -name client -CAfile ca.crt -caname ca

注意：若要设置密码为空，不用输入密码，直接回车。

服务器端，将客户端证书导入为受信任的证书

keytool -import -trustcacerts -file client.crt -alias client -storepass 123456 -keystore client.jks

四、tomcat实现单向、双向认证。在实际开发中绝大多数使用的单向认证（默认服务端信任所有客户端）。

@RestController
public class SslContoller {

    //http请求：http://192.168.111.201:8081/ssl/hello?name=123
    //https请求：https://192.168.111.201:8443/ssl/hello?name=123
    @GetMapping("/hello")
    public String hello(String name) {
        return name;
    }
}

单向验证配置 vi  /tomcat/conf/server.xml

<Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
            maxThreads="150" SSLEnabled="true" sslProtocol="TLS" clientAuth="false"
            keystoreFile="/root/ssl/server.p12" keystorePass="123456">
</Connector>

clientAuth：是否验证客户端，false为单向认证，true为双向认证。

 

 这里要注意：上面一个是 http ，下面一个是 https 别输入错误。

将fiddler的根证书导入到受信任的根证书服务器，使用fiddler抓包，也能正常抓到。

双向验证配置 vi  /tomcat/conf/server.xml

    <Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
            maxThreads="150" SSLEnabled="true" sslProtocol="TLS" clientAuth="true"
            keystoreFile="/root/ssl/server.p12" keystorePass="123456"
            truststoreFile="/root/ssl/client.jks" truststorePass="123456">
    </Connector>

clientAuth：是否验证客户端，false为单向认证，true为双向认证。

当未安装服务端证书时：报以下错误。

 客户端导入 client.p12 证书，windows系统双击安装即可。

再次访问提示选择证书：

选择证书，点击确定后，再次请求后成功：

 

 使用fiddler抓包，已经不正常抓到

 ，这时需要在fiddler中加入客户端的证书（若本地已经安装可以直接导出一个client.cer的证书，这里我用的是我们自己生成的client.crt）。

 再次用fiddler已经可以抓到

不管单向还是双向，都不存在中间人攻击问题，我这里能用fiddler抓包的前提是浏览器使用的了fiddler的根证书。在代码中加入下面的代理，使用代码的方式调用接口（代码在结尾）

        System.setProperty("http.proxyHost", "127.0.0.1");
        System.setProperty("https.proxyHost", "127.0.0.1");
        System.setProperty("http.proxyPort", "8888");
        System.setProperty("https.proxyPort", "8888");

 

发现fiddler根本抓不到包，所以不论单向还是双向不存在中间人攻击。

四、Springboot配置ssl实现单向、双向认证。在实际开发中绝大多数使用的单向认证（默认服务端信任所有客户端）。

将生成好的 server.p12 和 client.jks 复制到 springboot 中的  resources/ssl/ 文件目录下，并配置

单向验证配置 application.properties

#端口号
server.port=8443
#是否启用SSL证书
server.ssl.enabled=true
#服务端私钥
server.ssl.key-store=classpath:ssl/server.p12
server.ssl.key-store-password=123456
#是否验证客户端（双向验证）
server.ssl.client-auth=none

双向验证配置 application.properties

#端口号
server.port=8443
#是否启用SSL证书
server.ssl.enabled=true
#服务端私钥
server.ssl.key-store=classpath:ssl/server.p12
server.ssl.key-store-password=123456
#是否验证客户端（双向验证）
server.ssl.client-auth=need
#信任证书，客户端公钥
server.ssl.trust-store=classpath:ssl/client.jks
server.ssl.trust-store-password=123456

在浏览器 https://192.168.111.201:8443/hello?name=123 测试方式同上面tomcat的方式。

五、查看windows系统的证书是否成功安装

cmd 运行 certmgr.msc

 六、java代码客户端

单向验证

在单向验证中，假如你只管调用成功就行，不去验证服务器端证书，可以使用以下方式，但是不安全，还是建议验证服务器端的证书。

package com.ssl;

import javax.net.ssl.*;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

public class Http5 {

    public static void main(String[] args) throws Exception {
        //发送请求
        String url = "https://192.168.111.201:8443/ssl/hello?name=123";
        String sendGet = sendGet(url);
        //打印结果返回数据
        System.out.println(sendGet);
    }

    /**
     * Get请求
     */
    public static String sendGet(String url) {
        HttpsURLConnection con = null;
        ByteArrayOutputStream baos = null;
        InputStream is = null;
        try {
            // 打开连接
            con = (HttpsURLConnection) new URL(url).openConnection();
            // 绕过证书验证
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, new TrustManager[]{new MyTrustAnyTrustManager()}, new java.security.SecureRandom());
            con.setSSLSocketFactory(sc.getSocketFactory());
            // 绕过验证主机名和服务器验证方案的匹配是可接受的
            con.setHostnameVerifier(new CustomizedHostnameVerifier());
            //
            con.setRequestMethod("GET");
            con.setConnectTimeout(10000);//是建立连接的超时时间
            con.setReadTimeout(10000);//是inputStream.read()超时时间
            //请求头
            // con.setRequestProperty("Accept-Encoding", "gzip, deflate");//千万不要使用这个请求头，因为我们不会去解压。
            // con.setRequestProperty("Accept", "application/octet-stream");//二进制流数据
            // con.setRequestProperty("Accept", "application/json");
            // con.setRequestProperty("Connection", "keep-alive");//抓包发现，不加也是这个
            // 开启连接
            con.connect();
            if (con.getResponseCode() == 200) {
                is = con.getInputStream();
                baos = new ByteArrayOutputStream();
                byte[] buf = new byte[1024];
                int len;
                while ((len = is.read(buf)) != -1) {
                    baos.write(buf, 0, len);
                    baos.flush();
                }
                return baos.toString("UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null) {
                    baos.close();
                }
                if (is != null) {
                    is.close();
                }
                if (con != null) {
                    con.disconnect();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * Post请求
     */
    public static String sendPost(String url, String params, String accesstoken) {
        HttpsURLConnection con = null;
        ByteArrayOutputStream baos = null;
        OutputStream os = null;
        InputStream is = null;
        try {
            // 打开连接
            con = (HttpsURLConnection) new URL(url).openConnection();
            // 绕过证书验证
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, new TrustManager[]{new MyTrustAnyTrustManager()}, new java.security.SecureRandom());
            con.setSSLSocketFactory(sc.getSocketFactory());
            // 绕过验证主机名和服务器验证方案的匹配是可接受的
            con.setHostnameVerifier(new CustomizedHostnameVerifier());
            //
            con.setRequestMethod("POST");
            con.setDoOutput(true);
            con.setDoInput(true);
            con.setUseCaches(false);
            con.setConnectTimeout(10000);//是建立连接的超时时间
            con.setReadTimeout(10000);//是inputStream.read()超时时间
            //请求头
            // con.setRequestProperty("Accept-Encoding", "gzip, deflate");//千万不要使用这个请求头，因为我们不会去解压。
            // con.setRequestProperty("Accept", "application/octet-stream");//二进制流数据
            // con.setRequestProperty("Accept", "application/json;charset=UTF-8");
            // con.setRequestProperty("Connection", "keep-alive");//抓包发现，不加也是这个
            // 开启连接
            con.connect();
            //请求参数
            if (params != null && params.length() > 0) {
                os = con.getOutputStream();
                os.write(params.getBytes(StandardCharsets.UTF_8));
                os.flush();
            }
            //响应
            // System.out.println(con.getResponseCode());
            if (con.getResponseCode() == 200) {
                is = con.getInputStream();
                baos = new ByteArrayOutputStream();
                byte[] buf = new byte[1024];
                int len;
                while ((len = is.read(buf)) != -1) {
                    baos.write(buf, 0, len);
                    baos.flush();
                }
                return baos.toString("UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null) {
                    baos.close();
                }
                if (os != null) {
                    os.close();
                }
                if (is != null) {
                    is.close();
                }
                if (con != null) {
                    con.disconnect();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 受信任的客户端处理
     * 自定义X509TrustManager中的checkClientTreusted和checkServerTrusted都是空实现，也就是不检查服务端的SSL证书信息。
     * @date 2022/8/10 9:36
     */
    static class MyTrustAnyTrustManager implements X509TrustManager {
        public void checkClientTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
        }

        public void checkServerTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
        }

        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[]{};
        }
    }

    /**
     * host验证
     * 自定义HostnameVerifier中的verify方法返回true，默认信任所有域名，否则在请求时会报错。
     * @date 2022/8/10 9:37
     */
    static class CustomizedHostnameVerifier implements HostnameVerifier {
        // 重写验证方法
        @Override
        public boolean verify(String urlHostName, SSLSession session) {
            // 所有都正确
            return true;
        }
    }

}

双向验证

以下https请求使用的都是自签名证书，不支持系统证书，防止被抓包。

方式一：

涉及到的证书上面都有直接使用即可

package com.ssl;

import javax.net.ssl.*;
import java.io.*;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.security.KeyStore;
import java.security.SecureRandom;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;

public class Test3 {
    private static String serverPath = "F:/server.crt";//服务端证书（服务端公钥）
    private static String clientPath = "F:/client.p12";//客户端证书（客户端私钥）
    private static String password = "123456";


    public static void main(String[] args) throws Exception {
        //发送请求
        String url = "https://192.168.111.201:8443/hello?name=123";
        String sendGet = sendGet(url);
        //打印结果返回数据
        System.out.println(sendGet);
    }

    /**
     * Get请求
     */
    public static String sendGet(String url) {
        HttpsURLConnection con = null;
        ByteArrayOutputStream baos = null;
        InputStream is = null;
        try {
            // 打开连接
            con = (HttpsURLConnection) new URL(url).openConnection();
            //ssl验证
            con.setSSLSocketFactory(getSocketFactory());
            // 绕过验证主机名和服务器验证方案的匹配是可接受的
            con.setHostnameVerifier(new CustomizedHostnameVerifier());
            //
            con.setRequestMethod("GET");
            con.setConnectTimeout(10000);//是建立连接的超时时间
            con.setReadTimeout(10000);//是inputStream.read()超时时间
            //请求头
            // con.setRequestProperty("Accept-Encoding", "gzip, deflate");//千万不要使用这个请求头，因为我们不会去解压。
            // con.setRequestProperty("Accept", "application/octet-stream");//二进制流数据
            // con.setRequestProperty("Accept", "application/json");
            // con.setRequestProperty("Connection", "keep-alive");//抓包发现，不加也是这个
            // 开启连接
            con.connect();
            if (con.getResponseCode() == 200) {
                is = con.getInputStream();
                baos = new ByteArrayOutputStream();
                byte[] buf = new byte[1024];
                int len;
                while ((len = is.read(buf)) != -1) {
                    baos.write(buf, 0, len);
                    baos.flush();
                }
                return baos.toString("UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null) {
                    baos.close();
                }
                if (is != null) {
                    is.close();
                }
                if (con != null) {
                    con.disconnect();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * Post请求
     */
    public static String sendPost(String url, String params, String accesstoken) {
        HttpsURLConnection con = null;
        ByteArrayOutputStream baos = null;
        OutputStream os = null;
        InputStream is = null;
        try {
            // 打开连接
            con = (HttpsURLConnection) new URL(url).openConnection();
            //ssl验证
            con.setSSLSocketFactory(getSocketFactory());
            // 绕过验证主机名和服务器验证方案的匹配是可接受的
            con.setHostnameVerifier(new CustomizedHostnameVerifier());
            //
            con.setRequestMethod("POST");
            con.setDoOutput(true);
            con.setDoInput(true);
            con.setUseCaches(false);
            con.setConnectTimeout(10000);//是建立连接的超时时间
            con.setReadTimeout(10000);//是inputStream.read()超时时间
            //请求头
            // con.setRequestProperty("Accept-Encoding", "gzip, deflate");//千万不要使用这个请求头，因为我们不会去解压。
            // con.setRequestProperty("Accept", "application/octet-stream");//二进制流数据
            // con.setRequestProperty("Accept", "application/json;charset=UTF-8");
            // con.setRequestProperty("Connection", "keep-alive");//抓包发现，不加也是这个
            // 开启连接
            con.connect();
            //请求参数
            if (params != null && params.length() > 0) {
                os = con.getOutputStream();
                os.write(params.getBytes(StandardCharsets.UTF_8));
                os.flush();
            }
            //响应
            // System.out.println(con.getResponseCode());
            if (con.getResponseCode() == 200) {
                is = con.getInputStream();
                baos = new ByteArrayOutputStream();
                byte[] buf = new byte[1024];
                int len;
                while ((len = is.read(buf)) != -1) {
                    baos.write(buf, 0, len);
                    baos.flush();
                }
                return baos.toString("UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null) {
                    baos.close();
                }
                if (os != null) {
                    os.close();
                }
                if (is != null) {
                    is.close();
                }
                if (con != null) {
                    con.disconnect();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public static SSLSocketFactory getSocketFactory() throws Exception {
        InputStream serverInputStream = null;
        InputStream clientInputStream = null;
        SSLSocketFactory socketFactory;
        try {
            serverInputStream = new FileInputStream(serverPath);
            clientInputStream = new FileInputStream(clientPath);

            //加载受信任证书（服务端公钥）
            TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
            Certificate ca = certificateFactory.generateCertificate(serverInputStream);
            keyStore.load(null, null);
            //设置公钥
            keyStore.setCertificateEntry("server", ca);
            trustManagerFactory.init(keyStore);
            TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();

            //加载密钥库（客户端私钥）
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyStore = KeyStore.getInstance("PKCS12");
            keyStore.load(clientInputStream, password.toCharArray());
            keyManagerFactory.init(keyStore, password.toCharArray());
            KeyManager[] keyManagers = keyManagerFactory.getKeyManagers();

            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(keyManagers, trustManagers, new SecureRandom());
            socketFactory = sslContext.getSocketFactory();
        } finally {
            if (serverInputStream != null) {
                serverInputStream.close();
            }
            if (clientInputStream != null) {
                clientInputStream.close();
            }
        }
        return socketFactory;
    }

    static class CustomizedHostnameVerifier implements HostnameVerifier {
        // 重写验证方法
        @Override
        public boolean verify(String urlHostName, SSLSession session) {
            //这里假如客户端不需要验证服务端直接返回true就可以
            if ("192.168.111.201".equals(urlHostName)) {
                return true;
            }
            return false;
            // 所有都正确
            // return true;
        }
    }

}

方式二：

在很多时候，我们只是客户端去调用别人的服务器，别人给的证书格式又不一样，这点我就很烦为什么ssl证书乱七八糟这么多格式，就是因为这样才有了这篇博文，自己搭建了一套来测试。

1、服务端证书
2、客户端证书
3、客户端私钥

package com.ssl;

import sun.misc.BASE64Decoder;

import javax.net.ssl.*;
import java.io.*;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.SecureRandom;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.spec.PKCS8EncodedKeySpec;

public class Test5 {
    private static String serverPath = "F:/server.crt";//服务端证书
    private static String clientPath = "F:/client.crt";//客户端证书
    private static String clientKeyPath = "F:/client_private.pem";//客户端私钥
    private static String password = "123456";


    public static void main(String[] args) throws Exception {
        //发送请求
        String url = "https://192.168.111.201:8443/hello?name=123";
        String sendGet = sendGet(url);
        //打印结果返回数据
        System.out.println(sendGet);
    }

    /**
     * Get请求
     */
    public static String sendGet(String url) {
        HttpsURLConnection con = null;
        ByteArrayOutputStream baos = null;
        InputStream is = null;
        try {
            // 打开连接
            con = (HttpsURLConnection) new URL(url).openConnection();
            //ssl验证
            con.setSSLSocketFactory(getSocketFactory());
            // 绕过验证主机名和服务器验证方案的匹配是可接受的
            con.setHostnameVerifier(new CustomizedHostnameVerifier());
            //
            con.setRequestMethod("GET");
            con.setConnectTimeout(10000);//是建立连接的超时时间
            con.setReadTimeout(10000);//是inputStream.read()超时时间
            //请求头
            // con.setRequestProperty("Accept-Encoding", "gzip, deflate");//千万不要使用这个请求头，因为我们不会去解压。
            // con.setRequestProperty("Accept", "application/octet-stream");//二进制流数据
            // con.setRequestProperty("Accept", "application/json");
            // con.setRequestProperty("Connection", "keep-alive");//抓包发现，不加也是这个
            // 开启连接
            con.connect();
            if (con.getResponseCode() == 200) {
                is = con.getInputStream();
                baos = new ByteArrayOutputStream();
                byte[] buf = new byte[1024];
                int len;
                while ((len = is.read(buf)) != -1) {
                    baos.write(buf, 0, len);
                    baos.flush();
                }
                return baos.toString("UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null) {
                    baos.close();
                }
                if (is != null) {
                    is.close();
                }
                if (con != null) {
                    con.disconnect();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * Post请求
     */
    public static String sendPost(String url, String params, String accesstoken) {
        HttpsURLConnection con = null;
        ByteArrayOutputStream baos = null;
        OutputStream os = null;
        InputStream is = null;
        try {
            // 打开连接
            con = (HttpsURLConnection) new URL(url).openConnection();
            //ssl验证
            con.setSSLSocketFactory(getSocketFactory());
            // 绕过验证主机名和服务器验证方案的匹配是可接受的
            con.setHostnameVerifier(new CustomizedHostnameVerifier());
            //
            con.setRequestMethod("POST");
            con.setDoOutput(true);
            con.setDoInput(true);
            con.setUseCaches(false);
            con.setConnectTimeout(10000);//是建立连接的超时时间
            con.setReadTimeout(10000);//是inputStream.read()超时时间
            //请求头
            // con.setRequestProperty("Accept-Encoding", "gzip, deflate");//千万不要使用这个请求头，因为我们不会去解压。
            // con.setRequestProperty("Accept", "application/octet-stream");//二进制流数据
            // con.setRequestProperty("Accept", "application/json;charset=UTF-8");
            // con.setRequestProperty("Connection", "keep-alive");//抓包发现，不加也是这个
            // 开启连接
            con.connect();
            //请求参数
            if (params != null && params.length() > 0) {
                os = con.getOutputStream();
                os.write(params.getBytes(StandardCharsets.UTF_8));
                os.flush();
            }
            //响应
            // System.out.println(con.getResponseCode());
            if (con.getResponseCode() == 200) {
                is = con.getInputStream();
                baos = new ByteArrayOutputStream();
                byte[] buf = new byte[1024];
                int len;
                while ((len = is.read(buf)) != -1) {
                    baos.write(buf, 0, len);
                    baos.flush();
                }
                return baos.toString("UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null) {
                    baos.close();
                }
                if (os != null) {
                    os.close();
                }
                if (is != null) {
                    is.close();
                }
                if (con != null) {
                    con.disconnect();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public static SSLSocketFactory getSocketFactory() throws Exception {
        InputStream serverInputStream = null;
        InputStream clientInputStream = null;
        SSLSocketFactory socketFactory;
        try {
            serverInputStream = new FileInputStream(serverPath);
            clientInputStream = new FileInputStream(clientPath);

            //1、加载受信任证书（服务端公钥）

            // CA证书用于对服务器进行认证，信任指定的服务端
            //证书工厂(CertificateFactory)。密钥库(KeyStore)。
            //CA(公钥证书)经PKIX工作组改造的X.509规范
            //JKS是Java Keystore，一种专为Java设计的专有密钥库类型。 可以用于存储用于SSL通信的私钥和证书，但是它不能存储密钥。
            CertificateFactory serverCA = CertificateFactory.getInstance("X.509");
            X509Certificate ca = (X509Certificate) serverCA.generateCertificate(serverInputStream);
            KeyStore caks = KeyStore.getInstance("JKS");
            caks.load(null, null);
            caks.setCertificateEntry("server", ca);
            TrustManagerFactory tmf = TrustManagerFactory.getInstance("PKIX");//  Trust信任的,设置信任的服务端
            tmf.init(caks);


            //2、加载密钥库（客户端私钥）

            // 客户端密钥和证书被发送到服务器，以便服务器对我们进行身份验证
            CertificateFactory clientCA = CertificateFactory.getInstance("X.509");
            X509Certificate cert = (X509Certificate) clientCA.generateCertificate(clientInputStream);
            KeyStore certks = KeyStore.getInstance("JKS");//默认就是JKS
            certks.load(null, null);
            certks.setCertificateEntry("client", cert);
            certks.setKeyEntry("privateKey", getPrivateKey(clientKeyPath), password.toCharArray(), new java.security.cert.Certificate[]{cert});
            KeyManagerFactory kmf = KeyManagerFactory.getInstance("PKIX");
            kmf.init(certks, password.toCharArray());

            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), new SecureRandom());
            socketFactory = sslContext.getSocketFactory();
        } finally {
            if (serverInputStream != null) {
                serverInputStream.close();
            }
            if (clientInputStream != null) {
                clientInputStream.close();
            }
        }
        return socketFactory;
    }


    /**
     * 获取文件中的密钥
     */
    public static PrivateKey getPrivateKey(String path) {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader(path));
            String line;
            StringBuilder sb = new StringBuilder();
            while ((line = br.readLine()) != null) {
                if (!line.startsWith("-")) {
                    sb.append(line);
                }
            }
            // // byte[] buffer = Base64.getDecoder().decode(getPem(path));
            BASE64Decoder base64decoder = new BASE64Decoder();
            byte[] buffer = base64decoder.decodeBuffer(sb.toString());
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
            return privateKey;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    static class CustomizedHostnameVerifier implements HostnameVerifier {
        // 重写验证方法
        @Override
        public boolean verify(String urlHostName, SSLSession session) {
            //这里假如客户端不需要验证服务端直接返回true就可以
            if ("192.168.111.201".equals(urlHostName)) {
                return true;
            }
            return false;
            // 所有都正确
            // return true;
        }
    }

}

假如你的证书还不和上面一样，那就想办法转换成上面给的2种方式的证书，建议使用 openssl 命令直接转换成第一种方式。其实第二种方式的证书就可以转换为第一种方式，第二种方式就很麻烦，但是可以让我们更好地了解java的 KeyStore 模式是怎么去实现的。这里给一个 KeyStore 的api地址http://jszx-jxpt.cuit.edu.cn/JavaAPI/java/security/KeyStore.html

有盾就有茅，手机https的抓包方式

Fiddler利用Edxposed框架+TrustMeAlready来突破SSL pinning抓取手机APP数据_小百菜的博客-CSDN博客

小百菜
关注
  • 12
    点赞
  • 踩
  • 67
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
扯一扯HTTPS单向认证、双向认证、抓包原理、反抓包策略
2401_84122965的博客
04-07 862
HTTPS在保证数据安全传输上使用对称加密和非对称加密相结合的方式来进行的，简单来说就是通过一次非对称加密算法进行了最终通信密钥的生成、确认和交换，然后在后续的通信过程中使用最终通信密钥进行对称加密通信。之所以不是全程非对称加密，是因为非对称加密的计算量大，影响通信效率。这次面试问的还是还是有难度的，要求当场写代码并且运行，也是很考察面试者写代码因为Android知识体系比较庞大和复杂的，涉及到计算机知识领域的方方面面。
ssl双向认证_SSL双向认证和SSL单向认证的区别
weixin_39598941的博客
12-09 517
什么是SSL双向认证?什么是SSL单向认证? 本文给大家介绍SSL双向认证和SSL单向认证的具体过程以及他们两者之间的区别。SSL单向认证只要求站点部署了ssl证书就行，任何用户都可以去访问(IP被限制除外等)，只是服务端提供了身份认证。SSL单向认证具体过程① 浏览器发送一个连接请求给安全服务器。② 服务器将自己的证书，以及同证书相关的信息发送给客户浏览器。③ 客户浏览器检查服务器送过来的证书是...
HTTPS单双向认证流程详解与联想
最新发布
2401_84466316的博客
05-29 1329
理解HTTPS协议的认证流程，可以增加对安全的理解，HTTPS认证的过程，核心思想与Kerberos协议的认证也是互通的，是具有相似性的。网络安全学习资源分享:给大家分享一份全套的网络安全学习资料，给那些想学习 网络安全的小伙伴们一点帮助！对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。因篇幅有限，仅展示部分资料，朋友们如果有需要全套《网络安全入门+进阶学习资源包》，需要点击下方链接即可前往获取。
HTTPS双向认证指南(亲测可行)
springdk2009的博客
03-17 1912
HTTPS双向认证方式通信在一些安全级别较高的场景非常有用，拥有合法证书的客户端才能正常访问业务。实现这个场景需要以下几步：生成根公钥证书和私钥文件（root.crt/root.key）；使用根证书和根证书私钥(root.crt/root.key)配合服务器端私钥颁发服务器端证书(server.crt)；使用根证书和根证书私钥(root.crt/root.key)配合客户端私钥颁发客户端证书(server.crt)；
Https单向认证和双向认证
青鸟飞鱼
05-24 900
客户端收到服务端返回的加密方案密文后，使用自己的私钥进行解密，获取具体加密方式，而后，产生该加密方式的随机码，用作加密过程中的密钥，使用之前从服务端证书中获取到的公钥进行加密后，发送给服务端。服务端收到客户端发送的消息后，使用自己的私钥进行解密，获取对称加密的密钥，在接下来的会话中，服务器和客户端将会使用该密码进行对称加密，保证通信过程中信息的安全。客户端接收到服务端返回的加密方式后，使用该加密方式生成产生随机码，用作通信过程中对称加密的密钥，使用服务端返回的公钥进行加密，将加密后的随机码发送至服务器。
【网络】https单向认证和双向认证
ALLEN'Blog
12-02 3183
1.单向认证还是有必要先说下单向认证，单向认证是我刚开始接触https的时候就了解到的。下面看一下执行流程图（图是网上找的）再用文字描述下:首先建立链接 -> 验证服务端身份 -> 用服务端公钥加密得到后期通信用的密钥 -> 服务端用私钥解密，拿到密钥 - -> 双方使用密钥通信在上面这个过程中，我们可以看到仅仅是验证了服务端的身份，如果有人冒充了客户端，那该怎么办，就是下面要说的双向认证。2.https双向认证首先看图较于单向认证来说，双向认证多了验证客户端身份的这一环节。下面用文字再描述一下:首先建
SSL双向认证与单向认证
m0_51514815的博客
05-29 5007
参考：https://www.cnblogs.com/bluestorm/p/10571989.html整理双向认证 SSL 协议要求服务器和用户双方都有证书。单向认证 SSL 协议不需要客户拥有CA证书。
https双向认证试验
星河的博客
11-30 607
双向校验流程见：https://www.cnblogs.com/baihuitestsoftware/articles/7097389.html 1.利用xca工具生成CA，client，server端证书 创建CA证书： 1）使用模板创建新证书CA ，点击 应用模板所有信息。 2）主体里填写国家等信息，commonName随便填一个ca名称。 3）创建一个ca的密钥。 把x509v3 的extended key usage的TLS web client..选上，其余的有些也不...
iOS实用教程之Https双向认证详解
08-30
iOS实用教程之Https双向认证详解 本篇文章主要介绍了iOS中Https双向认证的相关知识点，它对大家具有非常重要的参考学习价值。 什么是Https双向认证 Https双向认证是一种安全认证机制，它可以确保客户端与服务端...
https双向认证ukey管理软件
10-14
HTTPS双向认证UKey管理软件是用于确保网络安全和数据完整性的专业工具，特别是在金融、医疗、政府等对数据安全要求极高的行业中广泛应用。该软件的主要功能是管理UKey（USB Key），这是一种硬件设备，通常用于存储...
C语言https客户端双向认证
09-04
本文将深入探讨如何使用C语言实现一个支持双向认证的HTTPS客户端。 首先，双向认证（Mutual Authentication）是网络安全的一种机制，它要求客户端和服务端都必须提供有效的身份证明才能进行通信。在HTTPS的双向认证...
https双向认证 .doc
08-19
Java实现HTTPS双向认证详解 HTTPS双向认证是指客户端和服务端都需要拥有证书，并且双方都需要互换证书，客户端安装服务端证书，服务端安装客户端证书。这种情况下，并不是所有用户都可以访问服务端的。只有服务端...
Https双向认证+加密狗配置教程
01-06
Https双向认证+ET199加密狗配置usb硬件证书认证，如果有其他问题 下载过文档的同学肯定一帮到底！
https 单向认证和双向认证
茅坤宝骏氹的博客
06-10 2941
转载自   https 单向认证和双向认证 一、Http HyperText Transfer Protocol，超文本传输协议，是互联网上使用最广泛的一种协议，所有WWW文件必须遵循的标准。HTTP协议传输的数据都是未加密的，也就是明文的，因此使用HTTP协议传输隐私信息非常不安全。 使用TCP端口为：80 二、Https Hyper Text Transfer Protocol ov...
HTTPS证书管理与双向认证篇
云原生运维
09-10 605
单向认证，只有一方需要验证对方的身份。通常是客户端验证服务器的身份。这种情况下，客户端会检查服务器提供的数字证书是否有效，以确定服务器是否合法。服务器不会验证客户端的身份。这种情况下，客户端可以确认它正在与合法的服务器进行通信，但服务器不能确定其与合法客户端通信。单向认证通常用于一些对服务器身份验证要求较高，但对客户端身份验证要求相对较低的场景，如网站访问。客户端向服务端发送SSL协议版本号、加密算法种类、随机数等信息。
https 双向认证
08-10
HTTPS双向认证是一种通过SSL/TLS协议进行通信的安全机制。在这种机制中，服务器和客户端都需要使用证书进行身份验证。 具体的双向认证流程如下： 1. 将服务器证书和客户端证书导入到浏览器中。服务器证书应该导入到受信任的根证书颁发机构，而客户端证书应该导入到个人证书存储区域。123 #### 引用[.reference_title] - *1* *2* [【HTTPS双向加密认证】](https://blog.csdn.net/weixin_33724046/article/details/86336789)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}} ] [.reference_item] - *3* [https 双向认证开发实践](https://blog.csdn.net/dtlscsl/article/details/50118225)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值