La désactivation de SSL de Validation de Certificat au Printemps RestTemplate

Je vais avoir deux Printemps en fonction des applications web A et B, sur deux machines différentes.

Je veux faire un https appel de web app Un pour web app B, cependant j'utilise un certificat auto-signé sur une Machine B. Donc ma demande HTTPS échoue.

Comment puis-je désactiver https certificat de validation lors de l'utilisation de RestTemplate au Printemps ? Je veux désactiver la validation parce que les deux web app A et B sont dans le réseau interne, mais le transfert de données doit se faire sur HTTPS

InformationsquelleAutor Prabhu R | 2010-11-01
  1. 28

    Ce que vous devez ajouter est une coutume HostnameVerifier classe contourne la vérification du certificat et renvoie true

    HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        });

    Ce doit être placé de manière appropriée dans votre code.

    InformationsquelleAutor Raghuram
  2. 46
    @Bean
public RestTemplate restTemplate() 
                throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
    TrustStrategy acceptingTrustStrategy = (X509Certificate[] chain, String authType) -> true;

    SSLContext sslContext = org.apache.http.ssl.SSLContexts.custom()
                    .loadTrustMaterial(null, acceptingTrustStrategy)
                    .build();

    SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext);

    CloseableHttpClient httpClient = HttpClients.custom()
                    .setSSLSocketFactory(csf)
                    .build();

    HttpComponentsClientHttpRequestFactory requestFactory =
                    new HttpComponentsClientHttpRequestFactory();

    requestFactory.setHttpClient(httpClient);
    RestTemplate restTemplate = new RestTemplate(requestFactory);
    return restTemplate;
 }
    InformationsquelleAutor DanieleDM
  3. 30

    Essentiellement deux choses que vous devez faire est d'utiliser un personnalisé TrustStrategy qui se fie à tous les certs, et également utiliser NoopHostnameVerifier() pour désactiver la vérification du nom d'hôte. Voici le code, avec toutes les importations: 

    import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.SSLContext;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;
public RestTemplate getRestTemplate() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
TrustStrategy acceptingTrustStrategy = new TrustStrategy() {
@Override
public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
return true;
}
};
SSLContext sslContext = org.apache.http.ssl.SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build();
SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext, new NoopHostnameVerifier());
CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(csf).build();
HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
requestFactory.setHttpClient(httpClient);
RestTemplate restTemplate = new RestTemplate(requestFactory);
return restTemplate;
}
    • TrustStrategy acceptingTrustStrategy = (X509Certificate[] x509Certificates, String s) ->true;
    • Merci, cela m'a sauvé la vie. Toutes les autres méthodes (ajout d'exportation .crt à java cacerts à l'aide de keytool, blog.codeleak.pl/2016/02/..., et environ 5~6 autres stackoverflow postes, y compris les réponses sur celui-ci) a échoué, a pris 7 heures de mon temps. Cette réponse était mon dernier espoir, merci.
    • Le NoopHostnameVerifier est très important de réponse à cette négligence. Un cas d'utilisation est à l'aide de votre public SSL cert par le biais de bouclage de localhost.
    • NoopHostnameVerifier n'est pas disponible dans httpclient-android:4.3.5.1, et si j'utilise httpclient:4.5.6, j'obtiens cette erreur: Pas de champ statique INSTANCE de type Lorg/apache/http/conn/ssl/AllowAllHostnameVerifier. Quelqu'un pourrait-il m'aider, s'il vous plaît?
    • Veuillez mentionner le client HTTP Apache nom de la bibliothèque et la version qui prend en charge cette solution, l'original de la question demande au REPOS du Ressort Modèle qui AFAICT ne veut pas automatiquement dans la bibliothèque, merci.
    InformationsquelleAutor rouble
  4. 7
    Add my response with cookie :
public static void main(String[] args) {
MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
params.add("username", testUser);
params.add("password", testPass);
NullHostnameVerifier verifier = new NullHostnameVerifier(); 
MySimpleClientHttpRequestFactory requestFactory = new MySimpleClientHttpRequestFactory(verifier , rememberMeCookie);
ResponseEntity<String> response = restTemplate.postForEntity(appUrl + "/login", params, String.class);
HttpHeaders headers = response.getHeaders();
String cookieResponse = headers.getFirst("Set-Cookie");
String[] cookieParts = cookieResponse.split(";");
rememberMeCookie = cookieParts[0];
cookie.setCookie(rememberMeCookie);
requestFactory = new  MySimpleClientHttpRequestFactory(verifier,cookie.getCookie());
restTemplate.setRequestFactory(requestFactory);
}
public class MySimpleClientHttpRequestFactory extends SimpleClientHttpRequestFactory {
private final HostnameVerifier verifier;
private final String cookie;
public MySimpleClientHttpRequestFactory(HostnameVerifier verifier ,String cookie) {
this.verifier = verifier;
this.cookie = cookie;
}
@Override
protected void prepareConnection(HttpURLConnection connection, String httpMethod) throws IOException {
if (connection instanceof HttpsURLConnection) {
((HttpsURLConnection) connection).setHostnameVerifier(verifier);
((HttpsURLConnection) connection).setSSLSocketFactory(trustSelfSignedSSL().getSocketFactory());
((HttpsURLConnection) connection).setAllowUserInteraction(true);
String rememberMeCookie = cookie == null ? "" : cookie; 
((HttpsURLConnection) connection).setRequestProperty("Cookie", rememberMeCookie);
}
super.prepareConnection(connection, httpMethod);
}
public SSLContext trustSelfSignedSSL() {
try {
SSLContext ctx = SSLContext.getInstance("TLS");
X509TrustManager tm = new X509TrustManager() {
public void checkClientTrusted(X509Certificate[] xcs, String string) throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] xcs, String string) throws CertificateException {
}
public X509Certificate[] getAcceptedIssuers() {
return null;
}
};
ctx.init(null, new TrustManager[] { tm }, null);
SSLContext.setDefault(ctx);
return ctx;
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
}
public class NullHostnameVerifier implements HostnameVerifier {
public boolean verify(String hostname, SSLSession session) {
return true;
}
}
    • NullHostnameVerifier vérificateur = new NullHostnameVerifier(); vous pouvez voir remember me cookie est une Chaîne de caractères
    InformationsquelleAutor Ran Adler
  5. 4

    Vous pouvez l'utiliser avec HTTPClient API.

    public RestTemplate getRestTemplateBypassingHostNameVerifcation() {
CloseableHttpClient httpClient = HttpClients.custom().setSSLHostnameVerifier(new NoopHostnameVerifier()).build();
HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
requestFactory.setHttpClient(httpClient);
return new RestTemplate(requestFactory);
}
    • Cette échoue avec "soleil.de sécurité.programme de validation.ValidatorException: PKIX chemin de bâtiment échoué...", mais il a été demandé à ignorer la vérification du certificat ainsi
    • Merci de remarquer. C'est tout simplement éteindre le nom d'hôte de vérification, tel que mentionné dans le nom de la méthode.
    InformationsquelleAutor Amit Parashar
  6. 0

    J'ai trouvé un moyen simple

        TrustStrategy acceptingTrustStrategy = (X509Certificate[] chain, String authType) -> true;
SSLContext sslContext = org.apache.http.ssl.SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build();
SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext);
CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(csf).build();
HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
requestFactory.setHttpClient(httpClient);
RestTemplate restTemplate = new RestTemplate(requestFactory);
    InformationsquelleAutor Yash Jagdale
  7. 0

    Pour renverser la stratégie par défaut, vous pouvez créer une méthode dans la classe où vous êtes câblé à votre restTemplate:

     protected void acceptEveryCertificate() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
TrustStrategy acceptingTrustStrategy = new TrustStrategy() {
@Override
public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
return true;
}
};
restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory(
HttpClientBuilder
.create()
.setSSLContext(SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build())
.build()));
}

    Note: Sûrement, vous avez besoin pour gérer les exceptions puisque cette méthode ne lance plus loin!

    InformationsquelleAutor sagaris