devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android支持https的处理方式2----HttpURLConnection请求https处理方式_android httpurlconnection ssl

作者：盐析白兔 | 2024-03-08 14:29:31

赞

踩

android httpurlconnection ssl

接着上一篇，这次讲解HttpURLConnection请求https处理方式，过程其实差不多，具体的有一点区别。

1、单向验证证书的https请求

首先获取SSLContext的对象，这是为了获取SSLSocketFactory的对象。

  1.  /**
  2.      * 获取Https的证书
  3.      * @param context Activity（fragment）的上下文
  4.      * @return SSL的上下文对象
  5.      */
  6.     private static SSLContext getSSLContext(Context context) {
  7.         SSLContext s_sSLContext = null;
  8.         if (null != s_sSLContext) {
  9.             return s_sSLContext;
  10.         }
  11.  
  12.         CertificateFactory certificateFactory = null;
  13.  
  14.         InputStream inputStream = null;
  15.         KeyStore keystore = null;
  16.         String tmfAlgorithm = null;
  17.         TrustManagerFactory trustManagerFactory = null;
  18.         try {
  19.             certificateFactory = CertificateFactory.getInstance("X.509");
  20.  
  21.             inputStream = context.getAssets().open("user.crt");//这里导入SSL证书文件
  22.             //            inputStream = context.getAssets().open("51p2b_server_bs.pem");//这里导入SSL证书文件
  23.  
  24.             Certificate ca = certificateFactory.generateCertificate(inputStream);
  25.  
  26.             keystore = KeyStore.getInstance(KeyStore.getDefaultType());
  27.             keystore.load(null, null);
  28.             keystore.setCertificateEntry("ca", ca);
  29.  
  30.             tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
  31.             trustManagerFactory = TrustManagerFactory.getInstance(tmfAlgorithm);
  32.             trustManagerFactory.init(keystore);
  33.  
  34.             // Create an SSLContext that uses our TrustManager
  35.             s_sSLContext = SSLContext.getInstance("TLS");
  36.             s_sSLContext.init(null, trustManagerFactory.getTrustManagers(), null);
  37.             return s_sSLContext;
  38.         } catch (CertificateException e) {
  39.             e.printStackTrace();
  40.         } catch (KeyManagementException e) {
  41.             e.printStackTrace();
  42.         } catch (NoSuchAlgorithmException e) {
  43.             e.printStackTrace();
  44.         } catch (KeyStoreException e) {
  45.             e.printStackTrace();
  46.         } catch (IOException e) {
  47.             e.printStackTrace();
  48.         }
  49.         return null;
  50.     }


接下来就是验证证书和请求的操作了 

  1.  public String httpGet(String httpUrl) {
  2.         BufferedReader input = null;
  3.         StringBuilder sb = null;
  4.         URL url = null;
  5.         HttpURLConnection con = null;
  6.         try {
  7.             url = new URL(httpUrl);
  8.             try {
  9.                 SSLContext sslContext = getSSLContext(activity);
  10.                 HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());
  11.                 HttpsURLConnection https= (HttpsURLConnection) url.openConnection();
  12.                 HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
  13.  
  14.                     @Override
  15.                     public boolean verify(String hostname, SSLSession sslsession) {
  16.  
  17.                         if("host".equals(hostname)){//判断域名是否和证书域名相等
  18.                             return true;
  19.                         } else {
  20.                             return false;
  21.                         }
  22.                     }});
  23.                 if (url.getProtocol().toLowerCase().equals("https")) {//判断是http还是https
  24.                     //https.setHostnameVerifier(DO_NOT_VERIFY);
  25.                     con = https;
  26.                 } else {
  27.                     con = (HttpURLConnection)url.openConnection();
  28.                 }
  29.                 input = new BufferedReader(new InputStreamReader(con.getInputStream()));
  30.                 sb = new StringBuilder();
  31.                 String s;
  32.                 while ((s = input.readLine()) != null) {
  33.                     sb.append(s).append("\n");
  34.                 }
  35.             } catch (IOException e) {
  36.                 e.printStackTrace();
  37.             }
  38.         } catch (MalformedURLException e1) {
  39.             e1.printStackTrace();
  40.         } finally {
  41.             // close buffered
  42.             if (input != null) {
  43.                 try {
  44.                     input.close();
  45.                 } catch (IOException e) {
  46.                     e.printStackTrace();
  47.                 }
  48.             }
  49.             // disconnecting releases the resources held by a connection so they may be closed or reused
  50.             if (con != null) {
  51.                 con.disconnect();
  52.             }
  53.         }
  54.  
  55.         return sb == null ? null : sb.toString();
  56.     }

2、信任所有证书的处理方式 

  1. /**
  2.      * 信任所有服务器，无需验证证书
  3.      */
  4.     private static void trustAllHosts() {
  5.         final String TAG = "trustAllHosts";
  6.         // Create a trust manager that does not validate certificate chains
  7.         TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
  8.  
  9.             public java.security.cert.X509Certificate[] getAcceptedIssuers() {
  10.                 return new java.security.cert.X509Certificate[] {};
  11.             }
  12.  
  13.             public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
  14.             }
  15.  
  16.             public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
  17.             }
  18.         } };
  19.  
  20.         // Install the all-trusting trust manager
  21.         try {
  22.             SSLContext sc = SSLContext.getInstance("TLS");
  23.             sc.init(null, trustAllCerts, new java.security.SecureRandom());
  24.             HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
  25.         } catch (Exception e) {
  26.             e.printStackTrace();
  27.         }
  28.     }


  1.  public String httpGet(String httpUrl) {
  2.         BufferedReader input = null;
  3.         StringBuilder sb = null;
  4.         URL url = null;
  5.         HttpURLConnection con = null;
  6.         try {
  7.             url = new URL(httpUrl);
  8.             try {
  9.                 // trust all hosts
  10.                 trustAllHosts();
  11.                 HttpsURLConnection https= (HttpsURLConnection) url.openConnection();
  12.                 HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
  13.  
  14.                     @Override
  15.                     public boolean verify(String hostname, SSLSession sslsession) {
  16.  
  17.                         if("host".equals(hostname)){
  18.                             return true;
  19.                         } else {
  20.                             return false;
  21.                         }
  22.                     }});
  23.                 if (url.getProtocol().toLowerCase().equals("https")) {
  24.                     https.setHostnameVerifier(DO_NOT_VERIFY);
  25.                     con = https;
  26.                 } else {
  27.                     con = (HttpURLConnection)url.openConnection();
  28.                 }
  29.                 input = new BufferedReader(new InputStreamReader(con.getInputStream()));
  30.                 sb = new StringBuilder();
  31.                 String s;
  32.                 while ((s = input.readLine()) != null) {
  33.                     sb.append(s).append("\n");
  34.                 }
  35.             } catch (IOException e) {
  36.                 e.printStackTrace();
  37.             }
  38.         } catch (MalformedURLException e1) {
  39.             e1.printStackTrace();
  40.         } finally {
  41.             // close buffered
  42.             if (input != null) {
  43.                 try {
  44.                     input.close();
  45.                 } catch (IOException e) {
  46.                     e.printStackTrace();
  47.                 }
  48.             }
  49.             // disconnecting releases the resources held by a connection so they may be closed or reused
  50.             if (con != null) {
  51.                 con.disconnect();
  52.             }
  53.         }
  54.  
  55.         return sb == null ? null : sb.toString();
  56.     }
  57.     final static HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {
  58.  
  59.         public boolean verify(String hostname, SSLSession session) {
  60.             return true;
  61.         }
  62.     };

这样就不必验证证书了。

3、双向验证证书的操作

  1. public class HttpsPost {
  2.     /**
  3.      * 获得KeyStore.
  4.      * @param keyStorePath
  5.      *            密钥库路径
  6.      * @param password
  7.      *            密码
  8.      * @return 密钥库
  9.      * @throws Exception
  10.      */
  11.     public static KeyStore getKeyStore(String password, String keyStorePath)
  12.             throws Exception {
  13.         // 实例化密钥库
  14.         KeyStore ks = KeyStore.getInstance("JKS");
  15.         // 获得密钥库文件流
  16.         FileInputStream is = new FileInputStream(keyStorePath);
  17.         // 加载密钥库
  18.         ks.load(is, password.toCharArray());
  19.         // 关闭密钥库文件流
  20.         is.close();
  21.         return ks;
  22.     }
  23.  
  24.     /**
  25.      * 获得SSLSocketFactory.
  26.      * @param password
  27.      *            密码
  28.      * @param keyStorePath
  29.      *            密钥库路径
  30.      * @param trustStorePath
  31.      *            信任库路径
  32.      * @return SSLSocketFactory
  33.      * @throws Exception
  34.      */
  35.     public static SSLContext getSSLContext(String password,
  36.             String keyStorePath, String trustStorePath) throws Exception {
  37.         // 实例化密钥库
  38.         KeyManagerFactory keyManagerFactory = KeyManagerFactory
  39.                 .getInstance(KeyManagerFactory.getDefaultAlgorithm());
  40.         // 获得密钥库
  41.         KeyStore keyStore = getKeyStore(password, keyStorePath);
  42.         // 初始化密钥工厂
  43.         keyManagerFactory.init(keyStore, password.toCharArray());
  44.  
  45.         // 实例化信任库
  46.         TrustManagerFactory trustManagerFactory = TrustManagerFactory
  47.                 .getInstance(TrustManagerFactory.getDefaultAlgorithm());
  48.         // 获得信任库
  49.         KeyStore trustStore = getKeyStore(password, trustStorePath);
  50.         // 初始化信任库
  51.         trustManagerFactory.init(trustStore);
  52.         // 实例化SSL上下文
  53.         SSLContext ctx = SSLContext.getInstance("TLS");
  54.         // 初始化SSL上下文
  55.         ctx.init(keyManagerFactory.getKeyManagers(),
  56.                 trustManagerFactory.getTrustManagers(), null);
  57.         // 获得SSLSocketFactory
  58.         return ctx;
  59.     }
  60.  
  61.     /**
  62.      * 初始化HttpsURLConnection.
  63.      * @param password
  64.      *            密码
  65.      * @param keyStorePath
  66.      *            密钥库路径
  67.      * @param trustStorePath
  68.      *            信任库路径
  69.      * @throws Exception
  70.      */
  71.     public static void initHttpsURLConnection(String password,
  72.             String keyStorePath, String trustStorePath) throws Exception {
  73.         // 声明SSL上下文
  74.         SSLContext sslContext = null;
  75.         // 实例化主机名验证接口
  76.         HostnameVerifier hnv = new MyHostnameVerifier();
  77.         try {
  78.             sslContext = getSSLContext(password, keyStorePath, trustStorePath);
  79.         } catch (GeneralSecurityException e) {
  80.             e.printStackTrace();
  81.         }
  82.         if (sslContext != null) {
  83.             HttpsURLConnection.setDefaultSSLSocketFactory(sslContext
  84.                     .getSocketFactory());
  85.         }
  86.         HttpsURLConnection.setDefaultHostnameVerifier(hnv);
  87.     }
  88.  
  89.     /**
  90.      * 发送请求.
  91.      * @param httpsUrl
  92.      *            请求的地址
  93.      * @param xmlStr
  94.      *            请求的数据
  95.      */
  96.     public static void post(String httpsUrl, String xmlStr) {
  97.         HttpsURLConnection urlCon = null;
  98.         try {
  99.             urlCon = (HttpsURLConnection) (new URL(httpsUrl)).openConnection();
  100.             urlCon.setDoInput(true);
  101.             urlCon.setDoOutput(true);
  102.             urlCon.setRequestMethod("POST");
  103.             urlCon.setRequestProperty("Content-Length",
  104.                     String.valueOf(xmlStr.getBytes().length));
  105.             urlCon.setUseCaches(false);
  106.             //设置为gbk可以解决服务器接收时读取的数据中文乱码问题
  107.             urlCon.getOutputStream().write(xmlStr.getBytes("gbk"));
  108.             urlCon.getOutputStream().flush();
  109.             urlCon.getOutputStream().close();
  110.             BufferedReader in = new BufferedReader(new InputStreamReader(
  111.                     urlCon.getInputStream()));
  112.             String line;
  113.             while ((line = in.readLine()) != null) {
  114.                 System.out.println(line);
  115.             }
  116.         } catch (MalformedURLException e) {
  117.             e.printStackTrace();
  118.         } catch (IOException e) {
  119.             e.printStackTrace();
  120.         } catch (Exception e) {
  121.             e.printStackTrace();
  122.         }
  123.     }
  124.  
  125.     /**
  126.      * 测试方法.
  127.      * @param args
  128.      * @throws Exception
  129.      */
  130.     public static void main(String[] args) throws Exception {
  131.         // 密码
  132.         String password = "123456";
  133.         // 密钥库
  134.         String keyStorePath = "tomcat.keystore";
  135.         // 信任库
  136.         String trustStorePath = "tomcat.keystore";
  137.         // 本地起的https服务
  138.         String httpsUrl = "https://localhost:8443/service/httpsPost";
  139.         // 传输文本
  140.         String xmlStr = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><fruitShop><fruits><fruit><kind>萝卜</kind></fruit><fruit><kind>菠萝</kind></fruit></fruits></fruitShop>";
  141.         HttpsPost.initHttpsURLConnection(password, keyStorePath, trustStorePath);
  142.         // 发起请求
  143.         HttpsPost.post(httpsUrl, xmlStr);
  144.     }
  145. }public class HttpsPost {
  146.     /**
  147.      * 获得KeyStore.
  148.      * @param keyStorePath
  149.      *            密钥库路径
  150.      * @param password
  151.      *            密码
  152.      * @return 密钥库
  153.      * @throws Exception
  154.      */
  155.     public static KeyStore getKeyStore(String password, String keyStorePath)
  156.             throws Exception {
  157.         // 实例化密钥库
  158.         KeyStore ks = KeyStore.getInstance("JKS");
  159.         // 获得密钥库文件流
  160.         FileInputStream is = new FileInputStream(keyStorePath);
  161.         // 加载密钥库
  162.         ks.load(is, password.toCharArray());
  163.         // 关闭密钥库文件流
  164.         is.close();
  165.         return ks;
  166.     }
  167.  
  168.     /**
  169.      * 获得SSLSocketFactory.
  170.      * @param password
  171.      *            密码
  172.      * @param keyStorePath
  173.      *            密钥库路径
  174.      * @param trustStorePath
  175.      *            信任库路径
  176.      * @return SSLSocketFactory
  177.      * @throws Exception
  178.      */
  179.     public static SSLContext getSSLContext(String password,
  180.             String keyStorePath, String trustStorePath) throws Exception {
  181.         // 实例化密钥库
  182.         KeyManagerFactory keyManagerFactory = KeyManagerFactory
  183.                 .getInstance(KeyManagerFactory.getDefaultAlgorithm());
  184.         // 获得密钥库
  185.         KeyStore keyStore = getKeyStore(password, keyStorePath);
  186.         // 初始化密钥工厂
  187.         keyManagerFactory.init(keyStore, password.toCharArray());
  188.  
  189.         // 实例化信任库
  190.         TrustManagerFactory trustManagerFactory = TrustManagerFactory
  191.                 .getInstance(TrustManagerFactory.getDefaultAlgorithm());
  192.         // 获得信任库
  193.         KeyStore trustStore = getKeyStore(password, trustStorePath);
  194.         // 初始化信任库
  195.         trustManagerFactory.init(trustStore);
  196.         // 实例化SSL上下文
  197.         SSLContext ctx = SSLContext.getInstance("TLS");
  198.         // 初始化SSL上下文
  199.         ctx.init(keyManagerFactory.getKeyManagers(),
  200.                 trustManagerFactory.getTrustManagers(), null);
  201.         // 获得SSLSocketFactory
  202.         return ctx;
  203.     }
  204.  
  205.     /**
  206.      * 初始化HttpsURLConnection.
  207.      * @param password
  208.      *            密码
  209.      * @param keyStorePath
  210.      *            密钥库路径
  211.      * @param trustStorePath
  212.      *            信任库路径
  213.      * @throws Exception
  214.      */
  215.     public static void initHttpsURLConnection(String password,
  216.             String keyStorePath, String trustStorePath) throws Exception {
  217.         // 声明SSL上下文
  218.         SSLContext sslContext = null;
  219.         // 实例化主机名验证接口
  220.         HostnameVerifier hnv = new MyHostnameVerifier();
  221.         try {
  222.             sslContext = getSSLContext(password, keyStorePath, trustStorePath);
  223.         } catch (GeneralSecurityException e) {
  224.             e.printStackTrace();
  225.         }
  226.         if (sslContext != null) {
  227.             HttpsURLConnection.setDefaultSSLSocketFactory(sslContext
  228.                     .getSocketFactory());
  229.         }
  230.         HttpsURLConnection.setDefaultHostnameVerifier(hnv);
  231.     }
  232.  
  233.     /**
  234.      * 发送请求.
  235.      * @param httpsUrl
  236.      *            请求的地址
  237.      * @param xmlStr
  238.      *            请求的数据
  239.      */
  240.     public static void post(String httpsUrl, String xmlStr) {
  241.         HttpsURLConnection urlCon = null;
  242.         try {
  243.             urlCon = (HttpsURLConnection) (new URL(httpsUrl)).openConnection();
  244.             urlCon.setDoInput(true);
  245.             urlCon.setDoOutput(true);
  246.             urlCon.setRequestMethod("POST");
  247.             urlCon.setRequestProperty("Content-Length",
  248.                     String.valueOf(xmlStr.getBytes().length));
  249.             urlCon.setUseCaches(false);
  250.             //设置为gbk可以解决服务器接收时读取的数据中文乱码问题
  251.             urlCon.getOutputStream().write(xmlStr.getBytes("gbk"));
  252.             urlCon.getOutputStream().flush();
  253.             urlCon.getOutputStream().close();
  254.             BufferedReader in = new BufferedReader(new InputStreamReader(
  255.                     urlCon.getInputStream()));
  256.             String line;
  257.             while ((line = in.readLine()) != null) {
  258.                 System.out.println(line);
  259.             }
  260.         } catch (MalformedURLException e) {
  261.             e.printStackTrace();
  262.         } catch (IOException e) {
  263.             e.printStackTrace();
  264.         } catch (Exception e) {
  265.             e.printStackTrace();
  266.         }
  267.     }
  268.  
  269.     /**
  270.      * 测试方法.
  271.      * @param args
  272.      * @throws Exception
  273.      */
  274.     public static void main(String[] args) throws Exception {
  275.         // 密码
  276.         String password = "123456";
  277.         // 密钥库
  278.         String keyStorePath = "tomcat.keystore";
  279.         // 信任库
  280.         String trustStorePath = "tomcat.keystore";
  281.         // 本地起的https服务
  282.         String httpsUrl = "https://localhost:8443/service/httpsPost";
  283.         // 传输文本
  284.         String xmlStr = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><fruitShop><fruits><fruit><kind>萝卜</kind></fruit><fruit><kind>菠萝</kind></fruit></fruits></fruitShop>";
  285.         HttpsPost.initHttpsURLConnection(password, keyStorePath, trustStorePath);
  286.         // 发起请求
  287.         HttpsPost.post(httpsUrl, xmlStr);
  288.     }
  289. }


4、如果你用的xutils3的框架， params.setSslSocketFactory(sslContext.getSocketFactory());这个方法认证证书

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号