Apache HttpClient 4.3'te SSL sertifikasının yok sayılması

104

Apache HttpClient 4.3 için SSL sertifikası (hepsine güven) nasıl göz ardı edilir ?

SO'da bulduğum tüm cevaplar önceki sürümleri ele alıyor ve API değişti.

İlişkili:

Düzenle:

  • Yalnızca test amaçlıdır. Çocuklar, bunu evde (veya üretimde) denemeyin
java  ssl  apache-httpcomponents 
— Jakub M.
kaynak

Yanıtlar:

146

Aşağıdaki kod, kendinden imzalı sertifikalara güvenmek için işe yarar. İstemcinizi oluştururken TrustSelfSignedStrategy'yi kullanmanız gerekir:

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_VERIFIERAmacı dahil etmedim : Önemli olan, kendinden imzalı sertifikalarla teste izin vermekti, böylece bir sertifika yetkilisinden uygun bir sertifika almanıza gerek kalmaz. Doğru ana bilgisayar adıyla kolayca kendi kendine imzalanan bir sertifika oluşturabilirsiniz, bu nedenle SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIERbayrağı eklemek yerine bunu yapın .

— Mavroprovato
kaynak
8
Bunu HttpClientBuilder ile çalışmak için yapıcıya SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER bağımsız değişkenini eklemek zorunda kaldım (holmis83'ün vasekt'e yanıtında bahsedildiği gibi).
— dejuknow
— arajashe
2
ALLOW_ALL_HOSTNAME_VERIFIER'ı da kullanmak zorunda kaldım: SSLConnectionSocketFactory (builder.build (), SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
— Görünen ad
Bu kod benim için çalışıyor olmadan argümanı ile kullanımdan kaldırılmış kurucu kullanılarakSSLConnectionSocketFactory.ALLOW_‌​ALL_HOSTNAME_VERIFIER
— user11153
Keşke kullandığınız sınıfın tam referansını belirtmiş olsaydınız. SSLContextBuilderIdea tarafından çağrılan birden çok sınıf bulunur.
— MasterMind
91

Yukarıdaki PoolingHttpClientConnectionManager prosedürünü kullanıyorsanız, özel SSLContext yoksayılır. PoolingHttpClientConnectionManager'ı oluştururken yapıcıda socketFactoryRegistry'i geçirmeniz gerekir.

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();
— Vasekt
kaynak
11
Kendi X509HostnameVerifier'inizi oluşturmak yerine SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER'ı kullanabilirsiniz.
— holmis83
Aşağıda @ rich95 ile işaretlendiği gibi, HttpClients için varsayılan, size bir PoolingHttpClient vermektir, bu nedenle bu çok sık geçerlidir. Buna ihtiyacım olduğunu bulmadan önce bu cevapların epeyce birkaçını denemek zorunda kaldım.
— SunSear
1
Bunu WebSphere'de uygulamaya çalıştım ve "java.security.KeyStoreException: IBMTrustManager: Güven deposuna erişim sorunu java.io.IOException: Geçersiz anahtar deposu biçimi" Bunu önlemek için KeyStore trustStore = KeyStore.getInstance (KeyStore.getDefaultType ()); null yerine builder.loadTrustMaterial için
— Georgy Gobozov
1
Aslında ile HttpClient 4.5, hem HttpClients.custom().setConnectionManager(cm).build()ve HttpClients.custom().setSSLSocketFactory(connectionFactory).build()bir oluşturmanıza gerek kalmaz, çalışacakPoolingHttpClientConnectionManager
— soulmachine
Bunu oluşturduktan sonra PoolingHttpClientConnectionManager nasıl kullanılır, kodum çalışıyor ancak bağlantı havuzunun çalışıp çalışmadığını bilmek istiyorum
— Labeo
35

@Mavroprovato yanıtına ek olarak, yalnızca kendi kendine imzalamak yerine tüm sertifikalara güvenmek istiyorsanız, bunu yaparsınız (kodunuzun tarzında)

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

veya (kendi kodumdan doğrudan kopyala-yapıştır):

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();

Ayrıca ana bilgisayar adı doğrulamasını da atlamak istiyorsanız, şunu ayarlamanız gerekir: 

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

yanı sıra. (ALLOW_ALL_HOSTNAME_VERIFIER kullanımdan kaldırıldı).

Zorunlu uyarı: Bunu gerçekten yapmamalısınız, tüm sertifikaları kabul etmek kötü bir şeydir. Bununla birlikte, bunu yapmak istediğiniz bazı nadir kullanım durumları vardır.

Daha önce verilen koda bir not olarak, httpclient.execute () bir istisna atsa bile yanıtı kapatmak isteyeceksiniz

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();
    }
}

Yukarıdaki kod kullanılarak test edildi

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

Ve ilgilenenler için işte tam test setim:

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'da çalışan test projesi )

— eis
kaynak
1
HttpClient # execute, bir istisna durumunda hiçbir zaman boş bir yanıt nesnesi döndürmez. Ayrıca, stok HttpClient uygulamaları, talep yürütme sırasında bir istisna olması durumunda, kiralık bağlantılar gibi tüm sistem kaynaklarının otomatik olarak serbest bırakılmasını sağlayacaktır. Mavroprovato tarafından kullanılan istisnai işlemler tamamen yeterlidir.
— ok2c
@oleg, Kapatılabilir arabirimin amacı "[...] akışını kapatmak ve onunla ilişkili tüm sistem kaynaklarını serbest bırakmaktır. Akış zaten kapalıysa, bu yöntemi çağırmanın bir etkisi yoktur." bu nedenle, gerekli olmasa bile kullanmak en iyi uygulamadır. Ayrıca, boş yanıt döndürme yorumunu da anlamıyorum - tabii ki, bir istisna atarsa, hiçbir şey döndürmez mi?
— eis
1
Apache HttpClient hiçbir zaman boş veya kısmen başlatılmış bir yanıt nesnesi döndürmez. Bunun kaç kez #close çağrıldığıyla hiçbir ilgisi yoktur, bunun yerine nihayet cümlesinde tamamen gereksiz boş kontrol
— ok2c
@oleg ve verdiğim kod hiçbir zaman boş veya kısmen başlatılmış bir yanıt nesnesi döndüreceğini veya böyle bir durumu kontrol edeceğini varsaymaz. Neden bahsettiğin hakkında hiçbir fikrim yok?
— eis
1
[ iç çekiş ] HttpResponse'nin hiçbir zaman boş olamayacağı ve bir istisna durumunda #execute yöntemi bir yanıt döndürmeden sona ereceği için tamamen gereksizdir ;-)
— ok2c
22

Vasekt'in cevabına küçük bir ekleme:

SocketFactoryRegistry ile sağlanan çözüm, PoolingHttpClientConnectionManager kullanılırken çalışır.

Ancak, düz http üzerinden bağlantılar artık çalışmıyor. Ek olarak http protokolü için bir PlainConnectionSocketFactory eklemeniz ve bunların yeniden çalışmasını sağlamanız gerekir:

Registry<ConnectionSocketFactory> socketFactoryRegistry = 
  RegistryBuilder.<ConnectionSocketFactory> create()
  .register("https", sslsf)
  .register("http", new PlainConnectionSocketFactory()).build();
— migo
kaynak
httpProtokolün PlainConnectionSocketFactory varsayılan olarak kullanıldığına inanıyorum . Sadece kaydoldum httpsve httpclienthala düz HTTP URL'leri alabilirim. bu yüzden bu adımın gerekli olduğunu düşünmüyorum.
— soulmachine
@soulmachine it won't forPoolingHttpClientConnectionManager
— amseager
15

Çeşitli seçenekleri denedikten sonra, aşağıdaki yapılandırma hem http hem de https için çalıştı:

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);

CloseableHttpClient httpClient = HttpClients.custom()
                .setSSLSocketFactory(sslsf)
                .setConnectionManager(cm)
                .build();

Http-client 4.3.3 kullanıyorum: compile 'org.apache.httpcomponents:httpclient:4.3.3'

— Saurabh
kaynak
1
Kapsamlı, tam olarak çalışan bir örnek sağladığınız için teşekkür ederiz! Önceki çözümlerle birden fazla sorunu çözüyordum ve bu çok yardımcı oldu. Ayrıca, kafa karışıklığını artıran, aynı adlara sahip birden çok sınıf olduğundan, içe aktarma ifadelerini sağlamanıza yardımcı oldu.
— helmy
8

Daha basit ve daha kısa çalışma kodu:

HTTPClient 4.3.5 kullanıyoruz ve neredeyse tüm çözümleri stackoverflow üzerinde denedik ama hiçbir şey yapmadık, Sorunu düşündükten ve çözdükten sonra, mükemmel çalışan aşağıdaki koda geliyoruz, HttpClient örneğini oluşturmadan önce eklemeniz yeterli.

gönderi talebinde bulunmak için kullandığınız bazı yöntemler ...

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 örneğini normal biçimde aramaya ve kullanmaya devam edin

— Hamed MP
kaynak
Verileri başlıklarda nasıl yayınlayabiliriz?
6

İşte "curl --insecure" ile eşdeğer olan yukarıdaki tekniklerin çalışan bir damıtması:

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
kaynak
5

Http istemcisi 4.5 kullanırken, herhangi bir ana bilgisayar adına izin vermek için (test amacıyla) javasx.net.ssl.HostnameVerifier'i kullanmak zorunda kaldım. İşte sonunda yaptığım şey:

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);
        }
    }
— Kurt
kaynak
HostnameVerifier'in uygulanması, HTTPClient 4.5 için sorunu çözdü.
— digz6666
lambdaları sevenler için (JDK1.8) SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContextBuilder.build(), hostnameVerifierAllowAll);ile değiştirilebilir SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContextBuilder.build(), (hostName, sslSession) -> true);. Anonim sınıflardan kaçınır ve kodu biraz daha okunaklı hale getirir.
— Vielinko
3

Üstüne üstlük PoolingHttpClientConnectionManagerbirlikte Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory> create().register("https", sslFactory).build(); İsterseniz bir zaman uyumsuz httpclient kullanarak PoolingNHttpClientConnectionManageraşağıdaki gibi shoudl kodu

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
kaynak
3

Eğer kullanıyorsanız HttpClient 4.5.x, kodunuz aşağıdakine benzer olabilir:

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();
— Paul Vargas
kaynak
Benim için çalışmadı. HttpClient kullanıyorum: 4.5.5. ve 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;
            }
        };
    }
}
— Dahai Li
kaynak
2

Apache HTTP İstemcisindeki Tüm Sertifikalara Güvenin

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());
— Jeff Z
kaynak
Bu, httpclient 4.5.9 ile iyi çalıştı, sadece tüm içeriği kopyalayıp yapıştırın.
— sathya
1

(Vasekt'in cevabına doğrudan bir yorum eklerdim ama yeterince itibar puanım yok (oradaki mantıktan emin değilim)

Her neyse ... söylemek istediğim, açıkça bir PoolingConnection oluşturmasanız / istemeseniz bile, bir Havuz Bağlantısı almadığınız anlamına gelmez.

Orijinal çözümün neden benim için işe yaramadığını anlamaya çalışırken çıldırıyordum, ama vasekt'in cevabını "benim durumum için geçerli olmadığı" için görmezden geldim - yanlış!

Düşükken yığın izime bakıyordum ve ortasında bir PoolingConnection gördüm. Bang - Eklemesini ve başarısını yordum !! (demomuz yarın ve umutsuzluğa kapılıyordum) :-)

— Rich95
kaynak
0

HttpClient örneğini ssl sertifika denetimi olmadan almak için aşağıdaki kod parçacığını kullanabilirsiniz.

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
kaynak
0

Sonar güvenlik uyarılarını düzeltmek için yukarıdaki @divbyzero'dan yanıtlamak için hafif ince ayar yapın

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();
        }
— andyd
kaynak
0

Başlangıçta, güven stratejisini kullanarak localhost'u devre dışı bırakabildim, daha sonra NoopHostnameVerifier'ı ekledim. Artık hem localhost hem de herhangi bir makine adı için çalışacak

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
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.