RestTemplate HTTPS双向认证

已于 2024-05-15 17:04:14 修改
阅读量841 收藏 6
点赞数 6
文章标签： ssl spring boot java spring
于 2024-05-15 17:03:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/li_habit/article/details/138915070
版权
创建根证书

openssl genrsa -out root.key 2048
openssl req -utf8 -new -out root.csr -key root.key
openssl x509 -req -in root.csr -out root.crt -signkey root.key -CAcreateserial -days 36500
创建(java的信任库)
keytool -import -noprompt -trustcacerts -alias root -file root.crt -keystore trust-keys.p12 -storetype PKCS12 -storepass ‘12345678’

Country Name (2 letter code) [AU]:CN
State or Province Name (full name) [Some-State]:上海市
Locality Name (eg, city) []:徐汇区
Organization Name (eg, company) [Internet Widgits Pty Ltd]:信昊
Organizational Unit Name (eg, section) []:信昊
Common Name (e.g. server FQDN or YOUR name) []:root
Email Address []:
创建服务端证书

openssl genrsa -out server.key 2048
openssl req -utf8 -new -out server.csr -key server.key
openssl x509 -req -in server.csr -out server.crt -signkey server.key -CA root.crt -CAkey root.key -CAcreateserial -days 36500
服务端p12格式证书(server.key+server.crt+root.crt -> server.p12)
openssl pkcs12 -export -inkey server.key -passin pass:‘12345678’ -in server.crt -chain -CAfile root.crt -out server.p12 -password pass:‘12345678’
导出server的公钥
keytool -storetype PKCS12 -keystore server.p12 -export -alias 1 -file server-public-key.cer
加入信任库
keytool -storetype PKCS12 -import -alias server -v -file server-public-key.cer -keystore trust-keys.p12

Country Name (2 letter code) [AU]:CN
State or Province Name (full name) [Some-State]:上海市
Locality Name (eg, city) []:徐汇区
Organization Name (eg, company) [Internet Widgits Pty Ltd]:信昊
Organizational Unit Name (eg, section) []:信昊
Common Name (e.g. server FQDN or YOUR name) []:server
Email Address []:
创建客户端证书

openssl genrsa -out client.key 2048
openssl req -utf8 -new -out client.csr -key client.key
openssl x509 -req -in client.csr -out client.crt -signkey client.key -CA root.crt -CAkey root.key -CAcreateserial -days 36500
生客户端p12格式证书(client.key+client.crt+rootca.crt -> client.p12)
openssl pkcs12 -export -inkey client.key -passin pass:‘12345678’ -in client.crt -chain -CAfile root.crt -out client.p12 -password pass:‘12345678’
导出client的公钥
keytool -storetype PKCS12 -keystore server.p12 -export -alias 1 -file client-public-key.cer
加入信任库
keytool -storetype PKCS12 -import -alias client -v -file client-public-key.cer -keystore trust-keys.p12

Country Name (2 letter code) [AU]:CN
State or Province Name (full name) [Some-State]:上海市
Locality Name (eg, city) []:徐汇区
Organization Name (eg, company) [Internet Widgits Pty Ltd]:信昊
Organizational Unit Name (eg, section) []:信昊
Common Name (e.g. server FQDN or YOUR name) []:client
Email Address []:
server配置
ssl:
    enabled: true
    client-auth: need
    key-store: classpath:ssl/server.p12
    key-store-password: 12345678
    key-store-type: PKCS12
    trust-store: classpath:ssl/trust-keys.p12
    trust-store-password: 12345678
    trust-store-type: PKCS12
server RestTemplate代码
package com.xinhaosoft.config;

import lombok.extern.slf4j.Slf4j;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ResourceLoader;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

import javax.net.ssl.*;
import java.io.IOException;
import java.io.InputStream;
import java.security.*;
import java.security.cert.CertificateException;
import java.time.Duration;

/**
 * SSL RestTemplate配置
 *
 * @author CleanCode
 */
@Configuration
@Slf4j
public class RestTemplateConfig {
    @Value("${server.ssl.key-store-type}")
    private String clientKeyType;
    @Value("${server.ssl.key-store}")
    private String clientPath;
    @Value("${server.ssl.key-store-password}")
    private String clientPass;
    @Value("${server.ssl.trust-store-type}")
    private String trustKeyType;
    @Value("${server.ssl.trust-store}")
    private String trustPath;
    @Value("${server.ssl.trust-store-password}")
    private String trustPass;
    private final ResourceLoader resourceLoader;

    public RestTemplateConfig(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    @Bean("sslRestTemplate")
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = null;
        try {
            HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
            // 客户端证书类型
            KeyStore clientStore = KeyStore.getInstance(clientKeyType);
            // 加载客户端证书，即自己的私钥
            InputStream keyStream = resourceLoader.getResource(clientPath).getInputStream();
            clientStore.load(keyStream, clientPass.toCharArray());
            // 创建密钥管理工厂实例
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            // 初始化客户端密钥库
            keyManagerFactory.init(clientStore, clientPass.toCharArray());
            KeyManager[] keyManagers = keyManagerFactory.getKeyManagers();

            // 创建信任库管理工厂实例
            TrustManagerFactory trustManagerFactory = TrustManagerFactory
                    .getInstance(TrustManagerFactory.getDefaultAlgorithm());
            KeyStore trustStore = KeyStore.getInstance(trustKeyType);
            InputStream trustStream = resourceLoader.getResource(trustPath).getInputStream();
            trustStore.load(trustStream, trustPass.toCharArray());

            // 初始化信任库
            trustManagerFactory.init(trustStore);
            TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
            // 建立TLS连接
            SSLContext sslContext = SSLContext.getInstance("TLS");
            // 初始化SSLContext
            sslContext.init(keyManagers, trustManagers, new SecureRandom());
            // INSTANCE 忽略域名检查
            SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
            CloseableHttpClient httpclient = HttpClients
                    .custom()
                    .setSSLSocketFactory(sslConnectionSocketFactory)
                    .setSSLHostnameVerifier(new NoopHostnameVerifier())
                    .build();
            requestFactory.setHttpClient(httpclient);
            requestFactory.setConnectTimeout((int) Duration.ofSeconds(15).toMillis());
            restTemplate = new RestTemplate(requestFactory);
        } catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException | CertificateException |
                 UnrecoverableKeyException | IOException e) {
            e.printStackTrace();
        }
        return restTemplate;
    }
}
服务端测试代码
package com.xinhaosoft.controller;

import com.xinhaosoft.vo.DbScanTableVO;
import com.xinhaosoft.vo.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * 双向认证测试Controller
 *
 * @author CleanCode
 */
@RestController
@Slf4j
public class TestController {
    private final RestTemplate restTemplate;

    public TestController(@Qualifier(value = "sslRestTemplate") RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    /**
     * 远程调用测试
     */
    @GetMapping("/public/ssl/test")
    public String sslTest() {
        ResponseEntity<Result<DbScanTableVO>> exchange = restTemplate.exchange("https://192.168.100.15:8005/dam-client/scan/table",
                HttpMethod.GET,
                null,
                new ParameterizedTypeReference<Result<DbScanTableVO>>() {
                });
        log.info("forObject:{}", exchange.getBody());
        return "双向认证调用通过";
    }

    /**
     * 被远程调用的方法
     */
    @GetMapping("/public/scan/table")
    public Result<DbScanTableVO> getScanTable() {
        DbScanTableVO dbScanTableVO = new DbScanTableVO();
        dbScanTableVO.setId(1L).setName("test");
        return Result.buildOk("成功", dbScanTableVO);
    }
}
client配置
server:
    ssl:
        enabled: true
        client-auth: need
        key-store: classpath:ssl/client.p12
        key-store-password: 12345678
        key-store-type: PKCS12
        trust-store: classpath:ssl/trust-keys.p12
        trust-store-password: 12345678
        trust-store-type: PKCS12
client RestTemplate代码
package com.xinhaosoft.config;

import lombok.extern.slf4j.Slf4j;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ResourceLoader;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

import javax.net.ssl.*;
import java.io.IOException;
import java.io.InputStream;
import java.security.*;
import java.security.cert.CertificateException;
import java.time.Duration;

/**
 * SSL RestTemplate配置
 *
 * @author CleanCode
 */
@Configuration
@Slf4j
public class RestTemplateConfig {
    @Value("${ssl.key-store-type}")
    private String clientKeyType;
    @Value("${ssl.key-store}")
    private String clientPath;
    @Value("${ssl.key-store-password}")
    private String clientPass;
    @Value("${ssl.trust-store-type}")
    private String trustKeyType;
    @Value("${ssl.trust-store}")
    private String trustPath;
    @Value("${ssl.trust-store-password}")
    private String trustPass;
    private final ResourceLoader resourceLoader;

    public RestTemplateConfig(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    @Bean("sslRestTemplate")
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = null;
        try {
            HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
            // 客户端证书类型
            KeyStore clientStore = KeyStore.getInstance(clientKeyType);
            // 加载客户端证书，即自己的私钥
            InputStream keyStream = resourceLoader.getResource(clientPath).getInputStream();
            clientStore.load(keyStream, clientPass.toCharArray());
            // 创建密钥管理工厂实例
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            // 初始化客户端密钥库
            keyManagerFactory.init(clientStore, clientPass.toCharArray());
            KeyManager[] keyManagers = keyManagerFactory.getKeyManagers();

            // 创建信任库管理工厂实例
            TrustManagerFactory trustManagerFactory = TrustManagerFactory
                    .getInstance(TrustManagerFactory.getDefaultAlgorithm());
            KeyStore trustStore = KeyStore.getInstance(trustKeyType);
            InputStream trustStream = resourceLoader.getResource(trustPath).getInputStream();
            trustStore.load(trustStream, trustPass.toCharArray());

            // 初始化信任库
            trustManagerFactory.init(trustStore);
            TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
            // 建立TLS连接
            SSLContext sslContext = SSLContext.getInstance("TLS");
            // 初始化SSLContext
            sslContext.init(keyManagers, trustManagers, new SecureRandom());
            // INSTANCE 忽略域名检查
            SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
            CloseableHttpClient httpclient = HttpClients
                    .custom()
                    .setSSLSocketFactory(sslConnectionSocketFactory)
                    .setSSLHostnameVerifier(new NoopHostnameVerifier())
                    .build();
            requestFactory.setHttpClient(httpclient);
            requestFactory.setConnectTimeout((int) Duration.ofSeconds(15).toMillis());
            restTemplate = new RestTemplate(requestFactory);
        } catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException | CertificateException |
                 UnrecoverableKeyException | IOException e) {
            e.printStackTrace();
        }
        return restTemplate;
    }
}
客户端测试代码
package com.xinhaosoft.controller;

import com.xinhaosoft.vo.DbScanTableVO;
import com.xinhaosoft.vo.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * 双向认证测试Controller
 *
 * @author CleanCode
 */
@RestController
@Slf4j
public class TestController {
    private final RestTemplate restTemplate;

    public TestController(@Qualifier(value = "sslRestTemplate") RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    /**
     * 被远程调用的方法
     *
     * @return Result
     */
    @GetMapping("/scan/table")
    public Result<DbScanTableVO> getScanTable() {
        DbScanTableVO dbScanTableVO = new DbScanTableVO();
        dbScanTableVO.setId(1L).setName("test");
        return Result.buildOk("成功", dbScanTableVO);
    }

    /**
     * 远程调用测试
     *
     * @return Result
     */
    @GetMapping("/public/ssl/test")
    public String sslTest() {
        //通过nginx做了代理所以端口是443
        ResponseEntity<Result<DbScanTableVO>> exchange = restTemplate.exchange("https://192.168.100.15/dam/public/scan/table",
                HttpMethod.GET,
                null,
                new ParameterizedTypeReference<Result<DbScanTableVO>>() {
                });
        log.info("forObject:{}", exchange.getBody());
        return "双向认证调用通过";
    }
}
nginx配置
    # HTTPS server
    #
    server {
        listen       443 ssl;
        server_name  192.168.100.15;
        # 服务端证书和私钥（pem格式）
        ssl_certificate      D:/server/nginx-1.26.0/ssl/server.crt;
        ssl_certificate_key  D:/server/nginx-1.26.0/ssl/server.key;
        
        # 根证书（pem格式）
        ssl_client_certificate D:/server/nginx-1.26.0/ssl/root.crt;
        # 开启双向认证
        ssl_verify_client on;

        ssl_session_cache    shared:SSL:1m;
        ssl_session_timeout  5m;

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

        location / {
        	# 代理后端服务
            proxy_pass   http://192.168.100.15:8004;
            #root   html;
            #index  index.html index.htm;
        }
    }
cleanCode
关注
grpc、https、oauth2等认证专栏实战9：https双向认证介绍
码二哥的技术池
08-29 906
2.3.1、第一步：生成服务器端密钥和服务器端证书签名 (非SAN类型，客户端不需要被访问，不需要添加额外的域名)2.2.1、第一步：生成服务器端密钥和服务器端证书签名 (SAN类型，即多个域名生效)0  grpc-go、protobuf、multus-cni 技术专栏 总入口。4  grpc、oauth2、openssl、双向认证、单向认证等专栏文章目录。2.2.2、第二步：根据CA证书，来颁发服务器端证书。2.3.2、第二步：根据CA证书，来颁发客户端证书。4.3.1、第1步：添加根证书，客户端证书。.
https请求封装类 双向认证
09-30
https请求封装类 双向认证 httpclient
JAVA使用RestTemplate类实现SSL双向/单向认证（国际）
qq_47275692的博客
03-28 4071
双向/单向认证、国际、SSL
spring mvc 中 RestTemplate 全面详解及示例
最新发布
爱的叹息的专栏
04-09 775
spring mvc 中 RestTemplate 全面详解及示例
https双向认证（证书生成+spring服务端配置+spring gateway配置+ spring restTemplate配置）
weixin_44670774的博客
02-01 1150
​配置springboot服务的https(ssl)双向认证，包括自签名证书生成，为服务配置，gateway配置，restTemplate配置
【原创】SpringBoot实现使用httpclient配合restTemplate验证服务器与服务器之间调用接口的TLS/SSL证书双向认证（精简版，附真实项目代码）
HD243608836的博客
07-13 1955
我的项目是服务器与服务器之间调接口，调用是需要ssl证书双向认证的。 yml中配置： ## 证书双向认证配置（本系统作为客户端） client: ssl: abs: # jks与pkcs12（即pfx）都可以。type不区分大小写 # path: ssl/abs/abs@aaa.abc.com.jks # type: JKS path: ssl/abs/abs@aaa.abc.com.pfx type: PKCS
RestTemplate客户端调用https接口设置ssl证书
get_metoo的博客
04-02 1516
其中 client_keystore.jks， keystore_password 和url 根据项目实现情况替换。该文是演示如何给resttemplate客户端配置ssl证书来进行https接口调用。
Java实现HTTPS双向认证的终极指南：从原理到实战
lucky_love816的博客
02-14 1307
在与某个外部系统进行API对接，比如银行支付网关或第三方服务，这些系统通常要求双向SSL认证来确保通信双方的身份；前端端交互的时候或者进行HTTPS协议传输的时候，其实已经帮我实现了，就不需要通过代码层进行解决了，但是目前就有这个需求，在于第三方系统接口交互的时候需要进行双向认证，那么在实战之前，大家肯定需要对进行个熟悉的认知。
SpringBoot服务间使用自签名证书实现https双向认证
抛洒的阳光专栏
05-21 1763
以服务server-one和server-two之间使用RestTemplate调用为例 一、生成密钥 需要生成server-one和server-two的客户端密钥和一个信任库密钥 1、生成TrustStore(信任库) keytool -genkey -alias trustkeys -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore trustKeys.p12 -validity 36500 2、生成server-one客户端密钥 keyto
RestTemplate https
02-14
### 使用 `RestTemplate` 进行 HTTPS 请求 为了通过 `RestTemplate` 发起 HTTPS 请求，在配置过程中需要注意几个方面。默认情况下，Spring 的 `RestTemplate` 支持 HTTP 和 HTTPS 协议。然而，当涉及到自签名证书或...
RestTemplate 请求https接口，无需证书访问，并整合工具类，细到极致
gubeichengxuyuan的博客
03-07 7420
这次给大家带来的是 RestTemplate 请求https接口，我们都知道，https接口一般是需要证书才能访问的，但是我们可以采取一些特殊的手段，跳过证书验证。
RestTemplate支持https请求
bpqdwo的博客
05-15 9739
设置RestTemplate支持https请求 不多说,直接上代码 @Configuration public class RestTemplateConfig { @Bean public RestTemplate restTemplate() { ClientHttpRequestFactory requestFactory = new HttpCom...
RestTemplate 发送https请求
m178643的博客
02-04 1266
参考：https://www.thinbug.com/q/4072585 import java.security.KeyManagementException; import java.security.KeyStoreException; import java.security.NoSuchAlgorithmException; import java.security.cert.X509C...
RestTemplate发送HTTPS请求
liwenyang1992的专栏
09-20 2110
RestTemplate发送HTTPS请求。
restTemplate访问https
weixin_34344403的博客
08-20 240
为什么80%的码农都做不了架构师？>>> ...
RestTemplate同时支持发送https和http请求,最简洁
饥饿中s的博客
09-28 2982
随着各大网站门户安全意识的提高，https的使用也越来越多，开发时免不了要配置RestTemplate等工具支持https请求的发出，最常见的做法就是发送时，构建sslcontext，忽略证书认证，信任所有。在配置RestTemplate时，考虑兼容性，必须一步到位，同时支持两种方式。springboot集成了优雅的RestTemplate，可以替代以前阿帕奇或者okhttp的一些http通信组件，通过注入的方式在系统内优雅的引用。
Spring RestTemplate 调用https
热门推荐
爱码少年 00fly.online 的博客
11-22 1万+
Spring RestTemplate 调用REST API 给我们的开发工作带来了极大的方便，默认的SimpleClientHttpRequestFactory 并不支持https的调用，我们可以通过引入Apache HttpClient实现对https的调用支持。 第一步，注册 package com.fly.config; import org.apache.http...
使用RestTemplate访问https实现SSL请求操作，设置TLS版本
记录个人学习笔记总结，遇见问题等
02-14 4671
使用RestTemplate访问https实现SSL请求操作，设置TLS版本
RestTemplate请求基本使用
dengdai123654的博客
06-05 589
POST： RestTemplate restTemplate = new RestTemplate(); StringBuffer url= new StringBuffer(LiveGoodsUtils.ADD); url.append(WeixinInfoUtils.accessToken); //请求头 HttpHeaders httpHeaders = new HttpHeaders(); //定义
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值