zoukankan      html  css  js  c++  java

  • HTTPS 信任证书

    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;
    10. public class SslUtils {
    12. private static void trustAllHttpsCertificates() throws Exception {
    13. TrustManager[] trustAllCerts = new TrustManager[1];
    14. TrustManager tm = new miTM();
    15. trustAllCerts[0] = tm;
    16. SSLContext sc = SSLContext.getInstance("SSL");
    17. sc.init(null, trustAllCerts, null);
    18. HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
    19. }
    21. static class miTM implements TrustManager, X509TrustManager {
    23. public X509Certificate[] getAcceptedIssuers() {
    24. return null;
    25. }
    27. public boolean isServerTrusted(X509Certificate[] certs) {
    28. return true;
    29. }
    31. public boolean isClientTrusted(X509Certificate[] certs) {
    32. return true;
    33. }
    35. public void checkServerTrusted(X509Certificate[] certs, String authType)
    36. throws CertificateException {
    37. return;
    38. }
    40. public void checkClientTrusted(X509Certificate[] certs, String authType)
    41. throws CertificateException {
    42. return;
    43. }
    44. }
    46. /**
    47. * 忽略HTTPS请求的SSL证书，必须在openConnection之前调用
    48. *
    49. * @throws Exception
    50. */
    51. public static void ignoreSsl() throws Exception {
    52. HostnameVerifier hv = new HostnameVerifier() {
    53. public boolean verify(String urlHostName, SSLSession session) {
    54. System.out.println("Warning: URL Host: " + urlHostName + " vs. " + session.getPeerHost());
    55. return true;
    56. }
    57. };
    58. trustAllHttpsCertificates();
    59. HttpsURLConnection.setDefaultHostnameVerifier(hv);
    60. }
    61. }

    调用方式

    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");
    4.         // 创建HttpsURLConnection对象，并设置其SSLSocketFactory对象
    5.         HttpsURLConnection httpsConn = (HttpsURLConnection) myURL
    6.                 .openConnection();
    8.         // 取得该连接的输入流，以读取响应内容
    9.         InputStreamReader insr = new InputStreamReader(httpsConn
    10.                 .getInputStream());
    12.         // 读取服务器的响应内容并显示
    13.         int respInt = insr.read();
    14.         while (respInt != -1) {
    15.             System.out.print((char) respInt);
    16.             respInt = insr.read();
    17.         }

    在取得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;
    3. import java.io.FileInputStream;
    4. import java.security.KeyStore;
    5. import java.security.cert.CertificateException;
    6. import java.security.cert.X509Certificate;
    8. import javax.net.ssl.TrustManager;
    9. import javax.net.ssl.TrustManagerFactory;
    10. import javax.net.ssl.X509TrustManager;
    12. public class MyX509TrustManager implements X509TrustManager {
    14.     /*
    15.      * The default X509TrustManager returned by SunX509.  We'll delegate
    16.      * decisions to it, and fall back to the logic in this class if the
    17.      * default X509TrustManager doesn't trust it.
    18.      */
    19.     X509TrustManager sunJSSEX509TrustManager;
    21.     MyX509TrustManager() throws Exception {
    22.         // create a "default" JSSE X509TrustManager.
    24.         KeyStore ks = KeyStore.getInstance("JKS");
    25.         ks.load(new FileInputStream("trustedCerts"),
    26.             "passphrase".toCharArray());
    28.         TrustManagerFactory tmf =
    29.         TrustManagerFactory.getInstance("SunX509", "SunJSSE");
    30.         tmf.init(ks);
    32.         TrustManager tms [] = tmf.getTrustManagers();
    34.         /*
    35.          * Iterate over the returned trustmanagers, look
    36.          * for an instance of X509TrustManager.  If found,
    37.          * use that as our "default" trust manager.
    38.          */
    39.         for (int i = 0; i < tms.length; i++) {
    40.             if (tms[i] instanceof X509TrustManager) {
    41.                 sunJSSEX509TrustManager = (X509TrustManager) tms[i];
    42.                 return;
    43.             }
    44.         }
    46.         /*
    47.          * Find some other way to initialize, or else we have to fail the
    48.          * constructor.
    49.          */
    50.         throw new Exception("Couldn't initialize");
    51.     }
    53.     /*
    54.      * Delegate to the default trust manager.
    55.      */
    56.     public void checkClientTrusted(X509Certificate[] chain, String authType)
    57.                 throws CertificateException {
    58.         try {
    59.             sunJSSEX509TrustManager.checkClientTrusted(chain, authType);
    60.         } catch (CertificateException excep) {
    61.             // do any special handling here, or rethrow exception.
    62.         }
    63.     }
    65.     /*
    66.      * Delegate to the default trust manager.
    67.      */
    68.     public void checkServerTrusted(X509Certificate[] chain, String authType)
    69.                 throws CertificateException {
    70.         try {
    71.             sunJSSEX509TrustManager.checkServerTrusted(chain, authType);
    72.         } catch (CertificateException excep) {
    73.             /*
    74.              * Possibly pop up a dialog box asking whether to trust the
    75.              * cert chain.
    76.              */
    77.         }
    78.     }
    80.     /*
    81.      * Merely pass this through.
    82.      */
    83.     public X509Certificate[] getAcceptedIssuers() {
    84.         return sunJSSEX509TrustManager.getAcceptedIssuers();
    85.     }
    86. }
    1.         // 创建SSLContext对象，并使用我们指定的信任管理器初始化
    2.         TrustManager[] tm = { new MyX509TrustManager() };
    3.         SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
    4.         sslContext.init(null, tm, new java.security.SecureRandom());
    6.         // 从上述SSLContext对象中得到SSLSocketFactory对象
    7.         SSLSocketFactory ssf = sslContext.getSocketFactory();
    9.         // 创建URL对象
    10.         URL myURL = new URL("https://ebanks.gdb.com.cn/sperbank/perbankLogin.jsp");
    12.         // 创建HttpsURLConnection对象，并设置其SSLSocketFactory对象
    13.         HttpsURLConnection httpsConn = (HttpsURLConnection) myURL.openConnection();
    14.         httpsConn.setSSLSocketFactory(ssf);
    16.         // 取得该连接的输入流，以读取响应内容
    17.         InputStreamReader insr = new InputStreamReader(httpsConn.getInputStream());
    19.         // 读取服务器的响应内容并显示
    20.         int respInt = insr.read();
    21.         while (respInt != -1) {
    22.             System.out.print((char) respInt);
    23.             respInt = insr.read();
    24.         }

    对于以上两种实现方式，各有各的优点，第一种方式不会破坏JSSE的安全性，但是要手工导入证书，如果服务器很多，那每台服务器的JRE都必须做相同的操作；第二种方式灵活性更高，但是要小心实现，否则可能会留下安全隐患；
  • 相关阅读:
    Jqurey 得到url参数 getUrlParam
    JQUERY获取当前页面的URL信息
    TextView，imageView属性讲解
    滑动解锁
    显示界面跳转，隐式跳转
    代码进行Relativelayout，constraintLayout布局
    代码布局-LinearLayout
    实例xml拖拽详细方法布局
    layout布局
    AS资源了解
  • 原文地址：https://www.cnblogs.com/haore147/p/7172135.html
Copyright © 2011-2022 走看看