Android okhttp访问https的问题

最新推荐文章于 2025-07-23 12:04:03 发布

原创最新推荐文章于 2025-07-23 12:04:03 发布 · 1.2k 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#Android #ssl #https #okhttp

Android 专栏收录该内容

2 篇文章

订阅专栏

本文介绍了Android访问HTTPS时的SSL校验原理，包括证书的所有者校验、颁发者比对、签名解密等步骤。针对Android可能出现的证书异常情况，提供了添加自定义证书的代码示例和操作指南，帮助解决证书未知、自签署和缺少中间CA等问题。

原理

https相比于http，多了ssl层，并且在我们访问的时候，是需要证书来校验的。一般的流程是这样的：
（1）首先浏览器读取证书中的证书所有者、有效期等信息进行一一校验
（2）浏览器开始查找操作系统中已内置的受信任的证书发布机构CA，与服务器发来的证书中的颁发者CA比对，用于校验证书是否为合法机构颁发
（3）如果找不到，浏览器就会报错，说明服务器发来的证书是不可信任的。
（4）如果找到，那么浏览器就会从操作系统中取出颁发者CA 的公钥，然后对服务器发来的证书里面的签名进行解密
（5）浏览器使用相同的hash算法计算出服务器发来的证书的hash值，将这个计算的hash值与证书中签名做对比
（6）对比结果一致，则证明服务器发来的证书合法，没有被冒充
（7）此时浏览器就可以读取证书中的公钥，用于后续加密了

对于我们Android来说，从 Android 4.2 开始，Android系统包含了100 多个 CA证书，所以我们在访问某些https网站时，不需要再自己添加CA。
但是某些情况下，我们还是会出现如下异常：

javax.net.ssl.SSLHandshakeException: java.security.cert.CertPathValidatorException: Trust anchor for certification path not found.
        at org.apache.harmony.xnet.provider.jsse.OpenSSLSocketImpl.startHandshake(OpenSSLSocketImpl.java:374)
        at libcore.net.http.HttpConnection.setupSecureSocket(HttpConnection.java:209)
        at libcore.net.http.HttpsURLConnectionImpl$HttpsEngine.makeSslConnection(HttpsURLConnectionImpl.java:478)
        at libcore.net.http.HttpsURLConnectionImpl$HttpsEngine.connect(HttpsURLConnectionImpl.java:433)
        at libcore.net.http.HttpEngine.sendSocketRequest(HttpEngine.java:290)
        at libcore.net.http.HttpEngine.sendRequest(HttpEngine.java:240)
        at libcore.net.http.HttpURLConnectionImpl.getResponse(HttpURLConnectionImpl.java:282)
        at libcore.net.http.HttpURLConnectionImpl.getInputStream(HttpURLConnectionImpl.java:177)
        at libcore.net.http.HttpsURLConnectionImpl.getInputStream(HttpsURLConnectionImpl.java:271)

原因有以下三点:
1、颁发服务器证书的 CA 未知
2、服务器证书不是由 CA 签署的，而是自签署
3、服务器配置缺少中间 CA

这三种情况下都有一个相同的解决办法，那就是在请求前添加自己的证书：

2、Code

（1）证书工具类：


import android.util.Log;
import java.io.IOException;
import java.io.InputStream;
import java.security.GeneralSecurityException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.NoSuchAlgorithmException;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.util.Arrays;
import java.util.Collection;

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;

import okio.Buffer;

public class HttpsManager {
    private static HttpsManager instance;
    private static X509TrustManager trustManager;
    private static SSLSocketFactory sslSocketFactory;

    private HttpsManager(){
        setSocketFactory();
    }

    public static HttpsManager getInstance(){
        if (instance==null){
            instance = new HttpsManager();
        }
        return instance;
    }

    private void setSocketFactory() {
        try {
            trustManager = trustManagerForCertificates(trustedCertificatesInputStream());
            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, new TrustManager[]{trustManager}, null);
            sslSocketFactory = sslContext.getSocketFactory();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (GeneralSecurityException e) {
            e.printStackTrace();
        }
    }

    public X509TrustManager getManager(){
        return trustManager;
    }

    public SSLSocketFactory getSslSocketFactory(){
        return sslSocketFactory;
    }

    private InputStream trustedCertificatesInputStream() {

        String servicesCertificationAuthority = ""
                +"-----BEGIN CERTIFICATE-----\n" +
                "content\n" +
                "-----END CERTIFICATE-----\n";
        String comodoRsaCertificationAuthority = ""
                + "-----BEGIN CERTIFICATE-----\n" +
                "content\n" +
                "-----END CERTIFICATE-----\n";
        String entrustRootCertificateAuthority = ""
                + "-----BEGIN CERTIFICATE-----\n" +
                "content\n" +
                "-----END CERTIFICATE-----\n";
//        return new Buffer()
//                .writeUtf8(servicesCertificationAuthority)
//                .writeUtf8(comodoRsaCertificationAuthority)
//                .writeUtf8(entrustRootCertificateAuthority)
//                .inputStream();
        try {
            return MyApplication.ctx.getAssets().open("server.cer");
        } catch (IOException e) {
            Log.e("Error","Trans fail");
            return null;
        }
    }

    private X509TrustManager trustManagerForCertificates(InputStream in) throws
            GeneralSecurityException {
        CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
        Collection<? extends Certificate> certificates = certificateFactory.generateCertificates(in);
        if (certificates.isEmpty()) {
            throw new IllegalArgumentException("expected non-empty set of trusted certificates");
        }

        // Put the certificates a key store.
        char[] password = "password".toCharArray(); // Any password will work.
        KeyStore keyStore = newEmptyKeyStore(password);
        int index = 0;
        for (Certificate certificate : certificates) {
            String certificateAlias = Integer.toString(index++);
            keyStore.setCertificateEntry(certificateAlias, certificate);
        }

        // Use it to build an X509 trust manager.
        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(
                KeyManagerFactory.getDefaultAlgorithm());
        keyManagerFactory.init(keyStore, password);
        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(
                TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(keyStore);
        TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
        if (trustManagers.length != 1 || !(trustManagers[0] instanceof X509TrustManager)) {
            throw new IllegalStateException("Unexpected default trust managers:"
                    + Arrays.toString(trustManagers));
        }
        return (X509TrustManager) trustManagers[0];
    }

    private KeyStore newEmptyKeyStore(char[] password) throws GeneralSecurityException {
        try {
            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            InputStream in = null; // By convention, 'null' creates an empty key store.
            keyStore.load(in, password);
            return keyStore;
        } catch (IOException e) {
            throw new AssertionError(e);
        }
    }
}

（2）

这段代码来自于Okhttp代码示例，我自己做了一些修改。

这里解释一下 trustedCertificatesInputStream方法返回的是一个流，这个就是你自己的证书流，使用方式2种，一种是把cer证书文件打开，拷贝字符串，2是放在asserts文件夹下，获取出来。单例的话，你可以自己优化一下。

下面说一下如何从web页面导入证书：

1、在访问的页面点连接前的锁标志.
111

2、选择详细信息在这里插入图片描述

3、依次下一步，存到指定位置即可。在这里插入图片描述

这样导出的就是一个cer文件了，当然用notepad++打开会发现里面就是一些如字符串型的。

（3）使用方式：

        OkHttpClient.Builder builder = createClientBuilder();
        builder.sslSocketFactory(manager.getSslSocketFactory(), manager.getManager());

（4）next

接下来就快去请求https吧。如果还是不行，请叫上后台的老哥，问问他中间证书配置了没有，给你的证书正不正确。

3、结尾

说一下，其实一般CA颁发的证书都是可以访问的，要不就是服务器配置的问题，要不就是证书是自签的。

主要来源：
1、谷歌爸爸的Android开发者网址，中文的

2、一位大佬的-----HTTPS原理和CA证书申请