Comment gérer des certificats SSL non valides avec Apache HttpClient?
Je sais, il y a beaucoup de questions différentes et beaucoup de réponses sur ce problème ... Mais je ne comprends pas ...
J'ai: ubuntu-9.10-desktop-AMD64 + NetBeans6.7.1 installé "tel quel" depuis off. rep . J'ai besoin de me connecter à un site via HTTPS. Pour cela, j'utilise le HttpClient d'Apache.
De tutoriel je lis:
"Une fois que JSSE est correctement installé, la communication HTTP sécurisée sur SSL doit être la
simple comme une simple communication HTTP. "Et quelques exemples:
HttpClient httpclient = new HttpClient();
GetMethod httpget = new GetMethod("https://www.verisign.com/");
try {
httpclient.executeMethod(httpget);
System.out.println(httpget.getStatusLine());
} finally {
httpget.releaseConnection();
}
A présent, j'écris ceci:
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();
}
En conséquence, j'ai un ensemble d'erreurs:
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
Que dois-je faire pour créer la connexion SSL la plus simple? (Probablement sans KeyManager et Trust Manager, etc.
https://mms.nw.ru utilise un certificat auto-signé qui, de toute évidence, ne figure pas dans l'ensemble par défaut de gestionnaires de confiance.
Vous aurez besoin de l'un des éléments suivants:
Configurez le contexte SSLC avec un TrustManager qui accepte tout certificat (voir ci-dessous).
Configurez le SSLContext avec un magasin de clés de confiance approprié incluant votre certificat.
Ajoutez le certificat pour ce site au magasin de clés de confiance Java par défaut.
Voici un exemple de programme qui crée un contexte SSL (généralement sans valeur) qui accepte n’importe quel certificat:
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;
}
}
}
https://mms.nw.ru probablement utilise un certificat non délivré par une autorité de certification. Par conséquent, vous devez ajouter le certificat à votre magasin de clés Java approuvé comme expliqué dans impossible de trouver le chemin de certification valide de la cible demandée :
Lorsque vous travaillez sur un client qui fonctionne avec un serveur compatible SSL en cours d'exécution dans protocole https, vous pourriez obtenir une erreur 'incapable de trouver une certification valide chemin vers la cible demandée 'si le le certificat de serveur n'est pas émis par autorité de certification, mais un individu signé ou émis par un CMS privé.
Ne paniquez pas. Tout ce que vous devez faire est de ajoutez le certificat de serveur à votre Magasin de clés Java approuvé si votre client est écrit en Java. Tu pourrais être se demandant comment, comme si vous ne pouvez pas accéder la machine sur laquelle se trouve le serveur installée. Il y a un programme simple peut vous aider. Veuillez télécharger le fichier Java programme et courir
% Java InstallCert _web_site_hostname_Ce programme a ouvert une connexion avec l'hôte spécifié et a démarré un protocole SSL poignée de main. Il imprimait l'exception trace de pile de l'erreur qui s'est produite et vous montre les certificats utilisés par le serveur. Maintenant, il vous invite à ajouter le certificat à votre KeyStore de confiance.
Si vous avez changé d'avis, entrez 'q'. Si vous voulez vraiment ajouter le certificat, entrez '1' ou autre numéros pour ajouter d'autres certificats, même un certificat de CA, mais vous habituellement ne veux pas faire ça. Une fois que tu as fait votre choix, le programme sera afficher le certificat complet et puis l'a ajouté à un KeyStore Java nommé 'jssecacerts' dans le courant annuaire.
Pour l'utiliser dans votre programme, soit configurer JSSE pour qu’elle l’utilise comme sa confiance stockez-le ou copiez-le dans votre Répertoire $ Java_HOME/jre/lib/security . Si vous souhaitez que toutes les applications Java soient reconnaître le certificat comme étant de confiance et pas seulement JSSE, vous pourriez aussi écraser le fichier cacerts dans ce annuaire.
Après tout cela, JSSE sera capable de compléter une poignée de main avec l'hôte, que vous pouvez vérifier en exécutant le fichier programme à nouveau.
Pour obtenir plus de détails, vous pouvez consulter Leeland's blog Plus jamais 'incapable de trouver chemin de certification valide à demandé cible'
Outre la réponse correcte de Pascal Thivent, vous pouvez également enregistrer le certificat depuis Firefox (Afficher le certificat -> Détails -> exporter) ou openssl s_client et l'importer dans le magasin de données de confiance.
Vous ne devriez le faire que si vous avez un moyen de vérifier ce certificat. Si vous ne le faites pas, faites-le lors de votre première connexion, cela vous donnera au moins une erreur si le certificat change de manière inattendue lors des connexions suivantes.
Pour l'importer dans un Trust Store, utilisez:
keytool -importcert -keystore truststore.jks -file servercert.pem
Par défaut, le magasin de clés de confiance par défaut devrait être lib/security/cacerts et son mot de passe, changeit, voir JSSE Reference guide pour plus de détails.
Si vous ne souhaitez pas autoriser ce certificat globalement, mais uniquement pour ces connexions, il est possible de créer une variable SSLContext pour ce certificat:
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);
Ensuite, vous devez le configurer pour Apache HTTP Client 3.x en en implémentant un si SecureProtocolSocketFactory pour utiliser cette SSLContext. (Il y a des exemples ici ).
Apache HTTP Client 4.x (à l'exception de la version la plus ancienne) prend directement en charge le passage d'une SSLContext.
De 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();
}
Où l'exemple de MySSLSocketFactory peut être trouvé ici . Il référence une TrustManager, que vous pouvez modifier pour faire confiance à tout (même si vous devez en tenir compte!)
La manière Apache HttpClient 4.5:
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();
NOTE: org.Apache.http.conn.ssl.SSLContextBuilder est deprecated et org.Apache.http.ssl.SSLContextBuilder est le nouveau (notez que conn manque dans le nom du paquet de ce dernier).
Une fois que vous avez un magasin de certificats Java (en utilisant la classe great InstallCert créée ci-dessus), vous pouvez demander à Java de l’utiliser en passant le paramètre "javax.net.ssl.trustStore" au démarrage de Java.
Ex:
Java -Djavax.net.ssl.trustStore=/path/to/jssecacerts MyClassName
Pour Apache HttpClient 4.5+ et 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();
Mais si votre HttpClient utilise un ConnectionManager pour rechercher une connexion, par ex. comme ça:
PoolingHttpClientConnectionManager connectionManager = new
PoolingHttpClientConnectionManager();
CloseableHttpClient client = HttpClients.custom()
.setConnectionManager(connectionManager)
.build();
La HttpClients.custom().setSSLSocketFactory(sslConnectionSocketFactory) n'a aucun effet , le problème n'est pas résolu.
Parce que HttpClient utilise le connectionManager spécifié pour rechercher une connexion et que le connectionManager spécifié n'a pas enregistré notre SSLConnectionSocketFactory personnalisée Pour résoudre ce problème, vous devez enregistrer le fichier SSLConnectionSocketFactory personnalisé dans le gestionnaire de connexion. Le code correct devrait ressembler à ceci:
PoolingHttpClientConnectionManager connectionManager = new
PoolingHttpClientConnectionManager(RegistryBuilder.
<ConnectionSocketFactory>create()
.register("http",PlainConnectionSocketFactory.getSocketFactory())
.register("https", sslConnectionSocketFactory).build());
CloseableHttpClient client = HttpClients.custom()
.setConnectionManager(connectionManager)
.build();
Un autre problème que vous pouvez rencontrer avec les certificats de test auto-signés est le suivant:
Java.io.IOException: nom d'hôte HTTPS incorrect: doit être ...
Cette erreur se produit lorsque vous essayez d'accéder à une URL HTTPS. Vous avez peut-être déjà installé le certificat de serveur dans le fichier de clés de votre JRE. Mais cette erreur signifie que le nom du certificat de serveur ne correspond pas au nom de domaine réel du serveur mentionné dans l'URL. Cela se produit normalement lorsque vous utilisez un certificat non émis par une autorité de certification.
Cet exemple montre comment écrire un HttpsURLConnection DefaultHostnameVerifier qui ignore le nom du serveur de certificats:
Pour ajouter facilement des hôtes en qui vous avez confiance au moment de l'exécution sans supprimer tous les contrôles, essayez le code ici: http://code.google.com/p/self-signed-cert-trust-manager/ .
EasySSLProtocolSocketFactory me posait des problèmes, j'ai donc mis en œuvre mon propre ProtocolSocketFactory.
D'abord, vous devez l'enregistrer:
Protocol.registerProtocol("https", new Protocol("https", new TrustAllSSLSocketFactory(), 443));
HttpClient client = new HttpClient();
...
Puis implémentez 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());
}
}
}
Note: Ceci est avec HttpClient 3.1 et Java 8
suivez les instructions données ci-dessous pour Java 1.7, pour créer un certificat SSL à l'aide du fichier programme InstallCert.Java.
https://github.com/escline/InstallCert
vous devez redémarrer le Tomcat
J'utilise httpclient 3.1.X, et cela fonctionne pour moi
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;
}
}
vouloir coller la réponse ici:
dans Apache HttpClient 4.5.5
Comment gérer un certificat SSL non valide avec le client Apache 4.5.5?
HttpClient httpClient = HttpClients
.custom()
.setSSLContext(new SSLContextBuilder().loadTrustMaterial(null, TrustAllStrategy.INSTANCE).build())
.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
.build();
L'utilisation de InstallCert pour générer le fichier jssecacerts et faire -Djavax.net.ssl.trustStore=/path/to/jssecacerts a fonctionné à merveille.
Pour HttpClient, nous pouvons faire ceci:
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()
J'ai été confronté au même problème, tout d'un coup, toutes mes importations ont disparu. J'ai essayé de supprimer tout le contenu de mon dossier .m2. Et essayer de tout réimporter, mais toujours rien ne fonctionnait. Enfin, j’ai ouvert le site Web pour lequel le IDE se plaignait de ne pas pouvoir le télécharger dans mon navigateur. Et vu le certificat qu'il utilisait, et vu dans mon
$ keytool -v -list PATH_TO_Java_KEYSTORE
Le chemin d'accès à mon magasin de clés était /Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/jre/lib/security/cacerts
ce certificat particulier n'était pas là.
Il vous suffit donc de replacer le certificat dans le fichier de clés Java JVM. Cela peut être fait en utilisant la commande ci-dessous.
$ keytool -import -alias ANY_NAME_YOU_WANT_TO_GIVE -file PATH_TO_YOUR_CERTIFICATE -keystore PATH_OF_Java_KEYSTORE
S'il vous demande un mot de passe, essayez le mot de passe par défaut 'changeit' Si vous obtenez une erreur d'autorisation lors de l'exécution de la commande ci-dessus. Dans Windows, ouvrez-le en mode administration. Sous Mac et Unix, utilisez Sudo.
Après avoir ajouté la clé avec succès, vous pouvez la visualiser en utilisant:
$ keytool -v -list /Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/jre/lib/security/cacerts
Vous pouvez voir seulement le SHA-1 en utilisant la commande
$ keytool -list /Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/jre/lib/security/cacerts
Ce link explique votre besoin étape par étape. Si vous n'êtes pas vraiment intéressé par quel certificat vous pouvez poursuivre le processus décrit dans le lien ci-dessous.
Remarque Vous voudrez peut-être vérifier ce que vous faites car il s'agit d'une opération non sécurisée.
Utilisé ce qui suit avec DefaultTrustManager et cela a fonctionné dans httpclient comme un charme. Merci beaucoup!! @ Kevin et tous les autres contributeurs
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();