Jak zignorować błędy certyfikatów SSL w Apache HttpClient 4.0

125

Jak ominąć błędy nieprawidłowych certyfikatów SSL w Apache HttpClient 4.0?

Viet
źródło
12
Należy zauważyć, że odpowiedzi na to pytanie nie robią więcej niż to, co zostało zadane: pozwalają zignorować błąd, ale nie rozwiązują podstawowego problemu (trochę jak wyjęcie baterii z czujnika dymu zamiast ugaszenia ognia ). Certyfikaty mają na celu zapewnienie bezpieczeństwa połączenia SSL / TLS, ignorowanie tych błędów wprowadza podatność na atak MITM. Użyj certyfikatów testowych zamiast ignorować błąd.
Bruno
46
„jak wyjmowanie baterii z czujnika dymu” Możesz dać innym programistom korzyści z wątpliwości i założyć, że wiedzą, co robią. Być może motywacją do tego pytania jest lokalne testowanie, a OP chce przeprowadzić szybki test bez przechodzenia przez okropną ilość gotowych elementów Javy potrzebnych do skonfigurowania nawet prostego środowiska SSL. Może ktoś mógłby po prostu odpowiedzieć na pytanie bez wchodzenia w wykład „bardziej święty niż ty”.
Mike
To znaczy, w naszej firmie, wewnętrzny serwer JIRA posiada „certyfikat oparty na polityce bezpieczeństwa systemu Windows”, który jest ważny na komputerach z systemem Windows w domenie, a nie na innych. Nie mogę kontrolować tej zasady i nadal chcę wywoływać interfejs API JIRA REST.
odiszapc
1
@Bruno Niemożność wyłączenia czujek dymu na okres 30-60 minut podczas zajmowania się małym kominkiem w kuchni wskazuje na szalony brak wglądu we wzorce użytkowania przez jakiegoś urzędnika prawnego w pewnym momencie, w którym czuję się na granicy przestępstwa. Dowodzi tego fakt, że istnieje koncepcja „wyjmowania baterii z czujnika dymu”. Czuję podobny poziom złości z powodu konieczności uzyskania certyfikatów potrzebnych do wykonania prostego testu, o którym wiem, że nie ma wpływu na bezpieczeństwo. Dowodzi tego istnienie tego pytania.
Bill K

Odpowiedzi:

84

Musisz utworzyć SSLContext z własnym TrustManager i utworzyć schemat HTTPS przy użyciu tego kontekstu. Oto kod,

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

// set up a TrustManager that trusts everything
sslContext.init(null, new TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {
                    System.out.println("getAcceptedIssuers =============");
                    return null;
            }

            public void checkClientTrusted(X509Certificate[] certs,
                            String authType) {
                    System.out.println("checkClientTrusted =============");
            }

            public void checkServerTrusted(X509Certificate[] certs,
                            String authType) {
                    System.out.println("checkServerTrusted =============");
            }
} }, new SecureRandom());

SSLSocketFactory sf = new SSLSocketFactory(sslContext);
Scheme httpsScheme = new Scheme("https", 443, sf);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(httpsScheme);

// apache HttpClient version >4.2 should use BasicClientConnectionManager
ClientConnectionManager cm = new SingleClientConnManager(schemeRegistry);
HttpClient httpClient = new DefaultHttpClient(cm);
ZZ Coder
źródło
1
Powiedz, że nie chcę kupować ważnego certyfikatu SSL dla mojej witryny i chcę go po prostu użyć. Ten fragment kodu może pomóc? Dlaczego nie widzę żadnej części, w której potrzebny jest adres URL lub wymagana jest obsługa wyjątków?
Viet,
19
Hmm, mówi mi, że „nowy SSLSocketFactory (ssslCont)” oczekuje KeyStore, a nie SSLContext. Czy coś mi brakuje?
MSpeed
2
Pojawia się błąd, że X509TrustManager nie może być rzutowany na TrustManager.
MW.
2
Upewnij się, że importujesz poprawne pakiety, np. Z org.apache.http.
naczelnik
2
Czy ktoś wie, jak to wszystko połączyć, używając HttpClientBuilder?
Ali
112

Wszystkie pozostałe odpowiedzi były przestarzałe lub nie działały w przypadku HttpClient 4.3.

Oto sposób na zezwolenie na wszystkie nazwy hostów podczas budowania klienta http.

CloseableHttpClient httpClient = HttpClients
    .custom()
    .setHostnameVerifier(AllowAllHostnameVerifier.INSTANCE)
    .build();

Jeśli używasz wersji 4.4 lub nowszej, zaktualizowane wywołanie wygląda następująco:

CloseableHttpClient httpClient = HttpClients
    .custom()
    .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
    .build();
erversteeg
źródło
Dzięki za odpowiedź, chciałbym wiedzieć, z którego pakietu pochodzi HttpsClients, ponieważ używam kompilacji systemu Android („org.apache.httpcomponents: httpclient: 4.3.4”), ale ta klasa nie pojawia się.
Juan Saravia
1
Jego pakiet to org.apache.http.impl.client.HttpClients.
erversteeg
14
Działa to w przypadku niezgodności nazwy hosta (zakładam), ale wydaje się, że nie działa, gdy certyfikat nie jest podpisany przez zaufany urząd.
twm
1
@twm dlatego mówi, że „zezwala na wszystkie nazwy hostów”, problemy z zaufaniem wymagają innej konfiguracji.
eis
1
@eis, zwracałem uwagę, że ta odpowiedź w niektórych przypadkach dotyczy pierwotnego pytania, ale nie dotyczy innych.
twm
43

Po prostu musiałem to zrobić z nowszym HttpClient 4.5 i wygląda na to, że wycofali kilka rzeczy od 4.4, więc oto fragment kodu, który działa dla mnie i używa najnowszego interfejsu API:

final SSLContext sslContext = new SSLContextBuilder()
        .loadTrustMaterial(null, (x509CertChain, authType) -> true)
        .build();

return HttpClientBuilder.create()
        .setSSLContext(sslContext)
        .setConnectionManager(
                new PoolingHttpClientConnectionManager(
                        RegistryBuilder.<ConnectionSocketFactory>create()
                                .register("http", PlainConnectionSocketFactory.INSTANCE)
                                .register("https", new SSLConnectionSocketFactory(sslContext,
                                        NoopHostnameVerifier.INSTANCE))
                                .build()
                ))
        .build();
Z4-
źródło
Pracował dla mnie również dla httpclient 4.5.2
Vikas Ranjan
ten jest aktualny dla HttpClient 4.5
Jesteś niesamowity
31

Tak dla przypomnienia, istnieje znacznie prostszy sposób osiągnięcia tego samego z HttpClient 4.1

    SSLSocketFactory sslsf = new SSLSocketFactory(new TrustStrategy() {

        public boolean isTrusted(
                final X509Certificate[] chain, String authType) throws CertificateException {
            // Oh, I am easy...
            return true;
        }

    });
ok2c
źródło
1
Brakuje Ci kodu w tym przykładzie? Może wywołanie httpClient.set ...?
Szary
6
httpclient.getConnectionManager (). getSchemeRegistry (). register (nowy Schemat ("https", 443, sslsf));
Ben Flynn,
8
SSLSocketFactory jest przestarzały w HttpClient 4.3
Toilal
1
Jeśli używasz Java 8, możesz nawetnew SSLSocketFactory((chain, authType) -> true);
jlb
28

Apache HttpClient 4.5.5

HttpClient httpClient = HttpClients
            .custom()
            .setSSLContext(new SSLContextBuilder().loadTrustMaterial(null, TrustAllStrategy.INSTANCE).build())
            .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
            .build();

Nie użyto żadnego wycofanego interfejsu API.

Prosty weryfikowalny przypadek testowy:

package org.apache.http.client.test;

import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContextBuilder;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;

public class ApacheHttpClientTest {

    private HttpClient httpClient;

    @Before
    public void initClient() throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException {
        httpClient = HttpClients
                .custom()
                .setSSLContext(new SSLContextBuilder().loadTrustMaterial(null, TrustAllStrategy.INSTANCE).build())
                .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                .build();
    }

    @Test
    public void apacheHttpClient455Test() throws IOException {
        executeRequestAndVerifyStatusIsOk("https://expired.badssl.com");
        executeRequestAndVerifyStatusIsOk("https://wrong.host.badssl.com");
        executeRequestAndVerifyStatusIsOk("https://self-signed.badssl.com");
        executeRequestAndVerifyStatusIsOk("https://untrusted-root.badssl.com");
        executeRequestAndVerifyStatusIsOk("https://revoked.badssl.com");
        executeRequestAndVerifyStatusIsOk("https://pinning-test.badssl.com");
        executeRequestAndVerifyStatusIsOk("https://sha1-intermediate.badssl.com");
    }

    private void executeRequestAndVerifyStatusIsOk(String url) throws IOException {
        HttpUriRequest request = new HttpGet(url);

        HttpResponse response = httpClient.execute(request);
        int statusCode = response.getStatusLine().getStatusCode();

        assert statusCode == 200;
    }
}
Michaił Kholodkow
źródło
Dziękuję Ci! Wystarczy zmienić TrustAllStrategy.INSTANCEsię TrustSelfSignedStrategy.INSTANCEw tej odpowiedzi.
Percy Vega,
To nie zadziałało dla mnie. javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: Tworzenie ścieżki PKIX nie powiodło się: sun.security. provider.certpath.SunCertPathBuilderException: nie można znaleźć prawidłowej ścieżki certyfikacji do żądanego celu
ggb667
26

Dla przypomnienia, przetestowany z httpclient 4.3.6 i kompatybilny z Executorem płynnego api:

CloseableHttpClient httpClient = HttpClients.custom().
                    setHostnameVerifier(new AllowAllHostnameVerifier()).
                    setSslcontext(new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy()
                    {
                        public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException
                        {
                            return true;
                        }
                    }).build()).build();
STM
źródło
3
W przypadku HttpClient 4.4 w górę musisz to zrobić - i może być również konieczne utworzenie SSLConnectionSocketFactoryużywającego go SSLContexti zdefiniowanie tego w a Registry<ConnectionSocketFactory>, jeśli masz zamiar utworzyć plik PoolingHttpClientConnectionManager. Pozostałe odpowiedzi są bardziej popularne, ale nie działają w HttpClient 4.4.
Thomas W
1
Działa dokładnie tak samo z httpclient-4.3.5.jar.
Harald
18

W przypadku Apache HttpClient 4.4:

HttpClientBuilder b = HttpClientBuilder.create();

SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
    public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
        return true;
    }
}).build();
b.setSslcontext( sslContext);

// or SSLConnectionSocketFactory.getDefaultHostnameVerifier(), if you don't want to weaken
HostnameVerifier hostnameVerifier = SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;

SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContext, hostnameVerifier);
Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
        .register("http", PlainConnectionSocketFactory.getSocketFactory())
        .register("https", sslSocketFactory)
        .build();

// allows multi-threaded use
PoolingHttpClientConnectionManager connMgr = new PoolingHttpClientConnectionManager( socketFactoryRegistry);
b.setConnectionManager( connMgr);

HttpClient client = b.build();

Jest to wyodrębnione z naszej rzeczywistej implementacji roboczej.

Inne odpowiedzi są popularne, ale w przypadku HttpClient 4.4 nie działają. Spędziłem godziny próbując i wyczerpując możliwości, ale wydaje się, że nastąpiła bardzo duża zmiana API i przeniesienie w 4.4.

Zobacz także nieco pełniejsze wyjaśnienie pod adresem: adresem http://literatejava.com/networks/ignore-ssl-certificate-errors-apache-httpclient-4-4/

Mam nadzieję, że to pomoże!

Thomas W.
źródło
2
Byłem tym kawałkiem SSLContext, którego potrzebowałem. Tak bardzo zobowiązany.
muttonUp
14

Jeśli wszystko, co chcesz zrobić, to pozbyć się błędów nieprawidłowych nazw hostów, możesz po prostu zrobić:

HttpClient httpClient = new DefaultHttpClient();
SSLSocketFactory sf = (SSLSocketFactory)httpClient.getConnectionManager()
    .getSchemeRegistry().getScheme("https").getSocketFactory();
sf.setHostnameVerifier(new AllowAllHostnameVerifier());
David Tinker
źródło
8
Metoda sf.setHostnameVerifier jest przestarzała od 4.1. Alternatywą jest użycie jednego z konstruktorów. Na przykład:SSLSocketFactory sf = new SSLSocketFactory(sslContext, SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
kaliatech
Było to bardzo przydatne, gdy miałem do czynienia ze starszym kodem.
DuncanSungWKim,
9

Używamy HTTPClient 4.3.5 i wypróbowaliśmy prawie wszystkie rozwiązania, które istnieją w przepływie stosu, ale nic. Po przemyśleniu i rozwiązaniu problemu dochodzimy do następującego kodu, który działa idealnie, po prostu dodaj go przed utworzeniem wystąpienia HttpClient.

jakaś metoda dzwonienia podczas wysyłania żądań pocztowych ...

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

kontynuuj swoją prośbę w zwykłej formie

Hamed MP
źródło
7

Mając płynną wersję 4.5.2 musiałem wprowadzić następującą modyfikację, aby to działało.

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

    public void checkServerTrusted(X509Certificate[] certs, String authType) {  }
    }
    };

    SSLContext sc = SSLContext.getInstance("SSL");
    sc.init(null, trustAllCerts, new SecureRandom());
    CloseableHttpClient httpClient = HttpClients.custom().setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE).setSslcontext(sc).build();

    String output = Executor.newInstance(httpClient).execute(Request.Get("https://127.0.0.1:3000/something")
                                      .connectTimeout(1000)
                                      .socketTimeout(1000)).returnContent().asString();
    } catch (Exception e) {
    }
Talespin_Kit
źródło
1
To jedyne rozwiązanie, które u mnie zadziałało. Wypróbowałem powyższe rozwiązania dla 4.3 i 4.4 przed aktualizacją do 4.5 i wypróbowaniem tego.
dirkoneill
6

Tak to zrobiłem -

  1. Utwórz własną fabrykę MockSSLSocketFactory (klasa dołączona poniżej)
  2. Użyj go, aby zainicjować DefaultHttpClient. Jeśli używany jest serwer proxy, należy podać ustawienia serwera proxy.

Inicjalizacja DefaultHTTPClient -

SchemeRegistry schemeRegistry = new SchemeRegistry();
    schemeRegistry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
    schemeRegistry.register(new Scheme("https", 443, new MockSSLSocketFactory()));
    ClientConnectionManager cm = new SingleClientConnManager(schemeRegistry);

    DefaultHttpClient httpclient = new DefaultHttpClient(cm);

Mock SSL Factory -

public class MockSSLSocketFactory extends SSLSocketFactory {

public MockSSLSocketFactory() throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
    super(trustStrategy, hostnameVerifier);
}

private static final X509HostnameVerifier hostnameVerifier = new X509HostnameVerifier() {
    @Override
    public void verify(String host, SSLSocket ssl) throws IOException {
        // Do nothing
    }

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

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

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

private static final TrustStrategy trustStrategy = new TrustStrategy() {
    @Override
    public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        return true;
    }
};
}

Jeśli za serwerem proxy, musisz to zrobić -

HttpParams params = new BasicHttpParams();
    params.setParameter(AuthPNames.PROXY_AUTH_PREF, getClientAuthPrefs());

DefaultHttpClient httpclient = new DefaultHttpClient(cm, params);

httpclient.getCredentialsProvider().setCredentials(
                        new AuthScope(proxyHost, proxyPort),
                        new UsernamePasswordCredentials(proxyUser, proxyPass));
Swaroop Rath
źródło
Byłoby pomocne, gdybyś w przyszłości uwzględnił import. Istnieją dwie różne klasy.
AndroidDev
4

Jako rozszerzenie odpowiedzi ZZ Codera, miło będzie nadpisać zmiennik nazwy hosta.

// ...
SSLSocketFactory sf = new SSLSocketFactory (sslContext);
sf.setHostnameVerifier(new X509HostnameVerifier() {
    public boolean verify(String hostname, SSLSession session) {
        return true;
    }

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

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

    public void verify(String host, SSLSocket ssl) throws IOException {
    }
});
// ...
eldur
źródło
Możesz osiągnąć to samo, po prostu robiącsf.setHostnameVerifier(new AllowAllHostnameVerifier());
Dan Dyer
7
Sf.setHostnameVerifier jest przestarzały od 4.1. Alternatywą jest użycie jednego z konstruktorów. Na przykład:SSLSocketFactory sf = new SSLSocketFactory(sslContext, SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
kaliatech
4
        DefaultHttpClient httpclient = new DefaultHttpClient();

    SSLContext sslContext;
    try {
        sslContext = SSLContext.getInstance("SSL");

        // set up a TrustManager that trusts everything
        try {
            sslContext.init(null,
                    new TrustManager[] { new X509TrustManager() {
                        public X509Certificate[] getAcceptedIssuers() {
                            log.debug("getAcceptedIssuers =============");
                            return null;
                        }

                        public void checkClientTrusted(
                                X509Certificate[] certs, String authType) {
                            log.debug("checkClientTrusted =============");
                        }

                        public void checkServerTrusted(
                                X509Certificate[] certs, String authType) {
                            log.debug("checkServerTrusted =============");
                        }
                    } }, new SecureRandom());
        } catch (KeyManagementException e) {
        }
         SSLSocketFactory ssf = new SSLSocketFactory(sslContext,SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
         ClientConnectionManager ccm = this.httpclient.getConnectionManager();
         SchemeRegistry sr = ccm.getSchemeRegistry();
         sr.register(new Scheme("https", 443, ssf));            
    } catch (Exception e) {
        log.error(e.getMessage(),e);
    }
mały tygrys
źródło
4

Aby zaakceptować wszystkie certyfikaty w HttpClient 4.4.x, możesz użyć poniższej linijki podczas tworzenia httpClient:

httpClient = HttpClients.custom().setSSLHostnameVerifier(new NoopHostnameVerifier()).setSslcontext(new SSLContextBuilder().loadTrustMaterial(null, (x509Certificates, s) -> true).build()).build();
Chłodny
źródło
Otrzymuję to: Przyczyna: javax.net.ssl.SSLHandshakeException: java.security.cert.CertificateException: Brak alternatywnych nazw tematów?
Jak zezwolić na połączenia z witrynami SSL bez certyfikatów w HttpClient API lub RestClient API?
4

Testowane za pomocą HttpClient 4.5.5 z interfejsem Fluent API

final SSLContext sslContext = new SSLContextBuilder()
    .loadTrustMaterial(null, (x509CertChain, authType) -> true).build();

CloseableHttpClient httpClient = HttpClients.custom()
    .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
    .setSSLContext(sslContext).build();

String result = Executor.newInstance(httpClient)
    .execute(Request.Get("https://localhost:8080/someapi")
    .connectTimeout(1000).socketTimeout(1000))
    .returnContent().asString();
Lachesis
źródło
3

Poniższy kod działa z 4.5.5

import java.io.IOException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

class HttpsSSLClient {


    public static CloseableHttpClient createSSLInsecureClient() {
        SSLContext sslcontext = createSSLContext();
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new HostnameVerifier() {

            @Override
            public boolean verify(String paramString, SSLSession paramSSLSession) {
                return true;
            }
        });
        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
        return httpclient;
    }


    private static SSLContext createSSLContext() {
        SSLContext sslcontext = null;
        try {
            sslcontext = SSLContext.getInstance("TLS");
            sslcontext.init(null, new TrustManager[] {new TrustAnyTrustManager()}, new SecureRandom());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
        return sslcontext;
    }


    private static class TrustAnyTrustManager 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[] {};
        }
    }

}
public class TestMe {


    public static void main(String[] args) throws IOException {
        CloseableHttpClient client = HttpsSSLClient.createSSLInsecureClient();

        CloseableHttpResponse res = client.execute(new HttpGet("https://wrong.host.badssl.com/"));
        System.out.println(EntityUtils.toString(res.getEntity()));
    }
}

Dane wyjściowe z kodu to

Kod

Dane wyjściowe w przeglądarce to

Zły SSL

Zastosowany pom jest poniżej

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.tarun</groupId>
    <artifactId>testing</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>6</source>
                    <target>6</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
    <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.5</version>
    </dependency>

</dependencies>
</project>
Tarun Lalwani
źródło
dzięki za zaktualizowaną odpowiedź, przyznałem nowemu gościowi nagrodę za „powitanie”, ale chciałem tylko zaktualizowanych odpowiedzi dla wszystkich!
1
@feelingunwelcome, jasne. Ja też go zagłosowałem :-)
Tarun Lalwani
2

pełna wersja działająca dla Apache HttpClient 4.1.3 (oparta na powyższym kodzie olega, ale nadal wymagała w moim systemie allow_all_hostname_verifier):

private static HttpClient trustEveryoneSslHttpClient() {
    try {
        SchemeRegistry registry = new SchemeRegistry();

        SSLSocketFactory socketFactory = new SSLSocketFactory(new TrustStrategy() {

            public boolean isTrusted(final X509Certificate[] chain, String authType) throws CertificateException {
                // Oh, I am easy...
                return true;
            }

        }, org.apache.http.conn.ssl.SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

        registry.register(new Scheme("https", 443, socketFactory));
        ThreadSafeClientConnManager mgr = new ThreadSafeClientConnManager(registry);
        DefaultHttpClient client = new DefaultHttpClient(mgr, new DefaultHttpClient().getParams());
        return client;
    } catch (GeneralSecurityException e) {
        throw new RuntimeException(e);
    }
}

Uwaga Ponownie wyrzucam wszystkie wyjątki, ponieważ tak naprawdę niewiele mogę zrobić, jeśli coś z tego zawiedzie w prawdziwym systemie!

Korny
źródło
2

Jeśli korzystasz z Fluent API , musisz go skonfigurować za pomocą Executor:

Executor.unregisterScheme("https");
SSLSocketFactory sslSocketFactory = new SSLSocketFactory(sslContext,
                                  SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
Executor.registerScheme(new Scheme("https", 443, sslSocketFactory));

... gdzie sslContextjest utworzony SSLContext, jak pokazano w odpowiedzi ZZ Coder .

Następnie możesz wykonywać żądania http jako:

String responseAsString = Request.Get("https://192.168.1.0/whatever.json")
                         .execute().getContent().asString();

Uwaga: testowano z HttpClient 4.2

Elias Dorneles
źródło
Niestety przestarzałe w 4.3: „Przestarzałe. (4.3) nie używaj”.
STM
2

Testowane z 4.3.3

import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.SSLContext;

import org.apache.http.Header;
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.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class AccessProtectedResource {

public static void main(String[] args) throws Exception {

    // Trust all certs
    SSLContext sslcontext = buildSSLContext();

    // Allow TLSv1 protocol only
    SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
            sslcontext,
            new String[] { "TLSv1" },
            null,
            SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

    CloseableHttpClient httpclient = HttpClients.custom()
            .setSSLSocketFactory(sslsf)
            .build();
    try {

        HttpGet httpget = new HttpGet("https://yoururl");

        System.out.println("executing request" + httpget.getRequestLine());

        CloseableHttpResponse response = httpclient.execute(httpget);
        try {
            HttpEntity entity = response.getEntity();

            System.out.println("----------------------------------------");
            System.out.println(response.getStatusLine());
            if (entity != null) {
                System.out.println("Response content length: " + entity.getContentLength());
            }
            for (Header header : response.getAllHeaders()) {
                System.out.println(header);
            }
            EntityUtils.consume(entity);
        } finally {
            response.close();
        }
    } finally {
        httpclient.close();
    }
}

private static SSLContext buildSSLContext()
        throws NoSuchAlgorithmException, KeyManagementException,
        KeyStoreException {
    SSLContext sslcontext = SSLContexts.custom()
            .setSecureRandom(new SecureRandom())
            .loadTrustMaterial(null, new TrustStrategy() {

                public boolean isTrusted(X509Certificate[] chain, String authType)
                        throws CertificateException {
                    return true;
                }
            })
            .build();
    return sslcontext;
}

}

craftmannadeem
źródło
Jak ustawić wartości w nagłówkach, jeśli chciałem to zrobić?
2

Testowane 4.5.4:

            SSLContext sslContext = new SSLContextBuilder()
                    .loadTrustMaterial(null, (TrustStrategy) (arg0, arg1) -> true).build();

            CloseableHttpClient httpClient = HttpClients
                    .custom()
                    .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                    .setSSLContext(sslContext)
                    .build();
Jacky
źródło
0

Jeśli napotkałeś ten problem podczas korzystania z AmazonS3Client, który osadza Apache HttpClient 4.1, wystarczy zdefiniować właściwość systemową taką jak ta, aby moduł sprawdzania certyfikatów SSL był zrelaksowany:

-Dcom.amazonaws.sdk.disableCertChecking = true

Udało się psotom

Mike Slinn
źródło
0

fwiw, przykład użycia implementacji JAX-RS 2.x „RestEasy” w celu zbudowania specjalnego klienta „zaufaj wszystkim” ...

    import java.io.IOException;
    import java.net.MalformedURLException;
    import java.security.GeneralSecurityException;
    import java.security.KeyManagementException;
    import java.security.KeyStoreException;
    import java.security.NoSuchAlgorithmException;
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;
    import java.util.ArrayList;
    import java.util.Arrays;
    import javax.ejb.Stateless;
    import javax.net.ssl.SSLContext;
    import javax.ws.rs.GET;
    import javax.ws.rs.Path;
    import javax.ws.rs.Produces;
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    import javax.ws.rs.client.Entity;
    import javax.ws.rs.core.MediaType;
    import javax.ws.rs.core.Response;
    import org.apache.http.config.Registry;
    import org.apache.http.config.RegistryBuilder;
    import org.apache.http.conn.HttpClientConnectionManager;
    import org.apache.http.conn.ssl.TrustStrategy;
    import org.jboss.resteasy.client.jaxrs.ResteasyClient;
    import org.jboss.resteasy.client.jaxrs.ResteasyClientBuilder;
    import org.jboss.resteasy.client.jaxrs.ResteasyWebTarget;
    import org.jboss.resteasy.client.jaxrs.engines.ApacheHttpClient4Engine;
    import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
    import org.apache.http.conn.socket.ConnectionSocketFactory;
    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.HttpClientBuilder;
    import org.apache.http.ssl.SSLContexts;

    @Stateless
    @Path("/postservice")
    public class PostService {

        private static final Logger LOG = LogManager.getLogger("PostService");

        public PostService() {
        }

        @GET
        @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
        public PostRespDTO get() throws NoSuchAlgorithmException, KeyManagementException, MalformedURLException, IOException, GeneralSecurityException {

            //...object passed to the POST method...
            PostDTO requestObject = new PostDTO();
            requestObject.setEntryAList(new ArrayList<>(Arrays.asList("ITEM0000A", "ITEM0000B", "ITEM0000C")));
            requestObject.setEntryBList(new ArrayList<>(Arrays.asList("AAA", "BBB", "CCC")));

            //...build special "trust all" client to call POST method...
            ApacheHttpClient4Engine engine = new ApacheHttpClient4Engine(createTrustAllClient());

            ResteasyClient client = new ResteasyClientBuilder().httpEngine(engine).build();
            ResteasyWebTarget target = client.target("https://localhost:7002/postRespWS").path("postrespservice");
            Response response = target.request().accept(MediaType.APPLICATION_JSON).post(Entity.entity(requestObject, MediaType.APPLICATION_JSON));

            //...object returned from the POST method...
            PostRespDTO responseObject = response.readEntity(PostRespDTO.class);

            response.close();

            return responseObject;
        }


        //...get special "trust all" client...
        private static CloseableHttpClient createTrustAllClient() throws NoSuchAlgorithmException, KeyStoreException, KeyManagementException {

            SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, TRUSTALLCERTS).useProtocol("TLS").build();
            HttpClientBuilder builder = HttpClientBuilder.create();
            NoopHostnameVerifier noop = new NoopHostnameVerifier();
            SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext, noop);
            builder.setSSLSocketFactory(sslConnectionSocketFactory);
            Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create().register("https", sslConnectionSocketFactory).build();
            HttpClientConnectionManager ccm = new BasicHttpClientConnectionManager(registry);
            builder.setConnectionManager(ccm);

            return builder.build();
        }


        private static final TrustStrategy TRUSTALLCERTS = new TrustStrategy() {
            @Override
            public boolean isTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
                return true;
            }
        };
    }

powiązane zależności Maven

    <dependency>
        <groupId>org.jboss.resteasy</groupId>
        <artifactId>resteasy-client</artifactId>
        <version>3.0.10.Final</version>
    </dependency>
    <dependency>
        <groupId>org.jboss.resteasy</groupId>
        <artifactId>jaxrs-api</artifactId>
        <version>3.0.10.Final</version>
    </dependency>
    <dependency>
        <groupId>org.jboss.resteasy</groupId>
        <artifactId>resteasy-jackson2-provider</artifactId>
        <version>3.0.10.Final</version>
    </dependency>
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5</version>
        <type>jar</type>
    </dependency>
    <dependency>
        <groupId>javax</groupId>
        <artifactId>javaee-web-api</artifactId>
        <version>7.0</version>
        <scope>provided</scope>
    </dependency> 
sairn
źródło
-1

Jeśli używasz Apache httpClient 4.5.x, spróbuj tego:

public static void main(String... args)  {

    try (CloseableHttpClient httpclient = createAcceptSelfSignedCertificateClient()) {
        HttpGet httpget = new HttpGet("https://example.com");
        System.out.println("Executing request " + httpget.getRequestLine());

        httpclient.execute(httpget);
        System.out.println("----------------------------------------");
    } catch (NoSuchAlgorithmException | KeyStoreException | KeyManagementException | IOException e) {
        throw new RuntimeException(e);
    }
}

private static CloseableHttpClient createAcceptSelfSignedCertificateClient()
        throws KeyManagementException, NoSuchAlgorithmException, KeyStoreException {

    // use the TrustSelfSignedStrategy to allow Self Signed Certificates
    SSLContext sslContext = SSLContextBuilder
            .create()
            .loadTrustMaterial(new TrustSelfSignedStrategy())
            .build();

    // we can optionally disable hostname verification. 
    // if you don't want to further weaken the security, you don't have to include this.
    HostnameVerifier allowAllHosts = new NoopHostnameVerifier();

    // create an SSL Socket Factory to use the SSLContext with the trust self signed certificate strategy
    // and allow all hosts verifier.
    SSLConnectionSocketFactory connectionFactory = new SSLConnectionSocketFactory(sslContext, allowAllHosts);

    // finally create the HttpClient using HttpClient factory methods and assign the ssl socket factory
    return HttpClients
            .custom()
            .setSSLSocketFactory(connectionFactory)
            .build();
}
Brijesh Patel
źródło