Acepte el certificado ssl autofirmado del servidor en el cliente Java

Parece una pregunta estándar, pero no pude encontrar instrucciones claras en ningún lado.

Tengo un código Java que intenta conectarse a un servidor con un certificado probablemente autofirmado (o caducado). El código informa el siguiente error:

[HttpMethodDirector] I/O exception (javax.net.ssl.SSLHandshakeException) caught 
when processing request: sun.security.validator.ValidatorException: PKIX path 
building failed: sun.security.provider.certpath.SunCertPathBuilderException: 
unable to find valid certification path to requested target

Según tengo entendido, tengo que usar keytool y decirle a Java que está bien permitir esta conexión.

Todas las instrucciones para solucionar este problema suponen que soy completamente competente con keytool, como

generar clave privada para el servidor e importarla al almacén de claves

¿Hay alguien que pueda publicar instrucciones detalladas?

Estoy ejecutando Unix, por lo que bash script sería lo mejor.

No estoy seguro de si es importante, pero el código se ejecuta en jboss.

Aquí tiene básicamente dos opciones: agregar el certificado autofirmado a su almacén de confianza JVM o configurar su cliente para

Opción 1

Exporte el certificado desde su navegador e impórtelo en su almacén de confianza JVM (para establecer una cadena de confianza):

<JAVA_HOME>\bin\keytool -import -v -trustcacerts
-alias server-alias -file server.cer
-keystore cacerts.jks -keypass changeit
-storepass changeit 

opcion 2

Deshabilitar validación de certificado:

// Create a trust manager that does not validate certificate chains
TrustManager[] trustAllCerts = new TrustManager[] { 
    new X509TrustManager() {     
        public java.security.cert.X509Certificate[] getAcceptedIssuers() { 
            return new X509Certificate[0];
        } 
        public void checkClientTrusted( 
            java.security.cert.X509Certificate[] certs, String authType) {
            } 
        public void checkServerTrusted( 
            java.security.cert.X509Certificate[] certs, String authType) {
        }
    } 
}; 

// Install the all-trusting trust manager
try {
    SSLContext sc = SSLContext.getInstance("SSL"); 
    sc.init(null, trustAllCerts, new java.security.SecureRandom()); 
    HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
} catch (GeneralSecurityException e) {
} 
// Now you can access an https URL without having the certificate in the truststore
try { 
    URL url = new URL("https://hostname/index.html"); 
} catch (MalformedURLException e) {
} 

Tenga en cuenta que no recomiendo la Opción # 2 en absoluto . Deshabilitar el administrador de confianza derrota algunas partes de SSL y lo hace vulnerable a los ataques de hombre en el medio. Prefiera la Opción # 1 o, mejor aún, haga que el servidor use un certificado "real" firmado por una CA reconocida.

Seguí este problema a un proveedor de certificados que no es parte de los hosts de confianza JVM predeterminados a partir de JDK 8u74. El proveedor es www.identrust.com , pero ese no era el dominio al que intentaba conectarme. Ese dominio había obtenido su certificado de este proveedor. Consulte ¿La cobertura de raíz cruzada confiará en la lista predeterminada en JDK / JRE? - Lea un par de entradas. Consulte también Qué navegadores y sistemas operativos admiten Let's Encrypt .

Entonces, para conectarme al dominio que me interesaba, que tenía un certificado emitido identrust.com, hice los siguientes pasos. Básicamente, tenía que obtener el DST Root CA X3certificado identrust.com ( ) para que JVM confiara en él. Pude hacerlo usando Apache HttpComponents 4.5 así:

1: Obtenga el certificado de confianza en las Instrucciones de descarga de la cadena de certificados . Haga clic en el enlace DST Root CA X3 .

2: Guarde la cadena en un archivo llamado "DST Root CA X3.pem". Asegúrese de agregar las líneas "----- BEGIN CERTIFICATE -----" y "----- END CERTIFICATE -----" en el archivo al principio y al final.

3: Cree un archivo de almacén de claves de Java, cacerts.jks con el siguiente comando:

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

4: Copie el almacén de claves cacerts.jks resultante en el directorio de recursos de su aplicación java / (maven).

5: Use el siguiente código para cargar este archivo y adjuntarlo al Apache 4.5 HttpClient. Esto resolverá el problema para todos los dominios que tienen certificados emitidos por indetrust.comutil oracle que incluye el certificado en el almacén de claves predeterminado de 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();

Cuando el proyecto se construye, los cacerts.jks se copiarán en el classpath y se cargarán desde allí. En este momento, no probé con otros sitios ssl, pero si el código anterior "encadena" en este certificado, también funcionarán, pero de nuevo, no lo sé.

Referencia: contexto SSL personalizado y ¿Cómo acepto un certificado autofirmado con una conexión HttpsURLConnection de Java?

Apache HttpClient 4.5 admite la aceptación de certificados autofirmados:

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

Esto construye una fábrica de sockets SSL que utilizará TrustSelfSignedStrategy, la registra con un administrador de conexión personalizado y luego realiza un HTTP GET utilizando ese administrador de conexión.

Estoy de acuerdo con aquellos que cantan "no hagas esto en producción", sin embargo, hay casos de uso para aceptar certificados autofirmados fuera de producción; los usamos en pruebas de integración automatizadas, por lo que estamos usando SSL (como en producción) incluso cuando no se ejecuta en el hardware de producción.

En lugar de configurar la fábrica de sockets predeterminada (que es IMO es algo malo), esto solo afectará la conexión actual en lugar de cada conexión SSL que intente abrir:

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

Hay una mejor alternativa para confiar en todos los certificados: TrustStorecree uno que confíe específicamente en un certificado determinado y úselo para crear uno SSLContextdesde el cual SSLSocketFactoryconfigurar el HttpsURLConnection. Aquí está el código completo:

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

Alternativamente, puede cargar KeyStoredirectamente desde un archivo o recuperar el Certificado X.509 de cualquier fuente confiable.

Tenga en cuenta que con este código, los certificados cacertsno se utilizarán. Este particular HttpsURLConnectionsolo confiará en este certificado específico.

Confíe en todos los certificados SSL: - Puede omitir SSL si desea realizar una prueba en el servidor de prueba. Pero no use este código para la producción.

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) { 
    }
}

}

Llame a esta función en la función onCreate () en Actividad o en su Clase de aplicación.

NukeSSLCerts.nuke();

Esto se puede usar para Volley en Android.

La respuesta aceptada está bien, pero me gustaría agregar algo a esto ya que estaba usando IntelliJ en Mac y no pude hacerlo funcionar usando el JAVA_HOME variable de ruta.

Resulta que Java Home era diferente al ejecutar la aplicación desde IntelliJ.

Para averiguar exactamente dónde está, simplemente puede hacer System.getProperty("java.home")lo que leen los certificados de confianza.

Si 'ellos' están utilizando un certificado autofirmado, ellos deben seguir los pasos necesarios para que su servidor sea utilizable. Específicamente, eso significa proporcionarle su certificado fuera de línea de manera confiable. Así que haz que hagan eso. Luego lo importa a su almacén de confianza utilizando la herramienta de claves como se describe en la Guía de referencia de JSSE. Ni siquiera pienses en el inseguro TrustManager publicado aquí.

EDITAR Para el beneficio de los diecisiete (!) Votantes negativos, y numerosos comentaristas a continuación, que claramente no han leído lo que he escrito aquí, esto no es una jeremiad contra los certificados autofirmados. No hay nada de malo con los certificados autofirmados cuando se implementan correctamente. Pero, la forma correcta de implementarlos es que el certificado se entregue de forma segura a través de un proceso fuera de línea, en lugar de hacerlo a través del canal no autenticado que se utilizarán para autenticar. ¿Seguramente esto es obvio? Ciertamente es obvio para todas las organizaciones conscientes de la seguridad para las que he trabajado, desde bancos con miles de sucursales hasta mis propias empresas. La 'solución' basada en el código del lado del cliente de confiar en todosLos certificados, incluidos los certificados autofirmados firmados por absolutamente cualquier persona o cualquier organismo arbitrario que se establezca como CA, ipso facto no es seguro. Es solo jugar a la seguridad. No tiene sentido. Está teniendo una conversación privada, a prueba de manipulaciones, a prueba de respuestas, a prueba de inyecciones con ... alguien. Cualquiera. Un hombre en el medio. Un imitador Cualquiera. También puede usar texto sin formato.

Esta no es una solución al problema completo, pero Oracle tiene una buena documentación detallada sobre cómo usar esta herramienta clave. Esto explica cómo

1. use keytool.
2. generar certs / certs autofirmados usando keytool.
3. importar certificados generados a clientes java.

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

En lugar de usar keytool como lo sugiere el comentario principal, en RHEL puede usar update-ca-trust a partir de las versiones más recientes de RHEL 6. Deberá tener el certificado en formato pem. Luego

trust anchor <cert.pem>

Edite /etc/pki/ca-trust/source/cert.p11-kit y cambie "categoría de certificado: otra entrada" a "categoría de certificado: autoridad". (O use sed para hacer esto en un script). Luego, haga

update-ca-trust

Un par de advertencias:

• No pude encontrar "confianza" en mi servidor RHEL 6 y mmm no ofreció instalarlo. Terminé usándolo en un servidor RHEL 7 y copiando el archivo .p11-kit.
• Para que esto funcione para usted, es posible que deba hacer update-ca-trust enable . Esto reemplazará / etc / pki / java / cacerts con un enlace simbólico que apunta a / etc / pki / ca-trust / extraído / java / cacerts. (Por lo tanto, es posible que desee hacer una copia de seguridad del primero primero).
• Si su cliente java usa cacerts almacenados en alguna otra ubicación, querrá reemplazarlo manualmente con un enlace simbólico a / etc / pki / ca-trust / extraído / java / cacerts, o reemplazarlo con ese archivo.

Tuve el problema de que estaba pasando una URL a una biblioteca que estaba llamando url.openConnection();Adapte la respuesta de jon-daniel,

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
        // /programming/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;
    }

}

Con esta clase, es posible crear una nueva URL con:

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

Esto tiene la ventaja de que está localizado y no reemplaza el valor predeterminado URL.openConnection.