जब restTemplate

Question

का उपयोग कर रहा पता निम्नलिखित करने के लिए एक अनुरोध भेजने के लिए कोशिश कर रहा हूँ प्रमाण पत्र की अनदेखी करने की आवश्यकता है। प्रमाण पत्र मान्य नहीं है और मैं इसे अनदेखा करना चाहता हूं। मैंने 1, 2 पर अपने शोध के आधार पर निम्नलिखित कोड लिखा लेकिन मैं इसे पूरा करने में सक्षम नहीं हूं। मैं जावा 1.7,

https://api.stubhubsandbox.com/search/catalog/events/v3 

कोड का उपयोग कर रहा

बातें jdk6 के बाद बदल गया है, लेकिन पिछली बार मैं यह करने के लिए कोशिश कर रहा था हम की कुंजी संग्रह करने के लिए एसएसएल प्रमाणपत्र आयात करने की जरूरत

private static final TrustManager[] UNQUESTIONING_TRUST_MANAGER = 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){} 
     public void checkClientTrusted(
       java.security.cert.X509Certificate[] arg0, String arg1) 
       throws CertificateException { 
      // TODO Auto-generated method stub 

     } 
     public void checkServerTrusted(
       java.security.cert.X509Certificate[] arg0, String arg1) 
       throws CertificateException { 
      // TODO Auto-generated method stub 

     } 
    } 
}; 

public static void main(String[] args) { 
    TrustStrategy acceptingTrustStrategy = 

    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); 
    String url = "https://api.stubhubsandbox.com/search/catalog/events/v3"; 
    RestTemplate rest = new RestTemplate(); 
    Map<String, String> mvm = new HashMap<String, String>(); 
    mvm.put("Authorization", "Bearer TOKEEEEEEEN"); 
    Object object = rest.postForObject(url, null, Object.class, mvm); 
    System.err.println("done"); 


} 

Answer 1

सुनिश्चित नहीं हैं JAVA_HOME भरोसेमंद एसएसएल का उपयोग करने वाले कार्यक्रम चलाने के लिए प्रयोग किया जाता था।

पहले, आप एक फाइल करने के लिए प्रमाणपत्र निर्यात करने की आवश्यकता होगी। विंडोज़ में, आप एसएसएल सर्टिफिकेट को अपने व्यक्तिगत सर्टिफिकेट स्टोर में सहेजने के लिए किसी भी ब्राउज़र का उपयोग कर सकते हैं और फिर एमएमसी चला सकते हैं, प्रमाणपत्र स्नैपिन (फ़ाइल/स्नैपिन निकालें) जोड़ें और सर्टिफिकेट को डिस्क पर सेव करें।

तो फिर तुम keytool का उपयोग कर विश्वसनीय डोमेन cacerts को प्रमाणपत्र आयात करने की जरूरत है। लेकिन आपको इसे उस कुंजीस्टोर पर आयात करने की आवश्यकता है जो आपके जावा प्रोग्राम का उपयोग करते समय आपके जावा_होम का उपयोग करता है।

नीचे आदेश फ़ाइल "cacerts.jks" में KeyStore को प्रमाणपत्र फ़ाइल "mycertificate.cer" जोड़ देगा। उपनाम "webservice" है:

"%JAVA_HOME%\bin\keytool" -import -trustcacerts -alias webservice -file mycertificate.cer -keystore cacerts.jks 

आमतौर पर, कीस्टोर पासवर्ड "परिवर्तन" होता है, कोई उद्धरण नहीं। उत्पादन के उपयोग के लिए इसे बदलें

Answer 2

जैसा कि आपने देखा होगा, वसंत RestTemplate सभी HTTP (एस) संबंधित सामग्री ClientHttpRequestFactory के अंतर्निहित कार्यान्वयन में प्रतिनिधि करता है।

• Ignoring SSL certificate in Apache HttpClient 4.3
• How to ignore SSL certificate errors in Apache HttpClient 4.0

जाहिर है, संस्करण के बाद से: चूंकि आप HttpClient आधारित कार्यान्वयन का उपयोग कर रहे है, तो यहां आंतरिक HttpClient के लिए इस लक्ष्य को हासिल करने के बारे में उपयोगी अतः लिंक के एक जोड़े हैं 4.4, यह इस प्रकार किया जा सकता है:

CloseableHttpClient httpClient = HttpClients.custom().setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE).build(); 

Answer 3

कई वसंत परियोजनाओं में एसएसएल चेक को बाईपास करने के लिए मैं हमेशा कुछ समय पहले स्प्रिंग के रेस्ट टेम्पलेट के संयोजन के साथ मैंने लिखा था (या पाया) एक SSLUtils वर्ग का दोबारा उपयोग करें। नीचे दिए गए वर्ग का उपयोग करने से पहले आपको अपना अनुरोध भेजने से पहले स्थिर विधि SSLUtils.turnOffSslChecking() पर कॉल करने की आवश्यकता है।

import javax.net.ssl.*; 
import java.security.*; 
import java.security.cert.CertificateException; 
import java.security.cert.X509Certificate; 

public final class SSLUtil{ 

    static { 
     //for localhost testing only 
     javax.net.ssl.HttpsURLConnection.setDefaultHostnameVerifier(
     new javax.net.ssl.HostnameVerifier(){ 

      public boolean verify(String hostname, 
        javax.net.ssl.SSLSession sslSession) { 
       if (hostname.equals("localhost")) { 
        return true; 
       } 
       return false; 
      } 
     }); 
    } 

    private static final TrustManager[] UNQUESTIONING_TRUST_MANAGER = 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){} 
      } 
     }; 

    public static void turnOffSslChecking() throws NoSuchAlgorithmException, KeyManagementException { 
     // Install the all-trusting trust manager 
     final SSLContext sc = SSLContext.getInstance("SSL"); 
     sc.init(null, UNQUESTIONING_TRUST_MANAGER, null); 
     HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory()); 
    } 

    public static void turnOnSslChecking() throws KeyManagementException, NoSuchAlgorithmException { 
     // Return it to the initial state (discovered by reflection, now hardcoded) 
     SSLContext.getInstance("SSL").init(null, null, null); 
    } 

    private SSLUtil(){ 
     throw new UnsupportedOperationException("Do not instantiate libraries."); 
    } 
} 

इसे आज़माएं। उम्मीद है कि यह काम करता है और आपके लिए एक आसान समाधान के रूप में बाहर निकलता है।

Answer 4

आप इस कोड का उपयोग कर सकते हैं:

@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; 
} 

जावा 7 में

लैम्ब्डा अभिव्यक्ति की जगह के साथ:

 TrustStrategy acceptingTrustStrategy = new TrustStrategy() { 
     @Override public boolean isTrusted(X509Certificate[] x509Certificates, String s) 
         throws CertificateException { 
      return true; 
     } 
    }; 

Answer 5

करने के लिए http SSLContext और X509TrustManager और HostnameVerifier उदाहरणों जोड़े क्लाइंटबिल्डर। वे उदाहरण के लिए हो सकता है (मेरे उदाहरण दिया)

HttpComponentsClientHttpRequestFactory साथ
1. HttpClientBuilder
OkHttp3ClientHttpRequestFactory

साथ

OkHttpClient.Builder यहाँ अपाचे HttpClient & OkHttpClient के लिए नमूना कोड है। डेमो प्रयोजन के लिए इसका उपयोग कर सकते हैं, लेकिन आप यह

अपाचे HttpClient

RestTemplate restTemplate = new RestTemplate(SSLClientFactory.getClientHttpRequestFactory(HttpClientType.HttpClient)); 

और OkHttpClient

RestTemplate restTemplate = new RestTemplate(SSLClientFactory.getClientHttpRequestFactory(HttpClientType.OkHttpClient)); 

कस्टम यहाँ वर्ग SSLClientFactory है

import java.security.KeyManagementException; 
import java.security.NoSuchAlgorithmException; 
import java.security.cert.CertificateException; 
import java.security.cert.X509Certificate; 
import java.util.concurrent.TimeUnit; 

import javax.net.ssl.HostnameVerifier; 
import javax.net.ssl.SSLContext; 
import javax.net.ssl.SSLSession; 
import javax.net.ssl.TrustManager; 
import javax.net.ssl.X509TrustManager; 

import org.apache.http.impl.client.HttpClientBuilder; 
import org.springframework.http.client.ClientHttpRequestFactory; 
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory; 
import org.springframework.http.client.OkHttp3ClientHttpRequestFactory; 

import okhttp3.OkHttpClient; 

public abstract class SSLClientFactory { 

    private static boolean allowUntrusted = false; 
    private static final long LOGIN_TIMEOUT_SEC = 10; 
    private static HttpClientBuilder closeableClientBuilder = null; 
    private static OkHttpClient.Builder okHttpClientBuilder = null; 

    public enum HttpClientType{ 
     HttpClient, 
     OkHttpClient 
    } 


    public static synchronized ClientHttpRequestFactory getClientHttpRequestFactory(HttpClientType httpClientType){ 

     ClientHttpRequestFactory requestFactory = null; 

     SSLContext sslContext = SSLClientFactory.getSSlContext(); 

     if(null == sslContext){ 
      return requestFactory; 
     } 

     switch (httpClientType) { 

     case HttpClient: 
      closeableClientBuilder = HttpClientBuilder.create(); 

      //Add the SSLContext and trustmanager 
      closeableClientBuilder.setSSLContext(getSSlContext()); 
      //add the hostname verifier 
      closeableClientBuilder.setSSLHostnameVerifier(gethostnameVerifier()); 

      requestFactory = new HttpComponentsClientHttpRequestFactory(closeableClientBuilder.build()); 

      break; 
     case OkHttpClient: 
      okHttpClientBuilder = new OkHttpClient().newBuilder().readTimeout(LOGIN_TIMEOUT_SEC, TimeUnit.SECONDS); 

      //Add the SSLContext and trustmanager 
      okHttpClientBuilder.sslSocketFactory(getSSlContext().getSocketFactory(), getTrustManager()); 
      //add the hostname verifier 
      okHttpClientBuilder.hostnameVerifier(gethostnameVerifier()); 

      requestFactory = new OkHttp3ClientHttpRequestFactory(okHttpClientBuilder.build()); 

      break; 
     default: 
      break; 
     } 

     return requestFactory; 

    } 


    private static SSLContext getSSlContext(){ 



     final TrustManager[] trustAllCerts = new TrustManager[]{getTrustManager()}; 

     SSLContext sslContext = null; 
     try { 

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

     } catch (NoSuchAlgorithmException | KeyManagementException e) { 
      e.printStackTrace(); 
     } 



     return sslContext; 

    } 

    private static X509TrustManager getTrustManager(){ 

     final X509TrustManager trustManager = new X509TrustManager() { 

      @Override 
      public X509Certificate[] getAcceptedIssuers() { 
       X509Certificate[] cArrr = new X509Certificate[0]; 
       return cArrr; 
      } 

      @Override 
      public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException { 
       // TODO Auto-generated method stub 

      } 

      @Override 
      public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException { 
       // TODO Auto-generated method stub 

      } 
     }; 

     return trustManager; 
    } 

    private static HostnameVerifier gethostnameVerifier(){ 

     HostnameVerifier hostnameVerifier = new HostnameVerifier() { 

      @Override 
      public boolean verify(String arg0, SSLSession arg1) { 
       return true; 
      } 
     }; 

     return hostnameVerifier; 

    } 

}