原作:https://blog.csdn.net/s003603u/article/details/53907910
該文章內容只是轉發(fā)

• • 前言
  • 簡介
  • HTTPS相關
    • 名詞解釋
    • 圖解HTTPS協(xié)議加密解密全過程
  • 異常解決
    • 問題描述
    • 原因
    • 分析
    • 解決方案
  • 參考鏈接

前言

在互聯(lián)網(wǎng)安全通信方式上，目前用的最多的就是https配合ssl和數(shù)字證書來保證傳輸和認證安全

簡介

• 結合okhttp實現(xiàn)https訪問脂凶，并解決其中遇到的問題
• okhttp默認情況下是支持https協(xié)議的，不過要注意的是戈毒，支持https的網(wǎng)站如果是CA機構頒發(fā)的證書艰猬，默認情況下是可以信任的。
• 使用Charles進行https抓包

HTTPS相關

名詞解釋

• https：在http(超文本傳輸協(xié)議)基礎上提出的一種安全的http協(xié)議埋市，因此可以稱為安全的超文本傳輸協(xié)議冠桃。http協(xié)議直接放置在TCP協(xié)議之上，而https提出在http和TCP中間加上一層加密層道宅。從發(fā)送端看食听，這一層負責把http的內容加密后送到下層的TCP，從接收方看污茵，這一層負責將TCP送來的數(shù)據(jù)解密還原成http的內容樱报。
• SSL(Secure Socket Layer)：是Netscape公司設計的主要用于WEB的安全傳輸協(xié)議。從名字就可以看出它在https協(xié)議棧中負責實現(xiàn)上面提到的加密層泞当。因此迹蛤，一個https協(xié)議棧大致是這樣的：

這里寫圖片描述

• 補充：IP（網(wǎng)絡層）、TCP（傳輸層）襟士，HTTP（應用層）盗飒，SSL處于TCP和HTTP之間
• 數(shù)字證書：一種文件的名稱，好比一個機構或人的簽名陋桂，能夠證明這個機構或人的真實性逆趣。其中包含的信息，用于實現(xiàn)上述功能嗜历。
• 加密和認證：加密是指通信雙方為了防止敏感信息在信道上被第三方竊聽而泄漏宣渗，將明文通過加密變成密文，如果第三方無法解密的話梨州，就算他獲得密文也無能為力痕囱；認證是指通信雙方為了確認對方是值得信任的消息發(fā)送或接受方，而不是使用假身份的騙子暴匠，采取的確認身份的方式鞍恢。只有同時進行了加密和認真才能保證通信的安全，因此在SSL通信協(xié)議中這兩者都很重要。

因此有序，這三者的關系已經(jīng)十分清楚了：https依賴一種實現(xiàn)方式抹腿，目前通用的是SSL，數(shù)字證書是支持這種安全通信的文件旭寿。另外有SSL衍生出TLS和WTLS警绩，前者是IEFT將SSL標準化之后產(chǎn)生的（TLS1.0），與SSL差別很小盅称，后者是用于無線環(huán)境下的TSL肩祥。

圖解HTTPS協(xié)議加密解密全過程

我們都知道HTTPS能夠加密信息，以免敏感信息被第三方獲取缩膝。所以很多銀行網(wǎng)站或電子郵箱等等安全級別較高的服務都會采用HTTPS協(xié)議混狠。

HTTPS其實是由兩部分組成：HTTP + SSL / TLS，也就是在HTTP上又加了一層處理加密信息的模塊疾层。服務端和客戶端的信息傳輸都會通過TLS進行加密将饺，所以傳輸?shù)臄?shù)據(jù)都是加密后的數(shù)據(jù)。具體是如何進行加密痛黎，解密予弧，驗證的，且看下圖湖饱。

這里寫圖片描述

• 客戶端發(fā)起HTTPS請求
  這個沒什么好說的掖蛤，就是用戶在瀏覽器里輸入一個https網(wǎng)址，然后連接到server的443端口井厌。
• 服務端的配置
  采用HTTPS協(xié)議的服務器必須要有一套數(shù)字證書蚓庭，可以自己制作，也可以向組織申請仅仆。區(qū)別就是自己頒發(fā)的證書需要客戶端驗證通過器赞，才可以繼續(xù)訪問，而使用受信任的公司申請的證書則不會彈出提示頁面(startssl就是個不錯的選擇蝇恶，有1年的免費服務)拳魁。這套證書其實就是一對公鑰和私鑰惶桐。如果對公鑰和私鑰不太理解撮弧，可以想象成一把鑰匙和一個鎖頭，只是全世界只有你一個人有這把鑰匙姚糊，你可以把鎖頭給別人贿衍，別人可以用這個鎖把重要的東西鎖起來，然后發(fā)給你救恨，因為只有你一個人有這把鑰匙贸辈，所以只有你才能看到被這把鎖鎖起來的東西。
• 傳送證書
  這個證書其實就是公鑰肠槽，只是包含了很多信息擎淤，如證書的頒發(fā)機構奢啥，過期時間等等。
• 客戶端解析證書
  這部分工作是有客戶端的TLS來完成的嘴拢，首先會驗證公鑰是否有效桩盲，比如頒發(fā)機構，過期時間等等席吴，如果發(fā)現(xiàn)異常赌结，則會彈出一個警告框，提示證書存在問題孝冒。如果證書沒有問題柬姚，那么就生成一個隨機值。然后用證書對該隨機值進行加密庄涡。就好像上面說的量承，把隨機值用鎖頭鎖起來，這樣除非有鑰匙穴店，不然看不到被鎖住的內容宴合。
• 傳送加密信息
  這部分傳送的是用證書加密后的隨機值，目的就是讓服務端得到這個隨機值迹鹅，以后客戶端和服務端的通信就可以通過這個隨機值來進行加密解密了卦洽。
• 服務端解密信息
  服務端用私鑰解密后，得到了客戶端傳過來的隨機值(私鑰)斜棚，然后把內容通過該值進行對稱加密阀蒂。所謂對稱加密就是，將信息和私鑰通過某種算法混合在一起弟蚀，這樣除非知道私鑰蚤霞，不然無法獲取內容，而正好客戶端和服務端都知道這個私鑰义钉，所以只要加密算法夠彪悍昧绣，私鑰夠復雜，數(shù)據(jù)就夠安全捶闸。
• 傳輸加密后的信息
  這部分信息是服務端用私鑰加密后的信息夜畴，可以在客戶端被還原。
• 客戶端解密信息
  客戶端用之前生成的私鑰解密服務端傳過來的信息删壮，于是獲取了解密后的內容贪绘。整個過程第三方即使監(jiān)聽到了數(shù)據(jù)，也束手無策央碟。

異常解決

問題描述

在4.x系統(tǒng)上通過HTTPS進行訪問產(chǎn)生如下異常：

• javax.net.ssl.SSLProtocolException: SSL handshake aborted: ssl=0x65bc0ad8: Failure in SSL library, usually a protocol error
  error:1407743E:SSL routines:SSL23_GET_SERVER_HELLO:tlsv1 alert inappropriate fallback (external/openssl/ssl/s23_clnt.c:744 0x5cf4ed74:0x00000000)

原因

Android4.x系統(tǒng)對TLS的支持存在版本差異税灌，具體細節(jié)請看以下分析

分析

首先我們查看一下Google關于SSLEngine的官方文檔說明

這里截取不同Android版本針對于TLS協(xié)議的默認配置圖如下：

這里寫圖片描述

從上圖可以得出如下結論：

• TLSv1.0從API 1+就被默認打開
• TLSv1.1和TLSv1.2只有在API 20+ 才會被默認打開
• 也就是說低于API 20+的版本是默認關閉對TLSv1.1和TLSv1.2的支持，若要支持則必須自己打開

有了以上關于Android SSLEngine相關知識的鋪墊，讓我們來測試一下這次目標案例的域名 fort.sports.baofeng.com

我們可以在QUALYS SSL LABS測試它對ssl支持的版本
這里截取SSL報告中對我們有用的一部分菱涤，如下圖

這里寫圖片描述

• 剛開始服務器配置只支持TLS1.2苞也，SSL報告的結果也驗證了這一點
• 可以看出大部分2.x、4.x的Android系統(tǒng)都會報Server sent fatal alert：handshake_failure,而5.0粘秆、6.0墩朦、7.0的Android系統(tǒng)在Hanshake Simulation中表現(xiàn)正常，因為它們支持TLS1.2

這就能解釋為什么大部分4.xAndroid系統(tǒng)在進行HTTPS訪問時產(chǎn)生上述異常

解決方案

• 我們首先想到的是翻擒，可以讓服務器配置兼容支持TLS1.0氓涣、TLS1.1、TLS1.2陋气，這樣客戶端就不需要做任何處理劳吠，完美兼容
• 經(jīng)過測試，這個是可以的（測試手機包括Lenovo K920 4.4.2巩趁，Lenovo K30-E 4.4.4）

我們再次查看SSL報告中的幾個關鍵結果：

這里寫圖片描述

從上圖可以看出痒玩，服務器配置已經(jīng)可以支持TLS1.0、TLS1.1议慰、TLS1.2
從下圖可以看出蠢古，Handshake Simulation在Android 4.x系統(tǒng)也可以正常運作了

這里寫圖片描述

或許，你以為這樣就完美了别凹，但是草讶，你有沒有想到過這樣一種情況，當你所訪問的域名服務器只支持TLS1.2炉菲，那Android4.x系統(tǒng)應該如何應對那

答案：想辦法讓Android4.x打開對TLS1.1堕战、TLS1.2的支持

• 假設你的網(wǎng)絡請求庫使用的是okhttp，在APP中可以這樣初始化OkHttpClient拍霜，這里通過在AppParams中配置isBypassAuthen嘱丢，來判斷是否繞過認證，也就是無條件信任所有HTTPS網(wǎng)站
• 這里只是 單向認證 客戶端對服務端證書的單向認證

private void initHttpsClient() {
        OkHttpClient.Builder builder = new OkHttpClient.Builder() .connectTimeout(30000L, TimeUnit.MILLISECONDS)
                .readTimeout(30000L, TimeUnit.MILLISECONDS)
                .addInterceptor(new LoggerInterceptor("OkHttpClient"))
                .hostnameVerifier(new HostnameVerifier() {
                    @Override
                    public boolean verify(String hostname, SSLSession session) {
                        return true;
                    }
                });
        if(AppParams.isBypassAuthen){
            HttpsUtils.SSLParams sslParams = HttpsUtils.getSslSocketFactory(null, null, null);
            builder.sslSocketFactory(sslParams.sSLSocketFactory, sslParams.trustManager);
        }else{
            SSLContext sslContext = null;
            try {
                sslContext = SSLContext.getInstance("TLS");
                try {
                    sslContext.init(null, null, null);
                } catch (KeyManagementException e) {
                    e.printStackTrace();
                }
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }

            SSLSocketFactory socketFactory = new Tls12SocketFactory(sslContext.getSocketFactory());
            builder.sslSocketFactory(socketFactory,new HttpsUtils.UnSafeTrustManager());
        }
        OkHttpClient okHttpClient = builder
                .build();
        OkHttpUtils.initClient(okHttpClient);
    }

具體怎么使用HTTPS祠饺，參考HttpsUtils：

public class HttpsUtils
{
    public static class SSLParams
    {
        public SSLSocketFactory sSLSocketFactory;
        public X509TrustManager trustManager;
    }

    public static SSLParams getSslSocketFactory(InputStream[] certificates, InputStream bksFile, String password)
    {
        SSLParams sslParams = new SSLParams();
        try
        {
            TrustManager[] trustManagers = prepareTrustManager(certificates);
            KeyManager[] keyManagers = prepareKeyManager(bksFile, password);
            SSLContext sslContext = SSLContext.getInstance("TLS");
            X509TrustManager trustManager = null;
            if (trustManagers != null)
            {
                trustManager = new MyTrustManager(chooseTrustManager(trustManagers));
            } else
            {
                trustManager = new UnSafeTrustManager();
            }
            sslContext.init(keyManagers, new TrustManager[]{trustManager},null);
            sslParams.sSLSocketFactory = sslContext.getSocketFactory();
            sslParams.trustManager = trustManager;
            return sslParams;
        } catch (NoSuchAlgorithmException e)
        {
            throw new AssertionError(e);
        } catch (KeyManagementException e)
        {
            throw new AssertionError(e);
        } catch (KeyStoreException e)
        {
            throw new AssertionError(e);
        }
    }

    private class UnSafeHostnameVerifier implements HostnameVerifier
    {
        @Override
        public boolean verify(String hostname, SSLSession session)
        {
            return true;
        }
    }

    public static class UnSafeTrustManager implements X509TrustManager
    {
        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType)
                throws CertificateException
        {
        }

        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType)
                throws CertificateException
        {
        }

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

    private static TrustManager[] prepareTrustManager(InputStream... certificates)
    {
        if (certificates == null || certificates.length <= 0) return null;
        try
        {

            CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            keyStore.load(null);
            int index = 0;
            for (InputStream certificate : certificates)
            {
                String certificateAlias = Integer.toString(index++);
                keyStore.setCertificateEntry(certificateAlias, certificateFactory.generateCertificate(certificate));
                try
                {
                    if (certificate != null)
                        certificate.close();
                } catch (IOException e)

                {
                }
            }
            TrustManagerFactory trustManagerFactory = null;

            trustManagerFactory = TrustManagerFactory.
                    getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustManagerFactory.init(keyStore);

            TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();

            return trustManagers;
        } catch (NoSuchAlgorithmException e)
        {
            e.printStackTrace();
        } catch (CertificateException e)
        {
            e.printStackTrace();
        } catch (KeyStoreException e)
        {
            e.printStackTrace();
        } catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;

    }

    private static KeyManager[] prepareKeyManager(InputStream bksFile, String password)
    {
        try
        {
            if (bksFile == null || password == null) return null;

            KeyStore clientKeyStore = KeyStore.getInstance("BKS");
            clientKeyStore.load(bksFile, password.toCharArray());
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(clientKeyStore, password.toCharArray());
            return keyManagerFactory.getKeyManagers();

        } catch (KeyStoreException e)
        {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e)
        {
            e.printStackTrace();
        } catch (UnrecoverableKeyException e)
        {
            e.printStackTrace();
        } catch (CertificateException e)
        {
            e.printStackTrace();
        } catch (IOException e)
        {
            e.printStackTrace();
        } catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }

    private static X509TrustManager chooseTrustManager(TrustManager[] trustManagers)
    {
        for (TrustManager trustManager : trustManagers)
        {
            if (trustManager instanceof X509TrustManager)
            {
                return (X509TrustManager) trustManager;
            }
        }
        return null;
    }

    private static class MyTrustManager implements X509TrustManager
    {
        private X509TrustManager defaultTrustManager;
        private X509TrustManager localTrustManager;

        public MyTrustManager(X509TrustManager localTrustManager) throws NoSuchAlgorithmException, KeyStoreException
        {
            TrustManagerFactory var4 = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            var4.init((KeyStore) null);
            defaultTrustManager = chooseTrustManager(var4.getTrustManagers());
            this.localTrustManager = localTrustManager;
        }

        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException
        {

        }

        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException
        {
            try
            {
                defaultTrustManager.checkServerTrusted(chain, authType);
            } catch (CertificateException ce)
            {
                localTrustManager.checkServerTrusted(chain, authType);
            }
        }

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

自行實現(xiàn)SSLSocketFactory 越驻，實現(xiàn)對TLSv1.1、TLSv1.2的支持

public class Tls12SocketFactory extends SSLSocketFactory {
    private static final String[] TLS_SUPPORT_VERSION = {"TLSv1.1", "TLSv1.2"};

    final SSLSocketFactory delegate;

    public Tls12SocketFactory(SSLSocketFactory base) {
        this.delegate = base;
    }

    @Override
    public String[] getDefaultCipherSuites() {
        return delegate.getDefaultCipherSuites();
    }

    @Override
    public String[] getSupportedCipherSuites() {
        return delegate.getSupportedCipherSuites();
    }

    @Override
    public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException {
        return patch(delegate.createSocket(s, host, port, autoClose));
    }

    @Override
    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
        return patch(delegate.createSocket(host, port));
    }

    @Override
    public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException, UnknownHostException {
        return patch(delegate.createSocket(host, port, localHost, localPort));
    }

    @Override
    public Socket createSocket(InetAddress host, int port) throws IOException {
        return patch(delegate.createSocket(host, port));
    }

    @Override
    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {
        return patch(delegate.createSocket(address, port, localAddress, localPort));
    }

    private Socket patch(Socket s) {
        if (s instanceof SSLSocket) {
            ((SSLSocket) s).setEnabledProtocols(TLS_SUPPORT_VERSION);
        }
        return s;
    }
}