Android平台实现双向证书(https)验证简单说明

最新推荐文章于 2023-10-12 10:43:46 发布
最新推荐文章于 2023-10-12 10:43:46 发布
阅读量5.7k 收藏 11
点赞数 1
分类专栏： android 文章标签： android 双向认证 ssl 证书转换 openssl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huweijian5/article/details/79365439
版权

Android平台实现双向证书(https)验证简单说明

前言

  • Android端实现双向认证的难点主要在于Android接受的证书格式是BKS，而一般提供的证书不包含此格式,需要手动转换
  • 转换之后如果请求不了，表现为握手失败（Handshake failed），则一般是证书转换错误
  • 网上有一大堆转换方法，有的虽能正常生成BKS证书，但还是导致握手失败，推测应该还是转换方式有误
  • 在这里提供一种自己亲自试验过能正常转换的方法供大家参考

证书转换

使用转换工具

  • 在这里提供一个比较好用的转换工具Portecle
  • 下载完后解压双击start.bat即可使用，至于详细使用请自行百度
  • 使用此工具可以很方便地将jks转为bks

通过openssl和keytool转换

  • openssl可以到官网下载,openssl暂时没有windows版，大伙可以在此处下载Win32OpenSSLwindows版本
  • 下载完记得配置环境变量，同时也记得配置jdk的环境变量，因为后面需要用到keytool命令
  • 现在假设你拿到了客户端证书client.crt和client.key（或者client.pem和client.key）
  • 通过以下命令生成pfx文件,期间会让输入密码，输入你想要的密码即可，假如这里输入的是123456

openssl pkcs12 -export -out client.pfx -inkey client.key -in client.pem
或者
openssl pkcs12 -export -out client.pfx -inkey client.key -in client.crt

  • 执行成功则可以看到client.pfx文件，接着再执行如下命令

keytool -importkeystore -srckeystore client.pfx -destkeystore client.jks -srcstoretype PKCS12 -deststoretype JKS

  • 执行成功即可看到生成了client.jks
  • 拿到生成的jks就可以通过Portecle工具转换成bks了

代码实现

SSLHelper.java

import android.content.Context;

import java.io.IOException;
import java.io.InputStream;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;

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

public class SSLHelper {
    private static final String TAG = "SSLHelper";
    private final static String CLIENT_PRI_KEY = "client.bks";
    private final static String TRUSTSTORE_PUB_KEY = "ca.bks";
    private final static String CLIENT_BKS_PASSWORD = "123456";
    private final static String TRUSTSTORE_BKS_PASSWORD = "123456";
    private final static String KEYSTORE_TYPE = "BKS";
    private final static String PROTOCOL_TYPE = "TLS";
    private final static String CERTIFICATE_STANDARD = "X509";

    public static SSLSocketFactory getSSLCertifcation(Context context) {
        SSLSocketFactory sslSocketFactory = null;
        try {
            // 服务器端需要验证的客户端证书，其实就是客户端的keystore
            KeyStore keyStore = KeyStore.getInstance(KEYSTORE_TYPE);
            // 客户端信任的服务器端证书
            KeyStore trustStore = KeyStore.getInstance(KEYSTORE_TYPE);

            //读取证书
            InputStream ksIn = context.getAssets().open(CLIENT_PRI_KEY);
            InputStream tsIn = context.getAssets().open(TRUSTSTORE_PUB_KEY);

            //加载证书
            keyStore.load(ksIn, CLIENT_BKS_PASSWORD.toCharArray());
            trustStore.load(tsIn, TRUSTSTORE_BKS_PASSWORD.toCharArray());
            ksIn.close();
            tsIn.close();


            TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(CERTIFICATE_STANDARD);
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(CERTIFICATE_STANDARD);
            trustManagerFactory.init(trustStore);
            keyManagerFactory.init(keyStore, CLIENT_BKS_PASSWORD.toCharArray());

            //初始化SSLContext
            SSLContext sslContext = SSLContext.getInstance(PROTOCOL_TYPE);
            sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), new java.security.SecureRandom());

            sslSocketFactory = sslContext.getSocketFactory();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (CertificateException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (UnrecoverableKeyException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
        return sslSocketFactory;
    }
}
  • HttpsUtil.java
import java.io.IOException;
import java.io.InputStream;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;
public class HttpsUtil {  
  
    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);  
        }  
    }

    public static 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 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];  
        }  
    }  
  
}
  • retrofit调用
		//创建日志拦截器，用于日志打印
        HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
        interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        //创建okhttp
        OkHttpClient httpClient = new OkHttpClient().newBuilder()
                .addInterceptor(interceptor)
                .sslSocketFactory(SSLHelper.getSSLCertifcation(this), new HttpsUtil.UnSafeTrustManager())
                .hostnameVerifier(new HttpsUtil.UnSafeHostnameVerifier())//由于还没有域名，此处设置忽略掉域名校验
                .build();
         //创建retrofit       
        String baseUrl = "https://180.101.147.89:8743/";
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(baseUrl)
                .client(httpClient)
                //.addConverterFactory(GsonConverterFactory.create())
                .addConverterFactory(ScalarsConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .build();
  • 顺便贴下依赖build.gradle
apply plugin: 'com.android.application'

android {
...
}
dependencies {
    ...

    //retrofit
    implementation "com.squareup.retrofit2:retrofit:2.3.0"
    implementation "com.squareup.retrofit2:converter-scalars:2.3.0"
    implementation "com.squareup.retrofit2:converter-gson:2.3.0"
    implementation "com.squareup.okhttp3:logging-interceptor:3.8.1"    
}

参考

  • http://blog.csdn.net/zhangyong125/article/details/50402183
hijunmeng
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
keytool证书工具详解（二）
u013083465的专栏
04-23 674
keytool证书工具详解（二）
Android HTTPS 自制证书实现双向认证(OkHttp + Retrofit + Rxjava)
Enweitech Software Works
12-22 3176
由于最近要做一个安全性比较高的项目，因此需要用到HTTPS进行双向认证。由于设计项目架构的时候，客户端是采用MVVM架构，基于DataBinding + Retrofit + Rxjava来实现Android端。 查阅很多资料，基于原生HttpClient实现双向认证的例子很多，但对于Retrofit的资料网上还是比较少，官方文档也是一句带过，没有具体的介绍。 看了 《Android中ht
android ssl证书验证
11-15
android ssl证书验证
Android OkHttp进行单向证书校验（双向的需要服务端也配置证书）
蓝色的天空的博客
05-31 2661
1.获取跟域名的证书文件 例如接口服务域名是 https://www.baidu.com/ 按照以下步骤导出证书信息，选择base64格式的.cer文件，用文本编辑器打开，复制证书信息 2.编写代码配置 // 证书信息进行缩减 private String CER_BAIDU = "xxxxxxxxxx"; //设置安全证书 public void setSafeOkHttpClient(OkHttpClient.Builder okhttpBuilder) { try {
Android https证书校验、防抓包
最新发布
conerconced的博客
10-12 1371
android https证书校验，防抓包
android https 双向认证,android okhttps双向验证
weixin_33173126的博客
05-27 290
使用：public void getHttps() {try {OkHttpClient mOkHttpClient = null;mOkHttpClient = new OkHttpClient().newBuilder()// 主要就是下面2句，其他的和正常请求都一样的.hostnameVerifier(new Home())//忽略服务器域名不信任警告....
Android签名证书文件的解析和签名校验的加强
01-10
Android签名证书文件的解析和签名校验的加强
IOS,Android SSL双向认证HTTPS方式请求及配置证书
12-19
本文将详细介绍`IOS`和`Android`平台上如何实现`SSL`双向认证以及配置证书。 首先，理解`SSL`双向认证的概念。常规的`SSL`单向认证中，服务器会验证客户端的身份，但客户端并不验证服务器的身份。而在双向认证中，...
android https 双向验证
05-11
首先，我们需要加载Keystore文件，然后创建TrustManager和KeyManager，它们分别用于处理服务器的证书验证和客户端的证书。最后，使用这些管理器初始化SSLContext。 ```java // 加载Keystore KeyStore keyStore = ...
Android TLS1.2双向认证demo
08-15
总结来说，实现Android与PC之间的TLS1.2双向认证涉及证书的生成、服务器和客户端的配置，以及安全连接的建立。通过这一系列步骤，我们可以提高应用的安全性，保护用户数据，防止未经授权的访问。在实际开发中，还...
Android SSL证书验证原理
08-25
Android SSL验证原理
jks转为bks
10-11
jks转化成bks BKS来自BouncyCastleProvider，它使用的也是TripleDES来保护密钥库中的Key，它能够防止证书库被不小心修改（Keystore的keyentry改掉1个bit都会产生错误），BKS能够跟JKS互操作。 JKS和JCEKS是Java密钥库(KeyStore)的两种比较常见类型，JKS的Provider是SUN，在每个版本的JDK中都有，JCEKS的Provider是SUNJCE，1.4后我们都能够直接使用它。 JCEKS在安全级别上要比JKS强，使用的Provider是JCEKS(推荐)，尤其在保护KeyStore中的私钥上（使用TripleDES） PFX（PKCS#12）是公钥加密标准，它规定了可包含所有私钥、公钥和证书。其以二进制格式存储，在windows中可以直接导入到密钥区，注意，PKCS#12的密钥库保护密码同时也用于保护Key。 UBER 比较特别，当密码是通过命令行提供的时候，它只能跟keytool交互。整个keystore是通过PBE/SHA1/Twofish加密，因此 keystore能够防止被误改、察看以及校验。SunJDK允许你在不提供密码的情况下直接加载一个Keystore，类似cacerts，UBER不 允许这种情况。
Nginx ssl双向认证包含移动端和PC端证书生成
Angus博客
04-04 3053
1：制作CA私钥,在根目录创建一个cert文件夹然后执行 openssl genrsa -out ca.key 2048 2：制作CA公钥/根证书 openssl req -new -x509 -days 3650 -key ca.key -out ca.crt Common Name 填写root；其它可以填”.” 3;制作服务器私钥 openssl genrsa -out server.pem 1024 openssl rsa -in server.pem -out se...
Android使用Https请求服务器，信任所有证书
weixin_37758967的博客
10-30 1374
服务器配置了SSL证书后，Android端把http改成https之后也不能请求成功！ 有一种是自己信任指定证书 另一种直接信任所有证书 我们直接信任所有证书新建工具类TrustAllSSL： public class TrustAllSSL implements X509TrustManager { @Override public void checkClien...
Android HTTPS SSL双向验证
Restless Breeze
05-26 534
package com.sunyard.moudledemo; import android.content.Context; import android.util.Log; import java.io.BufferedInputStream; import java.io.InputStream; import java.security.InvalidKeyException; import java.security.KeyStore; import java.security.NoSuch.
android 客户端强校验服务端证书,Android实现https网络通信之添加指定信任证书/信任所有证书...
weixin_36037280的博客
05-27 1394
当Android客户端访问https网站，默认情况下，受证书信任限制，无法访问，可以有两种解决方法来实现：1、将要访问的https网站的ca证书添加到客户端信任证书列表中，此种方式为谷歌推荐，安全性高。2、将客户端设置为信任所有证书，也就是说不验证服务器证书，此种方式实现简单，但是安全性低，不推荐使用。直接上代码，分别实现两种方式的访问。1、客户端添加指定信任证书assets目录中放置ca.crt...
Android—HTTPS部署自签名证书
#请假条的博客
02-14 1590
Android 作为客户端https 通信，通常需要一个SSLContext， SSLContext 需要配置一个 TrustManager，如果是双向通信，还需要一个KeyManager。KeyManager 负责提供证书和私钥，证书发给服务端校验。双向认证 TrustManager + KeyManager。TrustManager 负责校验服务端发来的证书。单向认证 TrustManager。二、Android 客户端的配置。一、生成自签名私有证书。
安卓 https 证书校验和绕过
AzulSystems的博客
03-04 2383
吕元江。
Android中使用Webview SSL 自签名CA证书安全校验方案
jsxin0816的博客
11-18 2672
Android中使用Webview SSL 自签名证书校验
android上如何实现x509证书链验证
04-12
可以使用Java中的TrustManager和SSLContext类来实现x509证书链验证。首先，需要创建一个X509TrustManager对象，并重写它的checkServerTrusted方法，该方法用于验证服务器端的证书链。然后，需要创建一个SSLContext...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值