wake-up-neo.net

Java SSL: Deaktivieren der Hostnamenüberprüfung

Gibt es eine Möglichkeit für die Standard-Java-SSL-Sockets, die Hostnamenverifizierung für SSL-Verbindungen mit einer Eigenschaft zu deaktivieren? Die einzige Möglichkeit, die ich bisher gefunden habe, ist das Schreiben eines Hostnamen-Prüfers, der die ganze Zeit true zurückgibt. 

Weblogic bietet diese Möglichkeit. Es ist möglich, die Überprüfung des Hostnamens mit der folgenden Eigenschaft zu deaktivieren:

-Dweblogic.security.SSL.ignoreHostnameVerify

33
paweloque

Es sollte möglich sein, benutzerdefinierte Java-Agenten zu erstellen, die die Standardvariable HostnameVerifier überschreiben:

import javax.net.ssl.*;
import Java.lang.instrument.Instrumentation;

public class LenientHostnameVerifierAgent {
    public static void premain(String args, Instrumentation inst) {
        HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
            public boolean verify(String s, SSLSession sslSession) {
                return true;
            }
        });
    }
}

Fügen Sie dann einfach -javaagent:LenientHostnameVerifierAgent.jar zu den Java-Startargumenten des Programms hinzu.

25
Vadzim

Es gibt keine Überprüfung des Hostnamens in Standard-Java-SSL-Sockets oder sogar in SSL. Aus diesem Grund können Sie diese Einstellung nicht auf dieser Ebene festlegen. Die Überprüfung des Hostnamens ist Teil von HTTPS (RFC 2818). Deshalb wird sie als javax.net.ssl.HostnameVerifier bezeichnet, der auf eine HttpsURLConnection angewendet wird.

5
user207421

Ich hatte auch das gleiche Problem beim Zugriff auf RESTful-Webdienste. Und ich bin mit dem folgenden Code, um das Problem zu überwinden:

public class Test {
    //Bypassing the SSL verification to execute our code successfully 
    static {
        disableSSLVerification();
    }

    public static void main(String[] args) {    
        //Access HTTPS URL and do something    
    }
    //Method used for bypassing SSL verification
    public static void disableSSLVerification() {

        TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
            public Java.security.cert.X509Certificate[] getAcceptedIssuers() {
                return null;
            }

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

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

        } };

        SSLContext sc = null;
        try {
            sc = SSLContext.getInstance("SSL");
            sc.init(null, trustAllCerts, new Java.security.SecureRandom());
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

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

Es hat für mich funktioniert. Versuch es!!

3
Nani

Wenn Sie den HTTP-Client 4 von Apache verwenden: 

SSLConnectionSocketFactory sslConnectionSocketFactory = 
    new SSLConnectionSocketFactory(sslContext,
             new String[] { "TLSv1.2" }, null, new HostnameVerifier() {
                    public boolean verify(String arg0, SSLSession arg1) {
                            return true;
            }
      });
1
Eduardo Beninca

Die Antwort von @Nani funktioniert mit Java 1.8u181 nicht mehr. Sie müssen weiterhin Ihren eigenen TrustManager verwenden, es muss jedoch ein X509ExtendedTrustManager anstelle eines X509TrustManager

import Java.io.IOException;
import Java.net.HttpURLConnection;
import Java.net.Socket;
import Java.net.URL;
import Java.security.KeyManagementException;
import Java.security.NoSuchAlgorithmException;
import Java.security.cert.X509Certificate;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509ExtendedTrustManager;

public class Test {

   public static void main (String [] args) throws IOException {
      // This URL has a certificate with a wrong name
      URL url = new URL ("https://wrong.Host.badssl.com/");

      try {
         // opening a connection will fail
         url.openConnection ().connect ();
      } catch (SSLHandshakeException e) {
         System.out.println ("Couldn't open connection: " + e.getMessage ());
      }

      // Bypassing the SSL verification to execute our code successfully
      disableSSLVerification ();

      // now we can open the connection
      url.openConnection ().connect ();

      System.out.println ("successfully opened connection to " + url + ": " + ((HttpURLConnection) url.openConnection ()).getResponseCode ());
   }

   // Method used for bypassing SSL verification
   public static void disableSSLVerification () {

      TrustManager [] trustAllCerts = new TrustManager [] {new X509ExtendedTrustManager () {
         @Override
         public void checkClientTrusted (X509Certificate [] chain, String authType, Socket socket) {

         }

         @Override
         public void checkServerTrusted (X509Certificate [] chain, String authType, Socket socket) {

         }

         @Override
         public void checkClientTrusted (X509Certificate [] chain, String authType, SSLEngine engine) {

         }

         @Override
         public void checkServerTrusted (X509Certificate [] chain, String authType, SSLEngine engine) {

         }

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

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

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

      }};

      SSLContext sc = null;
      try {
         sc = SSLContext.getInstance ("SSL");
         sc.init (null, trustAllCerts, new Java.security.SecureRandom ());
      } catch (KeyManagementException | NoSuchAlgorithmException e) {
         e.printStackTrace ();
      }
      HttpsURLConnection.setDefaultSSLSocketFactory (sc.getSocketFactory ());
   }
}
0