忽略Apache HttpClient 4.3中的SSL证书

102

如何忽略Apache HttpClient 4.3的 SSL证书（全部信任）？

我在SO上找到的所有答案都对待以前的版本，并且API更改了。

有关：

编辑：

仅用于测试目的。孩子们，不要在家（或在生产中）尝试

java ssl apache-httpcomponents

— 雅各布·M。
source

146

下面的代码用于信任自签名证书。创建客户端时，必须使用TrustSelfSignedStrategy：

SSLContextBuilder builder = new SSLContextBuilder();
builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
        builder.build());
CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(
        sslsf).build();

HttpGet httpGet = new HttpGet("https://some-server");
CloseableHttpResponse response = httpclient.execute(httpGet);
try {
    System.out.println(response.getStatusLine());
    HttpEntity entity = response.getEntity();
    EntityUtils.consume(entity);
} finally {
    response.close();
}

我没有SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER故意包括：关键是允许使用自签名证书进行测试，因此您不必从证书颁发机构获取适当的证书。您可以轻松创建具有正确主机名的自签名证书，而不要添加SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER标志。

— 大批
source

8

我必须将参数SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER添加到构造函数中，以使其与HttpClientBuilder一起使用（如holmis83对花瓶的响应中所述）。

— dejuknow 2014年

另请参阅httpclient网站hc.apache.org/httpcomponents-client-4.3.x/httpclient/examples/…

— arajashe 2014年

2

我还必须使用ALLOW_ALL_HOSTNAME_VERIFIER：SSLConnectionSocketFactory（builder.build（），SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER）;

— 显示名称

这段代码对我有效，而无需使用不带参数的构造函数SSLConnectionSocketFactory.ALLOW_‌ALL_HOSTNAME_VERIFIER

— user11153

我希望您已经指定了正在使用的类的完整参考。SSLContextBuilderIdea找到了多个被调用的类。

— MasterMind

91

如果您使用上面的PoolingHttpClientConnectionManager过程不起作用，则将忽略自定义SSLContext。创建PoolingHttpClientConnectionManager时，必须在构造函数中传递socketFactoryRegistry。

SSLContextBuilder builder = SSLContexts.custom();
builder.loadTrustMaterial(null, new TrustStrategy() {
    @Override
    public boolean isTrusted(X509Certificate[] chain, String authType)
            throws CertificateException {
        return true;
    }
});
SSLContext sslContext = builder.build();
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
        sslContext, new X509HostnameVerifier() {
            @Override
            public void verify(String host, SSLSocket ssl)
                    throws IOException {
            }

            @Override
            public void verify(String host, X509Certificate cert)
                    throws SSLException {
            }

            @Override
            public void verify(String host, String[] cns,
                    String[] subjectAlts) throws SSLException {
            }

            @Override
            public boolean verify(String s, SSLSession sslSession) {
                return true;
            }
        });

Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder
        .<ConnectionSocketFactory> create().register("https", sslsf)
        .build();

PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(
        socketFactoryRegistry);
CloseableHttpClient httpclient = HttpClients.custom()
        .setConnectionManager(cm).build();

— 花瓶
source

11

您可以使用SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER，而不是构建自己的X509HostnameVerifier。

— holmis83 2013年

如下@@@@@@@@@@@@ 95标记，HttpClients的默认设置是为您提供一个PoolingHttpClient，因此这经常很重要。在找到需要的答案之前，我不得不尝试其中的一些答案。

— SunSear 2014年

1

试图将此方法应用于WebSphere并得到“ java.security.KeyStoreException：IBMTrustManager：访问信任库时出现问题java.io.IOException：无效的密钥库格式” 而不是builder.loadTrustMaterial的null

— Georgy Gobozov 2014年

1

实际上，使用HttpClient 4.5时，两者HttpClients.custom().setConnectionManager(cm).build()和HttpClients.custom().setSSLSocketFactory(connectionFactory).build()都可以使用，因此您无需创建PoolingHttpClientConnectionManager

— soulmachine

创建此后如何使用PoolingHttpClientConnectionManager，我的代码正在运行，但是我想知道连接池是否起作用

— Labeo 2015年

34

除了@mavroprovato的答案外，如果您想信任所有证书而不是仅是自签名的，则可以这样做（按照代码样式）

builder.loadTrustMaterial(null, new TrustStrategy(){
    public boolean isTrusted(X509Certificate[] chain, String authType)
        throws CertificateException {
        return true;
    }
});

或（从我自己的代码直接复制粘贴）：

import javax.net.ssl.SSLContext;
import org.apache.http.ssl.TrustStrategy;
import org.apache.http.ssl.SSLContexts;

// ...

        SSLContext sslContext = SSLContexts
                .custom()
                //FIXME to contain real trust store
                .loadTrustMaterial(new TrustStrategy() {
                    @Override
                    public boolean isTrusted(X509Certificate[] chain,
                        String authType) throws CertificateException {
                        return true;
                    }
                })
                .build();

而且，如果您也想跳过主机名验证，则需要设置

    CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(
            sslsf).setSSLHostnameVerifier( NoopHostnameVerifier.INSTANCE).build();

也一样（不建议使用ALLOW_ALL_HOSTNAME_VERIFIER）。

强制性警告：您实际上不应该这样做，接受所有证书是一件坏事。但是，在某些罕见的用例中，您想这样做。

作为前面给出的代码的注释，即使httpclient.execute（）抛出异常，您也希望关闭响应

CloseableHttpResponse response = null;
try {
    response = httpclient.execute(httpGet);
    System.out.println(response.getStatusLine());
    HttpEntity entity = response.getEntity();
    EntityUtils.consume(entity);
}
finally {
    if (response != null) {
        response.close();
    }
}

上面的代码已使用测试

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

对于感兴趣的人，这是我完整的测试集：

import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.TrustStrategy;
import org.apache.http.util.EntityUtils;
import org.junit.Test;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.SSLPeerUnverifiedException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

public class TrustAllCertificatesTest {
    final String expiredCertSite = "https://expired.badssl.com/";
    final String selfSignedCertSite = "https://self-signed.badssl.com/";
    final String wrongHostCertSite = "https://wrong.host.badssl.com/";

    static final TrustStrategy trustSelfSignedStrategy = new TrustSelfSignedStrategy();
    static final TrustStrategy trustAllStrategy = new TrustStrategy(){
        public boolean isTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
            return true;
        }
    };

    @Test
    public void testSelfSignedOnSelfSignedUsingCode() throws Exception {
        doGet(selfSignedCertSite, trustSelfSignedStrategy);
    }
    @Test(expected = SSLHandshakeException.class)
    public void testExpiredOnSelfSignedUsingCode() throws Exception {
        doGet(expiredCertSite, trustSelfSignedStrategy);
    }
    @Test(expected = SSLPeerUnverifiedException.class)
    public void testWrongHostOnSelfSignedUsingCode() throws Exception {
        doGet(wrongHostCertSite, trustSelfSignedStrategy);
    }

    @Test
    public void testSelfSignedOnTrustAllUsingCode() throws Exception {
        doGet(selfSignedCertSite, trustAllStrategy);
    }
    @Test
    public void testExpiredOnTrustAllUsingCode() throws Exception {
        doGet(expiredCertSite, trustAllStrategy);
    }
    @Test(expected = SSLPeerUnverifiedException.class)
    public void testWrongHostOnTrustAllUsingCode() throws Exception {
        doGet(wrongHostCertSite, trustAllStrategy);
    }

    @Test
    public void testSelfSignedOnAllowAllUsingCode() throws Exception {
        doGet(selfSignedCertSite, trustAllStrategy, NoopHostnameVerifier.INSTANCE);
    }
    @Test
    public void testExpiredOnAllowAllUsingCode() throws Exception {
        doGet(expiredCertSite, trustAllStrategy, NoopHostnameVerifier.INSTANCE);
    }
    @Test
    public void testWrongHostOnAllowAllUsingCode() throws Exception {
        doGet(expiredCertSite, trustAllStrategy, NoopHostnameVerifier.INSTANCE);
    }

    public void doGet(String url, TrustStrategy trustStrategy, HostnameVerifier hostnameVerifier) throws Exception {
        SSLContextBuilder builder = new SSLContextBuilder();
        builder.loadTrustMaterial(trustStrategy);
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                builder.build());
        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(
                sslsf).setSSLHostnameVerifier(hostnameVerifier).build();

        HttpGet httpGet = new HttpGet(url);
        CloseableHttpResponse response = httpclient.execute(httpGet);
        try {
            System.out.println(response.getStatusLine());
            HttpEntity entity = response.getEntity();
            EntityUtils.consume(entity);
        } finally {
            response.close();
        }
    }
    public void doGet(String url, TrustStrategy trustStrategy) throws Exception {

        SSLContextBuilder builder = new SSLContextBuilder();
        builder.loadTrustMaterial(trustStrategy);
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                builder.build());
        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(
                sslsf).build();

        HttpGet httpGet = new HttpGet(url);
        CloseableHttpResponse response = httpclient.execute(httpGet);
        try {
            System.out.println(response.getStatusLine());
            HttpEntity entity = response.getEntity();
            EntityUtils.consume(entity);
        } finally {
            response.close();
        }
    }
}

（在github中运行测试项目）

— 埃斯
source

1

如果发生异常，HttpClient＃execute将永远不会返回空响应对象。而且，在请求执行期间发生异常的情况下，库存的HttpClient实现将确保自动释放所有系统资源，例如租用连接。mavroprovato使用的异常处理就足够了。

— ok2c

@oleg 可关闭接口的重点是“关闭流并释放与其关联的所有系统资源。如果流已关闭，则调用此方法无效。” 因此，即使不需要它，也最好使用它。另外，我不理解返回空响应的注释-当然，如果抛出异常，它不会返回任何东西吗？

— 2013年

1

Apache HttpClient永远不会返回null或部分初始化的响应对象。这与#close调用的次数无关，而是在finally子句中完全不必要的空检查

— ok2c

@oleg，我给出的代码从未假设它会返回null或部分初始化的响应对象，甚至不会检查这种情况。我不知道你在说什么？

— 2013年

1

[ 叹气 ]鉴于HttpResponse永远不能为null，并且在发生异常的情况下，#execute方法将在不返回响应的情况下终止；-)

— ok2c

22

花瓶的答案的一个小补充：

使用PoolingHttpClientConnectionManager时，SocketFactoryRegistry提供的解决方案可以工作。

但是，通过纯http的连接将不再起作用。您还必须为http协议添加一个PlainConnectionSocketFactory，以使其再次起作用：

Registry<ConnectionSocketFactory> socketFactoryRegistry = 
  RegistryBuilder.<ConnectionSocketFactory> create()
  .register("https", sslsf)
  .register("http", new PlainConnectionSocketFactory()).build();

— 米高
source

我相信默认情况下http使用协议PlainConnectionSocketFactory 。我只注册https了httpclient，仍然可以获取纯HTTP URL。所以我认为这一步骤不是必需的。

— soulmachine

@soulmachine不会的PoolingHttpClientConnectionManager

— amseager

15

在尝试了各种选项之后，以下配置对http和https均有效

        SSLContextBuilder builder = new SSLContextBuilder();
        builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(builder.build(),SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);


        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", new PlainConnectionSocketFactory())
                .register("https", sslsf)
                .build();


        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);
        cm.setMaxTotal(2000);//max connection


        //System.setProperty("jsse.enableSNIExtension", "false"); //""
        CloseableHttpClient httpClient = HttpClients.custom()
                .setSSLSocketFactory(sslsf)
                .setConnectionManager(cm)
                .build();

我正在使用http-client 4.3.3-

compile 'org.apache.httpcomponents:httpclient:4.3.3'

— 索拉卜
source

1

感谢您提供一个全面的，可以正常运行的示例！我以前的解决方案遇到了多个问题，这极大地帮助了我。还帮助您提供了import语句，因为有多个具有相同名称的类，这增加了混乱。

— helmy

8

更简单，更短的工作代码：

我们使用的是HTTPClient 4.3.5，我们尝试了所有几乎所有解决方案都存在于stackoverflow上，但是什么也没有，在思考并找出问题所在之后，我们得出了下面的代码，它们非常有效，只需在创建HttpClient实例之前将其添加即可。

您用来发出后期要求的某种方法...

SSLContextBuilder builder = new SSLContextBuilder();
    builder.loadTrustMaterial(null, new TrustStrategy() {
        @Override
        public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            return true;
        }
    });

    SSLConnectionSocketFactory sslSF = new SSLConnectionSocketFactory(builder.build(),
            SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

    HttpClient httpClient = HttpClients.custom().setSSLSocketFactory(sslSF).build();
    HttpPost postRequest = new HttpPost(url);

继续以正常形式调用和使用HttpPost实例

— 哈明德议员
source

我们如何在标题中发布数据？如果这样做，那么请参阅HTTP / 1.1 400错误请求

6

这是上述技术的有效提要，等同于“ curl --insecure”：

HttpClient getInsecureHttpClient() throws GeneralSecurityException {
    TrustStrategy trustStrategy = new TrustStrategy() {
        @Override
        public boolean isTrusted(X509Certificate[] chain, String authType) {
            return true;
        }
    };

    HostnameVerifier hostnameVerifier = new HostnameVerifier() {
        @Override
        public boolean verify(String hostname, SSLSession session) {
            return true;
        }
    };

    return HttpClients.custom()
            .setSSLSocketFactory(new SSLConnectionSocketFactory(
                    new SSLContextBuilder().loadTrustMaterial(trustStrategy).build(),
                    hostnameVerifier))
            .build();
}

— divbyzero
source

5

使用http客户端4.5时，我必须使用javasx.net.ssl.HostnameVerifier允许任何主机名（出于测试目的）。这是我最终要做的事情：

CloseableHttpClient httpClient = null;
    try {
        SSLContextBuilder sslContextBuilder = new SSLContextBuilder();
        sslContextBuilder.loadTrustMaterial(null, new TrustSelfSignedStrategy());

        HostnameVerifier hostnameVerifierAllowAll = new HostnameVerifier() 
            {
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            };

        SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContextBuilder.build(), hostnameVerifierAllowAll);

        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        credsProvider.setCredentials(
            new AuthScope("192.168.30.34", 8443),
            new UsernamePasswordCredentials("root", "password"));

        httpClient = HttpClients.custom()
            .setSSLSocketFactory(sslSocketFactory)
            .setDefaultCredentialsProvider(credsProvider)
            .build();

        HttpGet httpGet = new HttpGet("https://192.168.30.34:8443/axis/services/getStuff?firstResult=0&maxResults=1000");

        CloseableHttpResponse response = httpClient.execute(httpGet);

        int httpStatus = response.getStatusLine().getStatusCode();
        if (httpStatus >= 200 && httpStatus < 300) { [...]
        } else {
            throw new ClientProtocolException("Unexpected response status: " + httpStatus);
        }

    } catch (Exception ex) {
        ex.printStackTrace();
    }
    finally {
        try {
            httpClient.close();
        } catch (IOException ex) {
            logger.error("Error while closing the HTTP client: ", ex);
        }
    }

— 库尔特
source

HostnameVerifier的实现解决了HTTPClient 4.5的问题。

— digz6666 '16

对于喜欢lambda（JDK1.8）的用户，可以替换

SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContextBuilder.build(), hostnameVerifierAllowAll);

为

SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContextBuilder.build(), (hostName, sslSession) -> true);

。它避免了匿名类，并使代码更具可读性。

— Vielinko

3

在顶部PoolingHttpClientConnectionManager以及Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory> create().register("https", sslFactory).build(); 如果你想异步HttpClient的使用PoolingNHttpClientConnectionManager代码shoudl类似于以下

SSLContextBuilder builder = SSLContexts.custom();
builder.loadTrustMaterial(null, new TrustStrategy() {
    @Override
    public boolean isTrusted(X509Certificate[] chain, String authType)
            throws CertificateException {
        return true;
    }
});
SSLContext sslContext = builder.build();
SchemeIOSessionStrategy sslioSessionStrategy = new SSLIOSessionStrategy(sslContext, 
                new HostnameVerifier(){
            @Override
            public boolean verify(String hostname, SSLSession session) {
                return true;// TODO as of now allow all hostnames
            }
        });
Registry<SchemeIOSessionStrategy> sslioSessionRegistry = RegistryBuilder.<SchemeIOSessionStrategy>create().register("https", sslioSessionStrategy).build();
PoolingNHttpClientConnectionManager ncm  = new PoolingNHttpClientConnectionManager(new DefaultConnectingIOReactor(),sslioSessionRegistry);
CloseableHttpAsyncClient asyncHttpClient = HttpAsyncClients.custom().setConnectionManager(ncm).build();
asyncHttpClient.start();

— 安南（Anant Laxmikant Bobde）
source

3

如果使用HttpClient 4.5.x，则代码可以类似于以下内容：

SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null,
        TrustSelfSignedStrategy.INSTANCE).build();
SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(
        sslContext, NoopHostnameVerifier.INSTANCE);

HttpClient httpClient = HttpClients.custom()
                                   .setDefaultCookieStore(new BasicCookieStore())
                                   .setSSLSocketFactory(sslSocketFactory)
                                   .build();

— 保罗·瓦尔加斯
source

没有为我工作。我正在使用HttpClient：4.5.5。和HttpCore 4.4.9

— Vijay Kumar，

2

class ApacheHttpClient {

    /***
     * This is a https get request that bypasses certificate checking and hostname verifier.
     * It uses basis authentication method.
     * It is tested with Apache httpclient-4.4.
     * It dumps the contents of a https page on the console output.
     * It is very similar to http get request, but with the additional customization of
     *   - credential provider, and
     *   - SSLConnectionSocketFactory to bypass certification checking and hostname verifier.
     * @param path String
     * @param username String
     * @param password String
     * @throws IOException
     */
    public void get(String path, String username, String password) throws IOException {
        final CloseableHttpClient httpClient = HttpClients.custom()
                .setDefaultCredentialsProvider(createCredsProvider(username, password))
                .setSSLSocketFactory(createGenerousSSLSocketFactory())
                .build();

        final CloseableHttpResponse response = httpClient.execute(new HttpGet(path));
        try {
            HttpEntity entity = response.getEntity();
            if (entity == null)
                return;
            System.out.println(EntityUtils.toString(entity));
        } finally {
            response.close();
            httpClient.close();
        }
    }

    private CredentialsProvider createCredsProvider(String username, String password) {
        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        credsProvider.setCredentials(
                AuthScope.ANY,
                new UsernamePasswordCredentials(username, password));
        return credsProvider;
    }

    /***
     * 
     * @return SSLConnectionSocketFactory that bypass certificate check and bypass HostnameVerifier
     */
    private SSLConnectionSocketFactory createGenerousSSLSocketFactory() {
        SSLContext sslContext;
        try {
            sslContext = SSLContext.getInstance("SSL");
            sslContext.init(null, new TrustManager[]{createGenerousTrustManager()}, new SecureRandom());
        } catch (KeyManagementException | NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
        return new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
    }

    private X509TrustManager createGenerousTrustManager() {
        return new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] cert, String s) throws CertificateException {
            }

            @Override
            public void checkServerTrusted(X509Certificate[] cert, String s) throws CertificateException {
            }

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        };
    }
}

— 李大海
source

2

信任Apache HTTP客户端中的所有证书

TrustManager[] trustAllCerts = new TrustManager[]{
                    new X509TrustManager() {
                        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                            return null;
                        }
                        public void checkClientTrusted(
                            java.security.cert.X509Certificate[] certs, String authType) {
                        }
                        public void checkServerTrusted(
                            java.security.cert.X509Certificate[] certs, String authType) {
                        }
                    }
                };

          try {
                SSLContext sc = SSLContext.getInstance("SSL");
                sc.init(null, trustAllCerts, new java.security.SecureRandom());
                SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                        sc);
                httpclient = HttpClients.custom().setSSLSocketFactory(
                        sslsf).build();
                HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

— 杰夫·Z
source

这与httpclient 4.5.9配合得很好，只需复制并粘贴所有内容即可。

— sathya

1

（我本来可以直接在vasekt的答案中添加评论，但我的信誉点不足（不确定那里的逻辑）

无论如何...我想说的是，即使您没有明确地为PoolingConnection创建/询问，也不意味着您没有得到一个。

我发疯了，试图弄清楚为什么原始解决方案对我不起作用，但是我忽略了vasekt的回答，因为它“不适用于我的情况”-错误！

我低时盯着堆栈跟踪，发现中间看到一个PoolingConnection。邦-我讨厌他的加入和成功！！（我们的演示是明天，我感到绝望）:-)

— 丰富95
source

0

您可以使用以下代码片段来获取HttpClient实例，而无需进行ssl认证检查。

private HttpClient getSSLHttpClient() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {

        LogLoader.serverLog.trace("In getSSLHttpClient()");

        SSLContext context = SSLContext.getInstance("SSL");

        TrustManager tm = new X509TrustManager() {
            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }

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

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

        context.init(null, new TrustManager[] { tm }, null);

        HttpClientBuilder builder = HttpClientBuilder.create();
        SSLConnectionSocketFactory sslConnectionFactory = new SSLConnectionSocketFactory(context);
        builder.setSSLSocketFactory(sslConnectionFactory);

        PlainConnectionSocketFactory plainConnectionSocketFactory = new PlainConnectionSocketFactory();
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("https", sslConnectionFactory).register("http", plainConnectionSocketFactory).build();

        PoolingHttpClientConnectionManager ccm = new PoolingHttpClientConnectionManager(registry);
        ccm.setMaxTotal(BaseConstant.CONNECTION_POOL_SIZE);
        ccm.setDefaultMaxPerRoute(BaseConstant.CONNECTION_POOL_SIZE);
        builder.setConnectionManager((HttpClientConnectionManager) ccm);

        builder.disableRedirectHandling();

        LogLoader.serverLog.trace("Out getSSLHttpClient()");

        return builder.build();
    }

— 拉达迪亚（Radadiya Nikunj）
source

0

稍作调整即可从上面的@divbyzero答复以修复声纳安全警告

CloseableHttpClient getInsecureHttpClient() throws GeneralSecurityException {
            TrustStrategy trustStrategy = (chain, authType) -> true;

            HostnameVerifier hostnameVerifier = (hostname, session) -> hostname.equalsIgnoreCase(session.getPeerHost());

            return HttpClients.custom()
                    .setSSLSocketFactory(new SSLConnectionSocketFactory(new SSLContextBuilder().loadTrustMaterial(trustStrategy).build(), hostnameVerifier))
                    .build();
        }

— 安迪
source

0

最初，我能够使用信任策略禁用本地主机，后来又添加了NoopHostnameVerifier。现在它将对localhost和任何计算机名称都适用

SSLContext sslContext = SSLContextBuilder.create().loadTrustMaterial(null, new TrustStrategy() {

            @Override
            public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                return true;
            }

        }).build();
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                sslContext, NoopHostnameVerifier.INSTANCE);
        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();

— U_R_Naveen UR_Naveen
source