Wie kann ich die Zertifikatsprüfung im JAX-WS Client deaktivieren?

Question

Wie deaktivieren Sie die Zertifikatsüberprüfung in JAX-WS-Client mit javax.xml.ws.Service?

Ich habe versucht, eine All-vertrauensvollen Trust im SSLSocketFactory zu schaffen und versuchte es mit BindingProvider zu binden

SSLContext sc = SSLContext.getInstance("SSL"); 
sc.init(null, trustAllCerts, new java.security.SecureRandom()); 

Map<String, Object> ctxt = ((BindingProvider) wsport).getRequestContext(); 
ctxt.put(JAXWSProperties.SSL_SOCKET_FACTORY, sc.getSocketFactory()); 

aber ich habe noch Exception: unable to find valid certification path to requested target immer

Aber es funktioniert, wenn ich nur

verwenden

HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory()); 

Oder gibt es eine Möglichkeit, javax.xml.ws.Service die HttpsURLConnection, die ich erstellt habe, zu machen?

Answer 1

ich hier eine Lösung gefunden: http://schrepfler.blogspot.com.br/2009/06/relaxing-ssl-validation-for-jaxws.html

Ich bin mit dieser Lösung die beiden statischen Methoden auf einem statischen Block an der Haupt-Klasse aufrufen, wie folgt aus:

static { 
    SSLUtilities.trustAllHostnames(); 
    SSLUtilities.trustAllHttpsCertificates(); 
} 

this helps

Answer 2

Die Wahrheit kann von Erik Wramner Blog hier http://erikwramner.wordpress.com/2013/03/27/trust-self-signed-ssl-certificates-and-skip-host-name-verification-with-jax-ws

Beachten finden für Nikolay Smirnovs Kommentar auch. Ich benutze jdk 7 und glassfish 3.1.2. In dieser Umgebung funktioniert die vorgeschlagene Lösung perfekt, wenn der Server mit einem selbstsignierten Zertifikat arbeitet.

I umfassen die vollständige Lösung für die auch später Referenz einschließlich Lösung, wenn Apache CXF verwendet wird:

// import com.sun.xml.ws.developer.JAXWSProperties; 
import java.security.GeneralSecurityException; 
import java.security.SecureRandom; 
import java.util.Map; 
import javax.net.ssl.HostnameVerifier; 
import javax.net.ssl.KeyManager; 
import javax.net.ssl.SSLContext; 
import javax.net.ssl.SSLSession; 
import javax.net.ssl.SSLSocketFactory; 
import javax.net.ssl.TrustManager; 
import javax.net.ssl.X509TrustManager; 
import javax.xml.ws.BindingProvider; 
import org.apache.cxf.configuration.jsse.TLSClientParameters; 
import org.apache.cxf.endpoint.Client; 
import org.apache.cxf.frontend.ClientProxy; 
import org.apache.cxf.transport.http.HTTPConduit; 

/** 
* 
* Usage examples (BindingProvider port): 
* NaiveSSLHelper.makeWebServiceClientTrustEveryone(port); // GlassFish 
* NaiveSSLHelper.makeCxfWebServiceClientTrustEveryone(port); // TomEE 
* 
* Based on Erik Wramner's example frome here: 
* http://erikwramner.wordpress.com/2013/03/27/trust-self-signed-ssl-certificates-and-skip-host-name-verification-with-jax-ws/ 
* 
* I have extended the functionality when Apache CXF is used. 
*/ 
public class NaiveSSLHelper { 

    private static final String JAXWS_HOSTNAME_VERIFIER = "com.sun.xml.ws.transport.https.client.hostname.verifier"; // JAXWSProperties.HOSTNAME_VERIFIER; 
    private static final String JAXWS_SSL_SOCKET_FACTORY = "com.sun.xml.ws.transport.https.client.SSLSocketFactory"; // JAXWSProperties.SSL_SOCKET_FACTORY; 

    // In Glassfish (Metro) environment you can use this function (Erik Wramner's solution) 
    public static void makeWebServiceClientTrustEveryone(Object webServicePort) { 
     if (webServicePort instanceof BindingProvider) { 
      BindingProvider bp = (BindingProvider) webServicePort; 
      Map requestContext = bp.getRequestContext(); 
      requestContext.put(JAXWS_SSL_SOCKET_FACTORY, getTrustingSSLSocketFactory()); 
      requestContext.put(JAXWS_HOSTNAME_VERIFIER, new NaiveHostnameVerifier()); 
     } else { 
      throw new IllegalArgumentException(
        "Web service port " 
        + webServicePort.getClass().getName() 
        + " does not implement " 
        + BindingProvider.class.getName()); 
     } 
    } 

    // In TomEE (Apache CXF) environment you can use this function (my solution) 
    public static void makeCxfWebServiceClientTrustEveryone(Object port) { 
     TrustManager[] trustManagers = new TrustManager[]{ 
      new NaiveTrustManager() 
     }; 
     Client c = ClientProxy.getClient(port); 
     HTTPConduit httpConduit = (HTTPConduit) c.getConduit(); 
     TLSClientParameters tlsParams = new TLSClientParameters(); 
     tlsParams.setSecureSocketProtocol("SSL"); 
     tlsParams.setKeyManagers(new KeyManager[0]); 
     tlsParams.setTrustManagers(trustManagers); 
     tlsParams.setDisableCNCheck(true); 
     httpConduit.setTlsClientParameters(tlsParams); 
    } 

    public static SSLSocketFactory getTrustingSSLSocketFactory() { 
     return SSLSocketFactoryHolder.INSTANCE; 
    } 

    private static SSLSocketFactory createSSLSocketFactory() { 
     TrustManager[] trustManagers = new TrustManager[]{ 
      new NaiveTrustManager() 
     }; 
     SSLContext sslContext; 
     try { 
      sslContext = SSLContext.getInstance("SSL"); 
      sslContext.init(new KeyManager[0], trustManagers, new SecureRandom()); 
      return sslContext.getSocketFactory(); 
     } catch (GeneralSecurityException e) { 
      return null; 
     } 
    } 

    private static interface SSLSocketFactoryHolder { 

     public static final SSLSocketFactory INSTANCE = createSSLSocketFactory(); 
    } 

    private static class NaiveHostnameVerifier implements 
      HostnameVerifier { 

     @Override 
     public boolean verify(String hostName, 
       SSLSession session) { 
      return true; 
     } 
    } 

    private static class NaiveTrustManager implements 
      X509TrustManager { 

     @Override 
     public void checkClientTrusted(java.security.cert.X509Certificate[] certs, 
       String authType) throws java.security.cert.CertificateException { 
     } 

     @Override 
     public void checkServerTrusted(java.security.cert.X509Certificate[] certs, 
       String authType) throws java.security.cert.CertificateException { 
     } 

     @Override 
     public java.security.cert.X509Certificate[] getAcceptedIssuers() { 
      return new java.security.cert.X509Certificate[0]; 
     } 
    } 
}