Como lidar com certificados SSL inválidos com Apache HttpClient? [duplicado]

StackOverflow https://stackoverflow.com/questions/1828775

  •  11-09-2019
  •  | 
  •  

Pergunta

Esta questão já tem uma resposta aqui:

Eu sei, há muitas perguntas diferentes e tantas respostas sobre este problema ... Mas eu não consigo entender ...

Eu tenho: ubuntu-9.10-desktop-amd64 + NetBeans6.7.1 instalada "tal como está" de fora. rep. Eu preciso conectar a algum site sobre o HTTPS. Por isso eu uso do Apache HttpClient.

De tutorial eu li:

"Depois de ter JSSE instalado corretamente, a comunicação HTTP seguro sobre SSL deve ser tão
simples como a comunicação HTTP simples "E alguns exemplos:. 

HttpClient httpclient = new HttpClient();
GetMethod httpget = new GetMethod("https://www.verisign.com/"); 
try { 
  httpclient.executeMethod(httpget);
  System.out.println(httpget.getStatusLine());
} finally {
  httpget.releaseConnection();
}

Até agora, eu escrevo isto: 

HttpClient client = new HttpClient();

HttpMethod get = new GetMethod("https://mms.nw.ru");
//get.setDoAuthentication(true);

try {
    int status = client.executeMethod(get);
    System.out.println(status);

    BufferedInputStream is = new BufferedInputStream(get.getResponseBodyAsStream());
    int r=0;byte[] buf = new byte[10];
    while((r = is.read(buf)) > 0) {
        System.out.write(buf,0,r);
    }

} catch(Exception ex) {
    ex.printStackTrace();
}

Como resultado, eu tenho um conjunto de erros: 

javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
        at sun.security.ssl.Alerts.getSSLException(Alerts.java:192)
        at sun.security.ssl.SSLSocketImpl.fatal(SSLSocketImpl.java:1627)
        at sun.security.ssl.Handshaker.fatalSE(Handshaker.java:204)
        at sun.security.ssl.Handshaker.fatalSE(Handshaker.java:198)
        at sun.security.ssl.ClientHandshaker.serverCertificate(ClientHandshaker.java:994)
        at sun.security.ssl.ClientHandshaker.processMessage(ClientHandshaker.java:142)
        at sun.security.ssl.Handshaker.processLoop(Handshaker.java:533)
        at sun.security.ssl.Handshaker.process_record(Handshaker.java:471)
        at sun.security.ssl.SSLSocketImpl.readRecord(SSLSocketImpl.java:904)
        at sun.security.ssl.SSLSocketImpl.performInitialHandshake(SSLSocketImpl.java:1132)
        at sun.security.ssl.SSLSocketImpl.writeRecord(SSLSocketImpl.java:643)
        at sun.security.ssl.AppOutputStream.write(AppOutputStream.java:78)
        at java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)
        at java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)
        at org.apache.commons.httpclient.HttpConnection.flushRequestOutputStream(HttpConnection.java:828)
        at org.apache.commons.httpclient.HttpMethodBase.writeRequest(HttpMethodBase.java:2116)
        at org.apache.commons.httpclient.HttpMethodBase.execute(HttpMethodBase.java:1096)
        at org.apache.commons.httpclient.HttpMethodDirector.executeWithRetry(HttpMethodDirector.java:398)
        at org.apache.commons.httpclient.HttpMethodDirector.executeMethod(HttpMethodDirector.java:171)
        at org.apache.commons.httpclient.HttpClient.executeMethod(HttpClient.java:397)
        at org.apache.commons.httpclient.HttpClient.executeMethod(HttpClient.java:323)
        at simpleapachehttp.Main.main(Main.java:41)
Caused by: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
        at sun.security.validator.PKIXValidator.doBuild(PKIXValidator.java:302)
        at sun.security.validator.PKIXValidator.engineValidate(PKIXValidator.java:205)
        at sun.security.validator.Validator.validate(Validator.java:235)
        at sun.security.ssl.X509TrustManagerImpl.validate(X509TrustManagerImpl.java:147)
        at sun.security.ssl.X509TrustManagerImpl.checkServerTrusted(X509TrustManagerImpl.java:230)
        at sun.security.ssl.X509TrustManagerImpl.checkServerTrusted(X509TrustManagerImpl.java:270)
        at sun.security.ssl.ClientHandshaker.serverCertificate(ClientHandshaker.java:973)
        ... 17 more
Caused by: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
        at sun.security.provider.certpath.SunCertPathBuilder.engineBuild(SunCertPathBuilder.java:191)
        at java.security.cert.CertPathBuilder.build(CertPathBuilder.java:255)
        at sun.security.validator.PKIXValidator.doBuild(PKIXValidator.java:297)
        ... 23 more

O que eu tenho que fazer para criar mais simples conexão SSL? (Provavelmente sem KeyManager e Confiança gerente etc. enquanto.)

Foi útil?

Solução

https://mms.nw.ru usa um certificado auto-assinado que, obviamente, não está contido em o conjunto padrão de gestores de confiança.

Você vai precisar de uma das seguintes opções:

  • Configurar o SSLContext com um TrustManager que aceita qualquer cert (veja abaixo)

  • Configurar o SSLContext com uma loja de confiança apropriado que inclui a sua cert

  • Adicione o certificado para esse site para a loja de java padrão confiança.

Aqui está um programa de exemplo que cria um (a maioria inúteis) Contexto SSL que aceita qualquer cert: 

import java.net.URL;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.KeyManager;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

public class SSLTest {

    public static void main(String [] args) throws Exception {
        // configure the SSLContext with a TrustManager
        SSLContext ctx = SSLContext.getInstance("TLS");
        ctx.init(new KeyManager[0], new TrustManager[] {new DefaultTrustManager()}, new SecureRandom());
        SSLContext.setDefault(ctx);

        URL url = new URL("https://mms.nw.ru");
        HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
        conn.setHostnameVerifier(new HostnameVerifier() {
            @Override
            public boolean verify(String arg0, SSLSession arg1) {
                return true;
            }
        });
        System.out.println(conn.getResponseCode());
        conn.disconnect();
    }

    private static class DefaultTrustManager implements X509TrustManager {

        @Override
        public void checkClientTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {}

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

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

Outras dicas

https://mms.nw.ru usos prováveis ??um certificado não emitido por uma autoridade de certificação. Conseqüentemente, você precisa adicionar o certificado para o armazenamento de chaves Java confiável como explicado em incapaz de encontrar uma certificação válida caminho para solicitado alvo:

Ao trabalhar em um cliente que obras com um SSL habilitado servidor em execução no o protocolo https, você poderia começar de erro 'Incapaz de encontrar uma certificação válida caminho para destino solicitado' se o certificado do servidor não é emitido por autoridade de certificação, mas um auto assinado ou emitido por um CMS privado.

Do not panic. Tudo que você precisa fazer é adicione o certificado de servidor para o seu armazenamento de chaves Java confiável se o seu cliente é escrito em Java. Você deve ser perguntando como como se você não pode acessar a máquina onde o servidor está instalado. Não é um programa simples pode ajudá-lo. Faça o download do Java programa e executar 

% java InstallCert _web_site_hostname_

Este programa abriu uma conexão com o host especificado e começou uma SSL aperto de mão. É impresso excepção rastreamento de pilha do erro que ocorreu e mostra-lhe os certificados usados ??pelo o servidor. Agora ele solicitará que você adicione o certificado para o KeyStore confiável.

Se você mudou sua mente, insira 'Q'. Se você realmente deseja adicionar o certificado, digite '1', ou outra números para adicionar outros certificados, Mesmo um certificado da CA, mas você normalmente Não quero fazer isso. Uma vez que você tenha fez a sua escolha, o programa irá exibir o certificado completo e em seguida, adicionou-o a um Java KeyStore chamado 'jssecacerts' na atual diretório.

Para usá-lo em seu programa, quer configurar JSSE para usá-lo como a sua confiança armazenar ou copiá-lo para o seu $ JAVA_HOME / jre / lib / segurança. Se você quiser que todos os aplicativos Java reconhecer o certificado como confiável e não apenas JSSE, você poderia também substituir o arquivo cacerts no que diretório.

Depois de tudo isso, JSSE será capaz de completar um aperto de mão com o anfitrião, que você pode verificar executando o programa novamente.

Para obter mais detalhes, você pode conferir O blog de Leeland não mais 'incapaz de encontrar caminho de certificação válido para solicitado target '

Além de resposta correcta de Pascal Thivent, outra maneira é salvar o certificado do Firefox (Ver certificado -> Detalhes -> exportação). Ou openssl s_client e importá-lo para o armazenamento confiável

Você só deve fazer isso se você tem uma maneira de verificar se certificado. Falhando isso, fazê-lo a primeira vez que se conectar, ele pelo menos lhe dará um erro se o certificado muda inesperadamente em conexões subseqüentes.

Para importá-lo em uma loja de confiança, use: 

keytool -importcert -keystore truststore.jks -file servercert.pem

Por padrão, o armazenamento confiável padrão deve ser lib/security/cacerts e sua senha deve ser changeit, consulte JSSE guia de Referência para mais detalhes.

Se você não quiser permitir que o certificado globalmente, mas apenas para essas conexões, é possível criar um SSLContext para isso: 

TrustManagerFactory tmf = TrustManagerFactory
    .getInstance(TrustManagerFactory.getDefaultAlgorithm());
KeyStore ks = KeyStore.getInstance("JKS");
FileInputStream fis = new FileInputStream("/.../truststore.jks");
ks.load(fis, null);
// or ks.load(fis, "thepassword".toCharArray());
fis.close();

tmf.init(ks);

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

Em seguida, você precisará configurá-lo para 3.x Apache HTTP cliente através da implementação de um, se sua SecureProtocolSocketFactory para usar esta SSLContext. (Há exemplos aqui ).

Apache HTTP 4.x cliente (além da versão mais antiga) tem suporte direto para passar um SSLContext.

O Apache HttpClient 4,5 maneira: 

org.apache.http.ssl.SSLContextBuilder sslContextBuilder = SSLContextBuilder.create();
sslContextBuilder.loadTrustMaterial(new org.apache.http.conn.ssl.TrustSelfSignedStrategy());
SSLContext sslContext = sslContextBuilder.build();
org.apache.http.conn.ssl.SSLConnectionSocketFactory sslSocketFactory =
        new SSLConnectionSocketFactory(sslContext, new org.apache.http.conn.ssl.DefaultHostnameVerifier());

HttpClientBuilder httpClientBuilder = HttpClients.custom().setSSLSocketFactory(sslSocketFactory);
httpClient = httpClientBuilder.build();

NOTA:. org.apache.http.conn.ssl.SSLContextBuilder é deprecated e org.apache.http.ssl.SSLContextBuilder é o novo (aviso conn faltando nome do pacote deste último)

A partir http://hc.apache.org/httpclient-3.x/sslguide.html : 

Protocol.registerProtocol("https", 
new Protocol("https", new MySSLSocketFactory(), 443));
HttpClient httpclient = new HttpClient();
GetMethod httpget = new GetMethod("https://www.whatever.com/");
try {
  httpclient.executeMethod(httpget);
      System.out.println(httpget.getStatusLine());
} finally {
      httpget.releaseConnection();
}

Onde exemplo MySSLSocketFactory podem ser encontrados aqui . Ele faz referência a um TrustManager, que você pode modificar para confiar em tudo (embora você deve considerar isso!)

Para o Apache HttpClient 4.5+ & Java8: 

SSLContext sslContext = SSLContexts.custom()
        .loadTrustMaterial((chain, authType) -> true).build();

SSLConnectionSocketFactory sslConnectionSocketFactory =
        new SSLConnectionSocketFactory(sslContext, new String[]
        {"SSLv2Hello", "SSLv3", "TLSv1","TLSv1.1", "TLSv1.2" }, null,
        NoopHostnameVerifier.INSTANCE);
CloseableHttpClient client = HttpClients.custom()
        .setSSLSocketFactory(sslConnectionSocketFactory)
        .build();

Mas se o seu HttpClient usar um ConnectionManager para a procura de conexão, por exemplo, assim: 

 PoolingHttpClientConnectionManager connectionManager = new 
         PoolingHttpClientConnectionManager();

 CloseableHttpClient client = HttpClients.custom()
            .setConnectionManager(connectionManager)
            .build();

O HttpClients.custom().setSSLSocketFactory(sslConnectionSocketFactory) não tem efeito , o problema não é resolvido.

Porque que o HttpClient usar o ConnectionManager especificado para a procura de conexão eo ConnectionManager especificado não registrar o nosso SSLConnectionSocketFactory personalizado. Para resolver isso, deve registrar o The SSLConnectionSocketFactory personalizado na ConnectionManager. O código correto deve assim: 

PoolingHttpClientConnectionManager connectionManager = new 
    PoolingHttpClientConnectionManager(RegistryBuilder.
                <ConnectionSocketFactory>create()
      .register("http",PlainConnectionSocketFactory.getSocketFactory())
      .register("https", sslConnectionSocketFactory).build());

CloseableHttpClient client = HttpClients.custom()
            .setConnectionManager(connectionManager)
            .build();

Depois de ter um Cert loja Java (usando o grande InstallCert classe criada acima), você pode obter java para usá-lo, passando o param "javax.net.ssl.trustStore" no java comece.

Ex: 

java -Djavax.net.ssl.trustStore=/path/to/jssecacerts MyClassName

Outra questão que você pode executar em com certificados de teste auto-assinados é esta:

java.io.IOException: HTTPS hostname errado: deve ser ...

Este erro ocorre quando você está tentando acessar um HTTPS URL. Você já deve ter instalado o certificado de servidor para armazenamento de chaves do seu JRE. Mas isso significa erro que o nome do certificado do servidor não corresponde com o nome de domínio real do servidor que é mencionado na URL. Isso normalmente acontece quando você estiver usando um não CA certificado emitido.

Este exemplo mostra como escrever um HttpsURLConnection DefaultHostnameVerifier que ignorar o nome do servidor certificados:

http://www.java-samples.com/showtutorial.php? tutorialid = 211

deseja colar a resposta aqui:

no Apache HttpClient 4.5.5

Como lidar com SSL inválido certificado com o cliente Apache 4.5.5? 

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

Para uma maneira de adicionar facilmente anfitriões você confia em tempo de execução sem jogar fora todas as verificações, tente o código aqui: http://code.google.com/p/self-signed-cert-trust-manager/ .

EasySSLProtocolSocketFactory estava me dando problemas então acabei implementando meu próprio ProtocolSocketFactory.

Primeiro você precisa registrá-lo: 

Protocol.registerProtocol("https", new Protocol("https", new TrustAllSSLSocketFactory(), 443));

HttpClient client = new HttpClient();
...

Em seguida, implemente ProtocolSocketFactory: 

class TrustAllSSLSocketFactory implements ProtocolSocketFactory {

    public static final TrustManager[] TRUST_ALL_CERTS = new TrustManager[]{
        new X509TrustManager() {
            public void checkClientTrusted(final X509Certificate[] certs, final String authType) {

            }

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

            }

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

    private TrustManager[] getTrustManager() {
        return TRUST_ALL_CERTS;
    }

    public Socket createSocket(final String host, final int port, final InetAddress clientHost,
                               final int clientPort) throws IOException {
        return getSocketFactory().createSocket(host, port, clientHost, clientPort);
    }

    @Override
    public Socket createSocket(final String host, final int port, final InetAddress localAddress,
                               final int localPort, final HttpConnectionParams params) throws IOException {
        return createSocket(host, port);
    }

    public Socket createSocket(final String host, final int port) throws IOException {
        return getSocketFactory().createSocket(host, port);
    }

    private SocketFactory getSocketFactory() throws UnknownHostException {
        TrustManager[] trustAllCerts = getTrustManager();

        try {
            SSLContext context = SSLContext.getInstance("SSL");
            context.init(null, trustAllCerts, new SecureRandom());

            final SSLSocketFactory socketFactory = context.getSocketFactory();
            HttpsURLConnection.setDefaultSSLSocketFactory(socketFactory);
            return socketFactory;
        } catch (NoSuchAlgorithmException | KeyManagementException exception) {
            throw new UnknownHostException(exception.getMessage());
        }
    }
}

Nota: Este é com HttpClient 3.1 e Java 8

Este servidor ligação explica a necessidade que você tem passo a passo. Se você não está realmente em causa, que certificado você pode prosseguir com o processo no link abaixo.

Nota Você pode querer verificar o dobro do que você está fazendo uma vez que, esta é uma operação insegura.

Usando o InstallCert para gerar o arquivo jssecacerts e fazer -Djavax.net.ssl.trustStore=/path/to/jssecacerts trabalhou grande.

Eu estou useing httpclient 3.1.X, e isso funciona para mim 

        try {
        SSLContext sslContext = SSLContext.getInstance("TLS");
        TrustManager trustManager = new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
            }

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

            }

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        };
        sslContext.init(null, new TrustManager[]{trustManager}, null);
        SslContextSecureProtocolSocketFactory socketFactory = new SslContextSecureProtocolSocketFactory(sslContext,false);
        Protocol.registerProtocol("https", new Protocol("https", (ProtocolSocketFactory) socketFactory, 443));//同样会影响到HttpUtils
    } catch (Throwable e) {
        e.printStackTrace();

} 

public class SslContextSecureProtocolSocketFactory implements      SecureProtocolSocketFactory {

private SSLContext sslContext;
private boolean verifyHostname;

public SslContextSecureProtocolSocketFactory(SSLContext sslContext, boolean verifyHostname) {
    this.verifyHostname = true;
    this.sslContext = sslContext;
    this.verifyHostname = verifyHostname;
}

public SslContextSecureProtocolSocketFactory(SSLContext sslContext) {
    this(sslContext, true);
}

public SslContextSecureProtocolSocketFactory(boolean verifyHostname) {
    this((SSLContext)null, verifyHostname);
}

public SslContextSecureProtocolSocketFactory() {
    this((SSLContext)null, true);
}

public synchronized void setHostnameVerification(boolean verifyHostname) {
    this.verifyHostname = verifyHostname;
}

public synchronized boolean getHostnameVerification() {
    return this.verifyHostname;
}

public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort) throws IOException, UnknownHostException {
    SSLSocketFactory sf = this.getSslSocketFactory();
    SSLSocket sslSocket = (SSLSocket)sf.createSocket(host, port, clientHost, clientPort);
    this.verifyHostname(sslSocket);
    return sslSocket;
}

public Socket createSocket(String host, int port, InetAddress localAddress, int localPort, HttpConnectionParams params) throws IOException, UnknownHostException, ConnectTimeoutException {
    if(params == null) {
        throw new IllegalArgumentException("Parameters may not be null");
    } else {
        int timeout = params.getConnectionTimeout();
        Socket socket = null;
        SSLSocketFactory socketfactory = this.getSslSocketFactory();
        if(timeout == 0) {
            socket = socketfactory.createSocket(host, port, localAddress, localPort);
        } else {
            socket = socketfactory.createSocket();
            InetSocketAddress localaddr = new InetSocketAddress(localAddress, localPort);
            InetSocketAddress remoteaddr = new InetSocketAddress(host, port);
            socket.bind(localaddr);
            socket.connect(remoteaddr, timeout);
        }

        this.verifyHostname((SSLSocket)socket);
        return socket;
    }
}

public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
    SSLSocketFactory sf = this.getSslSocketFactory();
    SSLSocket sslSocket = (SSLSocket)sf.createSocket(host, port);
    this.verifyHostname(sslSocket);
    return sslSocket;
}

public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException {
    SSLSocketFactory sf = this.getSslSocketFactory();
    SSLSocket sslSocket = (SSLSocket)sf.createSocket(socket, host, port, autoClose);
    this.verifyHostname(sslSocket);
    return sslSocket;
}

private void verifyHostname(SSLSocket socket) throws SSLPeerUnverifiedException, UnknownHostException {
    synchronized(this) {
        if(!this.verifyHostname) {
            return;
        }
    }

    SSLSession session = socket.getSession();
    String hostname = session.getPeerHost();

    try {
        InetAddress.getByName(hostname);
    } catch (UnknownHostException var10) {
        throw new UnknownHostException("Could not resolve SSL sessions server hostname: " + hostname);
    }

    X509Certificate[] certs = (X509Certificate[])((X509Certificate[])session.getPeerCertificates());
    if(certs != null && certs.length != 0) {
        X500Principal subjectDN = certs[0].getSubjectX500Principal();
        List cns = this.getCNs(subjectDN);
        boolean foundHostName = false;
        Iterator i$ = cns.iterator();
        AntPathMatcher matcher  = new AntPathMatcher();
        while(i$.hasNext()) {
            String cn = (String)i$.next();
            if(matcher.match(cn.toLowerCase(),hostname.toLowerCase())) {
                foundHostName = true;
                break;
            }
        }

        if(!foundHostName) {
            throw new SSLPeerUnverifiedException("HTTPS hostname invalid: expected \'" + hostname + "\', received \'" + cns + "\'");
        }
    } else {
        throw new SSLPeerUnverifiedException("No server certificates found!");
    }
}

private List<String> getCNs(X500Principal subjectDN) {
    ArrayList cns = new ArrayList();
    StringTokenizer st = new StringTokenizer(subjectDN.getName(), ",");

    while(st.hasMoreTokens()) {
        String cnField = st.nextToken();
        if(cnField.startsWith("CN=")) {
            cns.add(cnField.substring(3));
        }
    }

    return cns;
}

protected SSLSocketFactory getSslSocketFactory() {
    SSLSocketFactory sslSocketFactory = null;
    synchronized(this) {
        if(this.sslContext != null) {
            sslSocketFactory = this.sslContext.getSocketFactory();
        }
    }

    if(sslSocketFactory == null) {
        sslSocketFactory = (SSLSocketFactory)SSLSocketFactory.getDefault();
    }

    return sslSocketFactory;
}

public synchronized void setSSLContext(SSLContext sslContext) {
    this.sslContext = sslContext;
}

}

Para HttpClient, podemos fazer isso: 

SSLContext ctx = SSLContext.getInstance("TLS");
        ctx.init(new KeyManager[0], new TrustManager[] {new DefaultTrustManager()}, new SecureRandom());
        SSLContext.setDefault(ctx);

        String uri = new StringBuilder("url").toString();

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

        HttpClient client = HttpClientBuilder.create().setSSLContext(ctx)
                .setSSLHostnameVerifier(hostnameVerifier).build()

siga as instruções dadas abaixo para Java 1.7, para criar um certificado SSL usando o arquivo de programa InstallCert.java.

https://github.com/escline/InstallCert

Você deve reiniciar o tomcat

utilizados os seguintes juntamente com DefaultTrustManager e funcionou em httpclient como charme. Graças a tonelada !! @ Kevin e todos os outros contribuinte 

    SSLContext ctx = null;
    SSLConnectionSocketFactory sslsf = null;
    try {

        ctx = SSLContext.getInstance("TLS");
        ctx.init(new KeyManager[0], new TrustManager[] {new DefaultTrustManager()}, new SecureRandom());
        SSLContext.setDefault(ctx);

        sslsf = new SSLConnectionSocketFactory(
                ctx,
                new String[] { "TLSv1" },
                null,
                SSLConnectionSocketFactory.getDefaultHostnameVerifier());

    } catch (Exception e) {
        e.printStackTrace();
    }

     CloseableHttpClient client = HttpClients.custom()
            .setSSLSocketFactory(sslsf)
            .build();

Aconteceu de eu enfrentar o mesmo problema, de repente todos os meus importações estavam faltando. Eu tentei apagar todo o conteúdo na minha pasta .m2. E tentando re-import tudo, mas nada ainda funcionava. Finalmente o que eu fiz foi aberto o site para o qual o IDE estava reclamando que não podia baixar no meu navegador. E viu o certificado que ele estava usando, e vi na minha 

$ keytool -v -list  PATH_TO_JAVA_KEYSTORE

Caminho para o meu armazenamento de chaves foi /Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/jre/lib/security/cacerts

que determinado certificado não estava lá.

Então tudo que você tem a fazer é colocar o certificado no JAVA JVM armazenamento de chaves novamente. Isso pode ser feito usando o comando abaixo. 

$ keytool -import -alias ANY_NAME_YOU_WANT_TO_GIVE -file PATH_TO_YOUR_CERTIFICATE -keystore PATH_OF_JAVA_KEYSTORE

Se ele pede senha, tente 'changeit' a senha padrão Se você receber erro de permissão ao executar o comando acima. Em janelas abri-lo no modo de administração. No Mac e Unix utilize sudo.

Depois de ter adicionado a chave com sucesso, Você pode vê-lo usando: 

$ keytool -v -list  /Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/jre/lib/security/cacerts

Você pode ver apenas o SHA-1 utilizando teh comando 

$ keytool -list  /Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/jre/lib/security/cacerts
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top