Ausnahme, wenn httpclient Daten an HTTPS sendet, um eine SSL-Verbindung herzustellen

Die Ausnahmeinformationen lauten wie folgt:

javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX-Pfadaufbau fehlgeschlagen: sun.security.provider.certpath.SunCertPathBuilderException: nicht gefunden gültiger Zertifizierungspfad zum angeforderten Ziel

Ursache: Das Zertifikat des Servers ist nicht vertrauenswürdig. Dies wird im Allgemeinen verursacht.

Verwenden Sie das KEYTOOL-Tool, um ein Zertifikat zu erstellen, und starten Sie es dann mit TOMCAT. Wenn der Browser die Website öffnet, erscheint eine Meldung, dass das Zertifikat nicht vertrauenswürdig ist. Wenn HTTPCLIENT zum Senden von Daten an den Server HTTPS verwendet wird, erkennt HTTPCLIENT natürlich auch, ob das Zertifikat des Servers vertrauenswürdig ist. Wenn es nicht vertrauenswürdig ist, wird die obige Ausnahme ausgelöst.

Es gibt zwei Lösungen: Die eine besteht darin, das Zertifikat für den Client vertrauenswürdig zu machen. Die andere besteht darin, HTTPCLIENT zum Senden von Daten zu verwenden, ohne zu prüfen, ob das Serverzertifikat vertrauenswürdig ist.

Die erste Methode besteht darin, das Zertifikat vertrauenswürdig zu machen.

Suchen Sie eine formelle Zertifizierungsstelle, um ein Zertifikat auszustellen, oder stellen Sie das Zertifikat selbst aus (es kann nur auf diesem Client als vertrauenswürdig eingestuft werden). Ich werde nicht darüber sprechen, eine formelle Zertifizierungsstelle für die Ausstellung eines Zertifikats zu finden. Informationen dazu, wie Sie selbst ein Zertifikat ausstellen können, finden Sie in meinen anderen Artikeln.

Ich habe festgestellt, dass nach dem Ausfüllen des von mir selbst signierten Zertifikats beim Öffnen der Serveradresse vom Client aus der obige Fehler nicht mehr angezeigt wurde, ich aber immer noch keine Daten senden konnte. Was ist der Grund? Da das Zertifikat auf dem Client-Betriebssystem vertrauenswürdig ist, im KEYSTORE von JAVA jedoch nicht, müssen Sie das Zertifikat des Servers in die KEYSTORE-Bibliothek importieren

Importmethode:

Öffnen Sie ein Befehlszeilenfenster, gehen Sie zum Verzeichnis 63b3ee7e72479f6360d4c7e4b3af780alibsecurity und führen Sie den folgenden Befehl aus:

keytool -import -noprompt -keystore cacerts -storepass changeit -alias yourEntry1 -file your.cer

Das letzte ist das vom Server exportierte Zertifikat, die anderen können standardmäßig verwendet werden.

Wenn auf dem Client-Computer viele JAVA-Versionen installiert sind, stellen Sie sicher, dass die JAVA-Version des von Ihnen importierten Zertifikats diejenige ist, die von Ihrem TOMCAT verwendet wird. TOMCAT verwendet die Umgebung Die JAVA-Version, auf die die Variable zeigt.

Wenn es sich um einen in ECLIPSE erstellten TOMCAT-Server handelt, werden Sie beim Erstellen eines neuen Servers aufgefordert, die Standard-JRE oder die verwiesene JAVA auszuwählen. Andernfalls müssen Sie den Pfad auswählen, der auf die soeben importierte JAVA verweist. Die von Ihnen importierte Zertifikatsbibliothek hat ebenfalls keine Auswirkung.

Die zweite Methode besteht nicht darin, zu prüfen, ob das Serverzertifikat bei Verwendung von HTTPCLIENT vertrauenswürdig ist

Erweitern Sie die HttpClient-Klasse, um das Zertifikat automatisch zu akzeptieren

Da diese Methode automatisch alle Zertifikate empfängt, gibt es bestimmte Sicherheitsprobleme. Bitte prüfen Sie daher sorgfältig die Sicherheitsanforderungen Ihres Systems, bevor Sie diese Methode verwenden. Die spezifischen Schritte lauten wie folgt:

• Stellen Sie eine benutzerdefinierte Socket-Factory bereit (test.MySecureProtocolSocketFactory). Diese benutzerdefinierte Klasse muss die Schnittstelle org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory implementieren und den benutzerdefinierten X509TrustManager (test.MyX509TrustManager) in der Klasse aufrufen, die die Schnittstelle implementiert. Diese beiden Klassen können im Anhang zu diesem Artikel abgerufen werden.

• Erstellen Sie eine Instanz von org.apache.commons.httpclient.protocol.Protocol, geben Sie den Protokollnamen und die Standardportnummer an.

Protocol myhttps = new Protocol("https", new MySecureProtocolSocketFactory ( ), 443);

•Registrieren Sie das soeben erstellte https-Protokollobjekt

Protocol.registerProtocol("https ", myhttps);

•Öffnen Sie dann die Zieladresse von https gemäß der normalen Programmiermethode. Der Code lautet wie folgt:

MySecureProtocolSocketFactory.java

import java.io.IOException;  
    import java.net.InetAddress;  
    import java.net.InetSocketAddress;  
    import java.net.Socket;  
    import java.net.SocketAddress;  
    import java.net.UnknownHostException;  
    import java.security.KeyManagementException;  
    import java.security.NoSuchAlgorithmException;  
    import java.security.cert.CertificateException;  
    import java.security.cert.X509Certificate;  
      
    import javax.net.SocketFactory;  
    import javax.net.ssl.SSLContext;  
    import javax.net.ssl.TrustManager;  
    import javax.net.ssl.X509TrustManager;  
      
    import org.apache.commons.httpclient.ConnectTimeoutException;  
    import org.apache.commons.httpclient.params.HttpConnectionParams;  
    import org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory;  
      
    public class MySecureProtocolSocketFactory implements SecureProtocolSocketFactory {  
        private SSLContext sslcontext = null;  
          
        private SSLContext createSSLContext() {  
            SSLContext sslcontext=null;  
            try {  
                sslcontext = SSLContext.getInstance("SSL");  
                sslcontext.init(null, new TrustManager[]{new TrustAnyTrustManager()}, new java.security.SecureRandom());  
            } catch (NoSuchAlgorithmException e) {  
                e.printStackTrace();  
            } catch (KeyManagementException e) {  
                e.printStackTrace();  
            }  
            return sslcontext;  
        }  
          
        private SSLContext getSSLContext() {  
            if (this.sslcontext == null) {  
                this.sslcontext = createSSLContext();  
            }  
            return this.sslcontext;  
        }  
          
        public Socket createSocket(Socket socket, String host, int port, boolean autoClose)  
                throws IOException, UnknownHostException {  
            return getSSLContext().getSocketFactory().createSocket(  
                    socket,  
                    host,  
                    port,  
                    autoClose  
                );  
        }  
      
        public Socket createSocket(String host, int port) throws IOException,  
                UnknownHostException {  
            return getSSLContext().getSocketFactory().createSocket(  
                    host,  
                    port  
                );  
        }  
          
          
        public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort)  
                throws IOException, UnknownHostException {  
            return getSSLContext().getSocketFactory().createSocket(host, port, clientHost, clientPort);  
        }  
      
        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");  
            }  
            int timeout = params.getConnectionTimeout();  
            SocketFactory socketfactory = getSSLContext().getSocketFactory();  
            if (timeout == 0) {  
                return socketfactory.createSocket(host, port, localAddress, localPort);  
            } else {  
                Socket socket = socketfactory.createSocket();  
                SocketAddress localaddr = new InetSocketAddress(localAddress, localPort);  
                SocketAddress remoteaddr = new InetSocketAddress(host, port);  
                socket.bind(localaddr);  
                socket.connect(remoteaddr, timeout);  
                return socket;  
            }  
        }  
          
        //自定义私有类  
        private static class TrustAnyTrustManager implements X509TrustManager {  
             
            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
            }  
         
            public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
            }  
         
            public X509Certificate[] getAcceptedIssuers() {  
                return new X509Certificate[]{};  
            }  
        }  
          
      
    }