Akceptuj certyfikat ssl z własnym podpisem serwera w kliencie Java

Istnieje lepsza alternatywa dla ufania wszystkim certyfikatom: Utwórz TrustStore, który konkretnie Ufa danemu certyfikatowi i użyj tego do utworzenia SSLContext, z którego uzyskasz SSLSocketFactory, aby ustawić na HttpsURLConnection. Oto kompletny kod:

File crtFile = new File("server.crt");
Certificate certificate = CertificateFactory.getInstance("X.509").generateCertificate(new FileInputStream(crtFile));

KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
keyStore.load(null, null);
keyStore.setCertificateEntry("server", certificate);

TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
trustManagerFactory.init(keyStore);

SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, trustManagerFactory.getTrustManagers(), null);

HttpsURLConnection connection = (HttpsURLConnection) new URL(url).openConnection();
connection.setSSLSocketFactory(sslContext.getSocketFactory());

Możesz alternatywnie załadować KeyStore bezpośrednio z pliku lub pobrać certyfikat X. 509 z dowolnego zaufanego źródła.

Zauważ, że z tym kodem certyfikaty w cacerts nie będą używane. Ten konkretny HttpsURLConnection będzie ufał tylko temu szczególne świadectwo.

Apache HttpClient 4.5 obsługuje akceptowanie certyfikatów podpisanych samodzielnie:

SSLContext sslContext = SSLContexts.custom()
    .loadTrustMaterial(new TrustSelfSignedStrategy())
    .build();
SSLConnectionSocketFactory socketFactory =
    new SSLConnectionSocketFactory(sslContext);
Registry<ConnectionSocketFactory> reg =
    RegistryBuilder.<ConnectionSocketFactory>create()
    .register("https", socketFactory)
    .build();
HttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(reg);        
CloseableHttpClient httpClient = HttpClients.custom()
    .setConnectionManager(cm)
    .build();
HttpGet httpGet = new HttpGet(url);
CloseableHttpResponse sslResponse = httpClient.execute(httpGet);

To buduje fabrykę gniazd SSL, która będzie używać TrustSelfSignedStrategy, rejestruje ją za pomocą niestandardowego Menedżera połączeń, a następnie robi HTTP GET używając tego menedżera połączeń.

Zgadzam się z tymi, którzy śpiewają "nie rób tego w produkcji", jednak istnieją przypadki użycia do przyjmowania certyfikatów podpisanych samodzielnie poza produkcją; używamy ich w zautomatyzowanych testach integracji, więc używamy SSL (jak w produkcji) nawet gdy nie działa na sprzęcie produkcyjnym.

Ścigałem ten problem do dostawcy certyfikatów, który nie jest częścią domyślnych zaufanych hostów JVM od JDK 8u74. Dostawcą jest www.identrust.com , ale to nie była domena, z którą próbowałem się połączyć. Ta domena otrzymała certyfikat od tego dostawcy. Zobacz czy cross root pokrywa zaufanie przez domyślną listę w JDK / JRE? -- przeczytaj kilka wpisów. Zobacz także które przeglądarki i systemy operacyjne obsługują Let ' s Encrypt .

Więc w aby połączyć się z domeną, którą byłem zainteresowany, która miała certyfikat wydany z identrust.com zrobiłem następujące kroki. W zasadzie, musiałem dostać identrust.com (DST Root CA X3) certyfikat do zaufania przez JVM. Udało mi się to zrobić używając Apache HttpComponents 4.5 W ten sposób:

1: Uzyskaj certyfikat od indettrust w Instrukcje pobierania łańcucha certyfikatów . Kliknij na link DST Root CA X3 .

2: Zapisz łańcuch do pliku o nazwie " DST Root CA X3.pem". Be pamiętaj, aby dodać linie "- - - - - BEGIN CERTIFICATE- - - - - " i "- - - - - - End CERTIFICATE - - - - - " w pliku na początku i na końcu.

3: Utwórz plik keystore java, cacerts.jks z następującym poleceniem:

keytool -import -v -trustcacerts -alias IdenTrust -keypass yourpassword -file dst_root_ca_x3.pem -keystore cacerts.jks -storepass yourpassword

4: skopiuj wynikowe cacerty.JKS keystore do katalogu zasobów Twojej aplikacji java / (maven).

5: użyj poniższego kodu, aby załadować ten plik i dołączyć go do HttpClient Apache 4.5. To rozwiąże problem dla wszystkich domen, które mają certyfikaty wydane z indetrust.com util Oracle włącza certyfikat do domyślnego magazynu kluczy JRE.

SSLContext sslcontext = SSLContexts.custom()
        .loadTrustMaterial(new File(CalRestClient.class.getResource("/cacerts.jks").getFile()), "yourpasword".toCharArray(),
                new TrustSelfSignedStrategy())
        .build();
// Allow TLSv1 protocol only
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
        sslcontext,
        new String[] { "TLSv1" },
        null,
        SSLConnectionSocketFactory.getDefaultHostnameVerifier());
CloseableHttpClient httpclient = HttpClients.custom()
        .setSSLSocketFactory(sslsf)
        .build();

Kiedy projekt buduje, to cacerts.jks zostanie skopiowany do classpath i załadowany stamtąd. W tym momencie nie testowałem na innych witrynach ssl, ale jeśli powyższy kod "łańcuchy" w tym certyfikacie to też będą działać, ale znowu, Nie wiem.

Reference: Custom SSL context i Jak zaakceptować certyfikat z podpisem własnym z Java HttpsURLConnection?

Zamiast ustawiać domyślną fabrykę gniazd (co IMO jest złe) - yhis wpłynie tylko na bieżące połączenie, a nie na każde połączenie SSL, które próbujesz otworzyć:

URLConnection connection = url.openConnection();
    // JMD - this is a better way to do it that doesn't override the default SSL factory.
    if (connection instanceof HttpsURLConnection)
    {
        HttpsURLConnection conHttps = (HttpsURLConnection) connection;
        // Set up a Trust all manager
        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)
            {
            }
        } };

        // Get a new SSL context
        SSLContext sc = SSLContext.getInstance("TLSv1.2");
        sc.init(null, trustAllCerts, new java.security.SecureRandom());
        // Set our connection to use this SSL context, with the "Trust all" manager in place.
        conHttps.setSSLSocketFactory(sc.getSocketFactory());
        // Also force it to trust all hosts
        HostnameVerifier allHostsValid = new HostnameVerifier() {
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        };
        // and set the hostname verifier.
        conHttps.setHostnameVerifier(allHostsValid);
    }
InputStream stream = connection.getInputStream();

Ufaj wszystkim certyfikatom SSL:- Możesz ominąć SSL, jeśli chcesz przetestować na serwerze testowym. Ale nie używaj tego kodu do produkcji.

public static class NukeSSLCerts {
protected static final String TAG = "NukeSSLCerts";

public static void nuke() {
    try {
        TrustManager[] trustAllCerts = new TrustManager[] { 
            new X509TrustManager() {
                public X509Certificate[] getAcceptedIssuers() {
                    X509Certificate[] myTrustedAnchors = new X509Certificate[0];  
                    return myTrustedAnchors;
                }

                @Override
                public void checkClientTrusted(X509Certificate[] certs, String authType) {}

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

        SSLContext sc = SSLContext.getInstance("SSL");
        sc.init(null, trustAllCerts, new SecureRandom());
        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
        HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
            @Override
            public boolean verify(String arg0, SSLSession arg1) {
                return true;
            }
        });
    } catch (Exception e) { 
    }
}

}

Proszę wywołać tę funkcję w funkcji OnCreate () w Activity lub w klasie aplikacji.

NukeSSLCerts.nuke();

To może być używane do Volley w Androidzie.

Przyjęta odpowiedź jest w porządku, ale chciałbym dodać coś do tego, ponieważ używałem IntelliJ na Macu i nie mogłem go uruchomić przy użyciu zmiennej JAVA_HOME path.

Okazuje się, że Java Home była inna podczas uruchamiania aplikacji z IntelliJ.

Aby dowiedzieć się dokładnie, gdzie to jest, możesz po prostu zrobić System.getProperty("java.home"), ponieważ tam są odczytywane zaufane certyfikaty.

Miałem problem, że przekazywałem adres URL do biblioteki, która wywoływała url.openConnection(); zaadaptowałem odpowiedź Jona-Daniela,

public class TrustHostUrlStreamHandler extends URLStreamHandler {

    private static final Logger LOG = LoggerFactory.getLogger(TrustHostUrlStreamHandler.class);

    @Override
    protected URLConnection openConnection(final URL url) throws IOException {

        final URLConnection urlConnection = new URL(url.getProtocol(), url.getHost(), url.getPort(), url.getFile()).openConnection();

        // adapated from
        // https://stackoverflow.com/questions/2893819/accept-servers-self-signed-ssl-certificate-in-java-client
        if (urlConnection instanceof HttpsURLConnection) {
            final HttpsURLConnection conHttps = (HttpsURLConnection) urlConnection;

            try {
                // Set up a Trust all manager
                final TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {

                    @Override
                    public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                        return null;
                    }

                    @Override
                    public void checkClientTrusted(final java.security.cert.X509Certificate[] certs, final String authType) {
                    }

                    @Override
                    public void checkServerTrusted(final java.security.cert.X509Certificate[] certs, final String authType) {
                    }
                } };

                // Get a new SSL context
                final SSLContext sc = SSLContext.getInstance("TLSv1.2");
                sc.init(null, trustAllCerts, new java.security.SecureRandom());
                // Set our connection to use this SSL context, with the "Trust all" manager in place.
                conHttps.setSSLSocketFactory(sc.getSocketFactory());
                // Also force it to trust all hosts
                final HostnameVerifier allHostsValid = new HostnameVerifier() {
                    @Override
                    public boolean verify(final String hostname, final SSLSession session) {
                        return true;
                    }
                };

                // and set the hostname verifier.
                conHttps.setHostnameVerifier(allHostsValid);

            } catch (final NoSuchAlgorithmException e) {
                LOG.warn("Failed to override URLConnection.", e);
            } catch (final KeyManagementException e) {
                LOG.warn("Failed to override URLConnection.", e);
            }

        } else {
            LOG.warn("Failed to override URLConnection. Incorrect type: {}", urlConnection.getClass().getName());
        }

        return urlConnection;
    }

}

Używając tej klasy można utworzyć nowy adres URL za pomocą:

trustedUrl = new URL(new URL(originalUrl), "", new TrustHostUrlStreamHandler());
trustedUrl.openConnection();

To ma tę zaletę, że jest zlokalizowane i nie zastępuje domyślnego URL.openConnection.

Zaakceptowana odpowiedź wymaga opcji 3

Także Opcja 2 jest straszna . Nigdy nie należy go używać (esp. w produkcji), ponieważ daje fałszywe poczucie bezpieczeństwa. Wystarczy użyć HTTP zamiast opcji 2.

Opcja 3

Użyj własnoręcznie podpisanego certyfikatu, aby nawiązać połączenie Https.

Oto przykład:

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManagerFactory;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.KeyStore;

/*
 * Use a SSLSocket to send a HTTP GET request and read the response from an HTTPS server.
 * It assumes that the client is not behind a proxy/firewall
 */

public class SSLSocketClientCert
{
    private static final String[] useProtocols = new String[] {"TLSv1.2"};
    public static void main(String[] args) throws Exception
    {
        URL inputUrl = null;
        String certFile = null;
        if(args.length < 1)
        {
            System.out.println("Usage: " + SSLSocketClient.class.getName() + " <url>");
            System.exit(1);
        }
        if(args.length == 1)
        {
            inputUrl = new URL(args[0]);
        }
        else
        {
            inputUrl = new URL(args[0]);
            certFile = args[1];
        }
        SSLSocket sslSocket = null;
        PrintWriter outWriter = null;
        BufferedReader inReader = null;
        try
        {
            SSLSocketFactory sslSocketFactory = getSSLSocketFactory(certFile);

            sslSocket = (SSLSocket) sslSocketFactory.createSocket(inputUrl.getHost(), inputUrl.getPort() == -1 ? inputUrl.getDefaultPort() : inputUrl.getPort());
            String[] enabledProtocols = sslSocket.getEnabledProtocols();
            System.out.println("Enabled Protocols: ");
            for(String enabledProtocol : enabledProtocols) System.out.println("\t" + enabledProtocol);

            String[] supportedProtocols = sslSocket.getSupportedProtocols();
            System.out.println("Supported Protocols: ");
            for(String supportedProtocol : supportedProtocols) System.out.println("\t" + supportedProtocol + ", ");

            sslSocket.setEnabledProtocols(useProtocols);

            /*
             * Before any data transmission, the SSL socket needs to do an SSL handshake.
             * We manually initiate the handshake so that we can see/catch any SSLExceptions.
             * The handshake would automatically  be initiated by writing & flushing data but
             * then the PrintWriter would catch all IOExceptions (including SSLExceptions),
             * set an internal error flag, and then return without rethrowing the exception.
             *
             * This means any error messages are lost, which causes problems here because
             * the only way to tell there was an error is to call PrintWriter.checkError().
             */
            sslSocket.startHandshake();
            outWriter = sendRequest(sslSocket, inputUrl);
            readResponse(sslSocket);
            closeAll(sslSocket, outWriter, inReader);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            closeAll(sslSocket, outWriter, inReader);
        }
    }

    private static PrintWriter sendRequest(SSLSocket sslSocket, URL inputUrl) throws IOException
    {
        PrintWriter outWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(sslSocket.getOutputStream())));
        outWriter.println("GET " + inputUrl.getPath() + " HTTP/1.1");
        outWriter.println("Host: " + inputUrl.getHost());
        outWriter.println("Connection: Close");
        outWriter.println();
        outWriter.flush();
        if(outWriter.checkError())        // Check for any PrintWriter errors
            System.out.println("SSLSocketClient: PrintWriter error");
        return outWriter;
    }

    private static void readResponse(SSLSocket sslSocket) throws IOException
    {
        BufferedReader inReader = new BufferedReader(new InputStreamReader(sslSocket.getInputStream()));
        String inputLine;
        while((inputLine = inReader.readLine()) != null)
            System.out.println(inputLine);
    }

    // Terminate all streams
    private static void closeAll(SSLSocket sslSocket, PrintWriter outWriter, BufferedReader inReader) throws IOException
    {
        if(sslSocket != null) sslSocket.close();
        if(outWriter != null) outWriter.close();
        if(inReader != null) inReader.close();
    }

    // Create an SSLSocketFactory based on the certificate if it is available, otherwise use the JVM default certs
    public static SSLSocketFactory getSSLSocketFactory(String certFile)
        throws CertificateException, KeyStoreException, IOException, NoSuchAlgorithmException, KeyManagementException
    {
        if (certFile == null) return (SSLSocketFactory) SSLSocketFactory.getDefault();
        Certificate certificate = CertificateFactory.getInstance("X.509").generateCertificate(new FileInputStream(new File(certFile)));

        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(null, null);
        keyStore.setCertificateEntry("server", certificate);

        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(keyStore);

        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, trustManagerFactory.getTrustManagers(), null);

        return sslContext.getSocketFactory();
    }
}

Jeśli ' oni ' używają certyfikatu z własnym podpisem, to do nich należy podjęcie kroków wymaganych do uczynienia ich serwera użytecznym. W szczególności oznacza to dostarczenie certyfikatu do Ciebie w trybie offline w sposób godny zaufania. Więc niech to zrobią. Następnie zaimportujesz go do sklepu truststore za pomocą keytool, jak opisano w Przewodniku referencyjnym JSSE. Nawet nie myśl o niepewnym TrustManager zamieszczonym tutaj.

EDIT na rzecz seventeen (!) downvoters, oraz liczni komentatorzy poniżej, którzy najwyraźniej nie przeczytali tego, co tu napisałem, to Nie jeremiada przeciwko własnoręcznie podpisanym certyfikatom. Nie ma nic złego w własnoręcznie podpisanych certyfikatach , gdy są poprawnie zaimplementowane. jednak, poprawnym sposobem ich implementacji jest dostarczenie certyfikatu bezpiecznie za pośrednictwem procesu offline, zamiast za pośrednictwem nieautoryzowanego kanału, który zostanie użyty do uwierzytelnienia. To chyba oczywiste? Informatyka to oczywiste dla każdej organizacji dbającej o bezpieczeństwo, dla której kiedykolwiek pracowałem, od banków z tysiącami oddziałów po moje własne firmy. "Rozwiązanie" bazujące na kodzie klienta polegające na zaufaniu wszystkim certyfikatom, w tym certyfikatom podpisanym przez absolutnie każdego, lub dowolnemu organowi arbitralnemu tworzącemu się jako CA, jest ipso facto Nie bezpieczne. To tylko zabawa w ochronę. To bezcelowe. Masz prywatną, odporną na manipulacje, odporną na odpowiedź, odporną na zastrzyki rozmowę z ... ktokolwiek. Ktokolwiek. Mężczyzna w środku. Podszywacz. Ktokolwiek. Równie dobrze możesz użyć zwykłego tekstu.

Nie jest to rozwiązanie całego problemu, ale oracle ma dobrą szczegółową dokumentację, jak używać tego keytoola. To wyjaśnia, jak

1. Użyj keytool.
2. generowanie Cert / self signed Cert za pomocą keytool.
3. Importuj wygenerowane certy do klientów java.

Https://docs.oracle.com/cd/E54932_01/doc.705/e54936/cssg_create_ssl_cert.htm#CSVSG178

Zamiast używać keytool zgodnie z sugestią z komentarza, w RHEL możesz użyć update-ca-trust począwszy od nowszych wersji RHEL 6. Musisz mieć certyfikat w formacie pem. Then

trust anchor <cert.pem>

Edycja / etc/PKI/ca-trust/source/cert.p11-ustaw i zmień "Kategoria certyfikatu: inne-wpis"na" kategoria certyfikatu: autorytet". (Lub użyj sed, aby to zrobić w skrypcie.) Następnie wykonaj

update-ca-trust

Kilka uwag:

• nie mogłem znaleźć "trust" na moim serwerze RHEL 6 i yum nie oferował aby go zainstalować. Skończyło się na używaniu go na serwerze RHEL 7 i kopiowaniu .P11-odbiór.
• aby to zadziałało dla ciebie, być może będziesz musiał to zrobić update-ca-trust enable. To zastąpi/etc/PKI /java/cacerts dowiązaniem symbolicznym wskazującym na/etc/PKI/ca-trust/extracted / java / cacerts. (Możesz więc najpierw wykonać kopię zapasową tego pierwszego.)
• Jeśli twój Klient java używa cacerts przechowywanych w innej lokalizacji, będziesz chciał ręcznie zastąpić go dowiązaniem symbolicznym do /etc/PKI / ca-trust/extracted/java / cacerts, lub zastąp go tym plikiem.