HTTPS信任證書

文藝小青年發表於2017-06-08
  1. 使用HttpsURLConnection訪問HTTPS連結時一般需要引入證照,否則會產生異常。
  2. 但是也可以使用信任所有證照的方式來達到訪問的目的。
  3. 經上網查詢資料發現一個很好用的類來實現信任所有證照的功能。特此記錄。
  4. 程式碼來自[這裡](http://javaweb.org/?p=1237)

類程式碼

  1. import java.security.cert.CertificateException;
  2. import java.security.cert.X509Certificate;
  3. import javax.net.ssl.HostnameVerifier;
  4. import javax.net.ssl.HttpsURLConnection;
  5. import javax.net.ssl.SSLContext;
  6. import javax.net.ssl.SSLSession;
  7. import javax.net.ssl.TrustManager;
  8. import javax.net.ssl.X509TrustManager;
  9. public class SslUtils {
  10. private static void trustAllHttpsCertificates() throws Exception {
  11. TrustManager[] trustAllCerts = new TrustManager[1];
  12. TrustManager tm = new miTM();
  13. trustAllCerts[0] = tm;
  14. SSLContext sc = SSLContext.getInstance("SSL");
  15. sc.init(null, trustAllCerts, null);
  16. HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
  17. }
  18. static class miTM implements TrustManager, X509TrustManager {
  19. public X509Certificate[] getAcceptedIssuers() {
  20. return null;
  21. }
  22. public boolean isServerTrusted(X509Certificate[] certs) {
  23. return true;
  24. }
  25. public boolean isClientTrusted(X509Certificate[] certs) {
  26. return true;
  27. }
  28. public void checkServerTrusted(X509Certificate[] certs, String authType)
  29. throws CertificateException {
  30. return;
  31. }
  32. public void checkClientTrusted(X509Certificate[] certs, String authType)
  33. throws CertificateException {
  34. return;
  35. }
  36. }
  37. /**
  38. * 忽略HTTPS請求的SSL證照,必須在openConnection之前呼叫
  39. *
  40. * @throws Exception
  41. */
  42. public static void ignoreSsl() throws Exception {
  43. HostnameVerifier hv = new HostnameVerifier() {
  44. public boolean verify(String urlHostName, SSLSession session) {
  45. System.out.println("Warning: URL Host: " + urlHostName + " vs. " + session.getPeerHost());
  46. return true;
  47. }
  48. };
  49. trustAllHttpsCertificates();
  50. HttpsURLConnection.setDefaultHostnameVerifier(hv);
  51. }
  52. }

呼叫方式

  1. openConnection之前呼叫SslUtils.ignoreSsl();即可忽略所有HTTPS連結的證照。

 


 

 

 

 

 

 

在web應用互動過程中,有很多場景需要保證通訊資料的安全;在前面也有好多篇文章介紹了在Web Service呼叫過程中用WS-Security來保證介面互動過程的安全性,值得注意的是,該種方式基於的傳輸協議仍然是Http,採用這種方式可擴充套件性和資料互動效率比較高;另外一種實現方式就是用Https,他是在協議層對Http的再次封裝,加入了SSL/TLS,採用該協議進行通訊的資料全部都會被加密,由於目前Web開發程式設計中對此都有了一定程度的封裝,所以採用Https對外提供服務,除了證照以外,對程式設計能力的要求並不高,相對於前者門檻較低,但是由於對雙方通訊的所有資料都進行加密,而且互動過程中還有多次握手等,所以效率較低;以下就介紹下在Java中訪問Https連結時會出現的一些問題;

在Java中要訪問Https連結時,會用到一個關鍵類HttpsURLConnection;參見如下實現程式碼:

  1.         // 建立URL物件
  2.         URL myURL = new URL(“https://www.sun.com”);
  3.         // 建立HttpsURLConnection物件,並設定其SSLSocketFactory物件
  4.         HttpsURLConnection httpsConn = (HttpsURLConnection) myURL
  5.                 .openConnection();
  6.         // 取得該連線的輸入流,以讀取響應內容
  7.         InputStreamReader insr = new InputStreamReader(httpsConn
  8.                 .getInputStream());
  9.         // 讀取伺服器的響應內容並顯示
  10.         int respInt = insr.read();
  11.         while (respInt != –1) {
  12.             System.out.print((char) respInt);
  13.             respInt = insr.read();
  14.         }

在取得connection的時候和正常瀏覽器訪問一樣,仍然會驗證服務端的證照是否被信任(權威機構發行或者被權威機構簽名);如果服務端證照不被信任,則預設的實現就會有問題,一般來說,用SunJSSE會拋如下異常資訊:
javax.NET.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

上面提到SunJSSE,JSSE(Java Secure Socket Extension)是實現Internet安全通訊的一系列包的集合。它是一個SSL和TLS的純Java實現,可以透明地提供資料加密、伺服器認證、資訊完整性等功能,可以使我們像使用普通的套接字一樣使用JSSE建立的安全套接字。JSSE是一個開放的標準,不只是Sun公司才能實現一個SunJSSE,事實上其他公司有自己實現的JSSE,然後通過JCA就可以在JVM中使用。
關於JSSE的詳細資訊參考官網Reference:http://java.sun.com/j2se/1.5.0/docs/guide/security/jsse/JSSERefGuide.html
以及java Security Guide:http://java.sun.com/j2se/1.5.0/docs/guide/security/

在深入瞭解JSSE之前,需要了解一個有關Java安全的概念:客戶端的TrustStore檔案。客戶端的TrustStore檔案中儲存著被客戶端所信任的伺服器的證照資訊。客戶端在進行SSL連線時,JSSE將根據這個檔案中的證照決定是否信任伺服器端的證照。在SunJSSE中,有一個信任管理器類負責決定是否信任遠端的證照,這個類有如下的處理規則:
1、若系統屬性javax.net.sll.trustStore指定了TrustStore檔案,那麼信任管理器就去jre安裝路徑下的lib/security/目錄中尋找並使用這個檔案來檢查證照。
2、若該系統屬性沒有指定TrustStore檔案,它就會去jre安裝路徑下尋找預設的TrustStore檔案,這個檔案的相對路徑為:lib/security/jssecacerts
3、若jssecacerts不存在,但是cacerts存在(它隨J2SDK一起發行,含有數量有限的可信任的基本證照),那麼這個預設的TrustStore檔案就是lib/security/cacerts

那遇到這種情況,怎麼處理呢?有以下兩種方案:
1、按照以上信任管理器的規則,將服務端的公鑰匯入到jssecacerts,或者是在系統屬性中設定要載入的trustStore檔案的路徑;證照匯入可以用如下命令:keytool -import -file src_cer_file –keystore dest_cer_store;至於證照可以通過瀏覽器匯出獲得;
2、實現自己的證照信任管理器類,比如MyX509TrustManager,該類必須實現X509TrustManager介面中的三個method;然後在HttpsURLConnection中載入自定義的類,可以參見如下兩個程式碼片段,其一為自定義證照信任管理器,其二為connect時的程式碼:

  1. package test;
  2. import java.io.FileInputStream;
  3. import java.security.KeyStore;
  4. import java.security.cert.CertificateException;
  5. import java.security.cert.X509Certificate;
  6. import javax.net.ssl.TrustManager;
  7. import javax.net.ssl.TrustManagerFactory;
  8. import javax.net.ssl.X509TrustManager;
  9. public class MyX509TrustManager implements X509TrustManager {
  10.     /*
  11.      * The default X509TrustManager returned by SunX509.  We`ll delegate
  12.      * decisions to it, and fall back to the logic in this class if the
  13.      * default X509TrustManager doesn`t trust it.
  14.      */
  15.     X509TrustManager sunJSSEX509TrustManager;
  16.     MyX509TrustManager() throws Exception {
  17.         // create a “default” JSSE X509TrustManager.
  18.         KeyStore ks = KeyStore.getInstance(“JKS”);
  19.         ks.load(new FileInputStream(“trustedCerts”),
  20.             “passphrase”.toCharArray());
  21.         TrustManagerFactory tmf =
  22.         TrustManagerFactory.getInstance(“SunX509”, “SunJSSE”);
  23.         tmf.init(ks);
  24.         TrustManager tms [] = tmf.getTrustManagers();
  25.         /*
  26.          * Iterate over the returned trustmanagers, look
  27.          * for an instance of X509TrustManager.  If found,
  28.          * use that as our “default” trust manager.
  29.          */
  30.         for (int i = 0; i < tms.length; i++) {
  31.             if (tms[i] instanceof X509TrustManager) {
  32.                 sunJSSEX509TrustManager = (X509TrustManager) tms[i];
  33.                 return;
  34.             }
  35.         }
  36.         /*
  37.          * Find some other way to initialize, or else we have to fail the
  38.          * constructor.
  39.          */
  40.         throw new Exception(“Couldn`t initialize”);
  41.     }
  42.     /*
  43.      * Delegate to the default trust manager.
  44.      */
  45.     public void checkClientTrusted(X509Certificate[] chain, String authType)
  46.                 throws CertificateException {
  47.         try {
  48.             sunJSSEX509TrustManager.checkClientTrusted(chain, authType);
  49.         } catch (CertificateException excep) {
  50.             // do any special handling here, or rethrow exception.
  51.         }
  52.     }
  53.     /*
  54.      * Delegate to the default trust manager.
  55.      */
  56.     public void checkServerTrusted(X509Certificate[] chain, String authType)
  57.                 throws CertificateException {
  58.         try {
  59.             sunJSSEX509TrustManager.checkServerTrusted(chain, authType);
  60.         } catch (CertificateException excep) {
  61.             /*
  62.              * Possibly pop up a dialog box asking whether to trust the
  63.              * cert chain.
  64.              */
  65.         }
  66.     }
  67.     /*
  68.      * Merely pass this through.
  69.      */
  70.     public X509Certificate[] getAcceptedIssuers() {
  71.         return sunJSSEX509TrustManager.getAcceptedIssuers();
  72.     }
  73. }
  1.         // 建立SSLContext物件,並使用我們指定的信任管理器初始化
  2.         TrustManager[] tm = { new MyX509TrustManager() };
  3.         SSLContext sslContext = SSLContext.getInstance(“SSL”, “SunJSSE”);
  4.         sslContext.init(null, tm, new java.security.SecureRandom());
  5.         // 從上述SSLContext物件中得到SSLSocketFactory物件
  6.         SSLSocketFactory ssf = sslContext.getSocketFactory();
  7.         // 建立URL物件
  8.         URL myURL = new URL(“https://ebanks.gdb.com.cn/sperbank/perbankLogin.jsp”);
  9.         // 建立HttpsURLConnection物件,並設定其SSLSocketFactory物件
  10.         HttpsURLConnection httpsConn = (HttpsURLConnection) myURL.openConnection();
  11.         httpsConn.setSSLSocketFactory(ssf);
  12.         // 取得該連線的輸入流,以讀取響應內容
  13.         InputStreamReader insr = new InputStreamReader(httpsConn.getInputStream());
  14.         // 讀取伺服器的響應內容並顯示
  15.         int respInt = insr.read();
  16.         while (respInt != –1) {
  17.             System.out.print((char) respInt);
  18.             respInt = insr.read();
  19.         }

對於以上兩種實現方式,各有各的優點,第一種方式不會破壞JSSE的安全性,但是要手工匯入證照,如果伺服器很多,那每臺伺服器的JRE都必須做相同的操作;第二種方式靈活性更高,但是要小心實現,否則可能會留下安全隱患;

 

本文轉自二郎三郎部落格園部落格,原文連結:http://www.cnblogs.com/haore147/p/7172135.html,如需轉載請自行聯絡原作者


相關文章