[免费专栏] Android安全之绕过直连、HOST校验、系统证书校验、代理检测、双向认证抓HTTPS数据

[免费专栏] Android安全之绕过直连、HOST校验、系统证书校验、代理检测、双向认证抓HTTPS数据
欢迎新同学的光临
… …
人若无名，便可专心练剑

我不是一条咸鱼，而是一条死鱼啊！

0x01 HTTP 直连

注：样本APK下载地址，请见文章末尾

httpstest APP 中使用的https访问组件是okhttp3，直接访问http协议的url 即可。不需要进行任何多余的配置，只需要配置好代理，http流量会被代理软件抓到
```
/*
* http协议
*/
button_http_connect.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        new Thread(new Runnable() {
            @RequiresApi(api = Build.VERSION_CODES.N)
            @Override
            public void run() {
                OkHttpClient mClient = client.newBuilder().build();
                Request request = new Request.Builder()
                        .url("http://www.vulnweb.com/")
                        .build();
                Message message = new Message();
                message.what = 1;
                try (Response response = mClient.newCall(request).execute()) {
                    message.obj = "http connect access vulnweb.com success";
                    Log.d(TAG, "http connect access vulnweb.com success return code:"+response.code());
                } catch (IOException e) {
                    message.obj = "http connect access vulnweb.com failed";
                    Log.d(TAG, "http connect access vulnweb.com failed");
                    e.printStackTrace();
                }
                mHandler.sendMessage(message);
            }
        }).start();
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
```
打开Burp，并在Android 设备中配置好代理，然后打开APP后点击【HTTP CONNECT】按钮，APP成功访问，并在显示 http connect access vulnweb.com success，Burp也成功抓到信息，如下：

0x02 HOST校验

样本APK地址：https://github.com/AndroidAppSec/vuls/releases/download/v2.1/vuls2.1.apk

对于开发者来说，在测试环境中，通常会使用自签名的证书。正常情况下是无法进行 https 通信的，于是很多开发者就会在代码中忽略证书错误。但是在上生产环境的时候，又忘记去掉相关的代码，就会出现 https 通信被中间人攻击的情况。

以下是一段典型的忽略证书错误的写法，在 TrustManager 中不做任何校验，在 HostnameVerifier 中总是返回域名正确。
```
// 该方法检查客户端的证书，若不信任该证书则抛出异常
@Override
public void checkClientTrusted(X509Certificate[] chain, String authType)
throws CertificateException {
    ... ...
}

// 该方法检查服务器的证书，若不信任该证书同样抛出异常
@Override
public void checkServerTrusted(X509Certificate[] chain, String authType)
throws CertificateException {
    ... ...
}

// 返回受信任的X509证书数组
@Override
public X509Certificate[] getAcceptedIssuers() {
    return new X509Certificate[0];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
```
```
final HostnameVerifier hostnameVerifier = new HostnameVerifier() {@
    Override
    public boolean verify(String hostname, SSLSession session) {
        return true;
    }
}
1
2
3
4
5
6
```
```
new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, trustManagers, new SecureRandom());

            URL url = new URL(baidu);
            HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
            connection.setSSLSocketFactory(sslContext.getSocketFactory());
            connection.setHostnameVerifier(hostnameVerifier);
            connection.setConnectTimeout(5000);
            connection.setReadTimeout(10000);
            connection.connect();

            int responseCode = connection.getResponseCode();
            if (200 == responseCode) {
                runOnUiThread(new Runnable() {@
                    Override
                    public void run() {
                        Toast.makeText(HttpsURLConnectionActivity.this, "请求成功", Toast.LENGTH_LONG).show();
                    }
                });
            }
            connection.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
            runOnUiThread(new Runnable() {@
                Override
                public void run() {
                    Toast.makeText(HttpsURLConnectionActivity.this, "请求失败", Toast.LENGTH_LONG).show();
                }
            });
        }
    }
}).start();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
```
如上代码会造成APP，在进行 https 通信与 http 通信效果无异，都会受到中间人攻击

Android7 抓包问题解决

目前在Android 7.0或以上的系统有启用了对第三方证书的限制，但在Android 7.0以下依旧可以将Fiddler/Charles/Burp的证书安装在用户的CA集中抓取https请求

将Burp或者Charles的证书作为系统级别的信任证书安装。建议重新生产burp证书并重启burp后再导出。系统级别的受信任证书以特殊格式存储在/system/etc/security/cacerts文件夹中。我们可以将Burp的证书写入此位置。

导出一个Burp/Charles证书之后，adb push到模拟器，然后修改后缀为crt直接安全，这种方式在Android 6及之前的版本可用，从Android 7.0开始，Android更改了信任用户安装的证书的默认行为，应用程序仅信任系统级CA。这样就导致安装证书后，如果尝试通过Burp或者Charlse代理访问https网站，系统会提示“该证书并非来自可信的授权中心”

对于Android 7.0 (API 24) 之后，做了些改动，使得系统安全性增加了，导致：
- APP 默认不信任用户域的证书
  - 之前把抓包工具的ssl证书，通过【从SD卡安装】安装到受信任的凭据 -> 用户。就没用了，因为不再受信任了
  - 只信任（安装到）系统域的证书
  - 导致无法抓包https，抓出来的https的请求，都是加了密的，无法看到原文了
对此，总结出相关解决思路和方案：
- 让系统信任抓包工具的ssl证书
  - 作为app的开发者自己：改自己的app的配置，允许https抓包（得到或本身有app的源码，把证书放到受系统信任的系统证书中去）
  - 把证书放到受系统信任的系统证书中去（root权限）
- 绕开https不去校验
  - 借助于其他（JustTrustMe等）工具绕开https的校验（例如XPosed、太极XPosed等框架）
Android7抓包问题，解决方法：
1. 导出Burp的证书后，使用openssl来做一些改动，最后上传到/system/etc/security/cacerts
```
root@kali:~# openssl x509 -inform DER -in cert-der.crt -out PortSwiggerCA.pem
root@kali:~# openssl x509 -inform PEM -subject_hash_old -in PortSwiggerCA.pem|head -1
root@kali:~# mv PortSwiggerCA.pem 9999.0
1
2
3
```
1. adb传输文件报错couldn‘t create file：Read-only file system解决方法
```
D:\>adb shell
VOG-AL00:/ # mount -o remount -o rw /system
mount -o remount -o rw /system
VOG-AL00:/ # exit;
exit;

D:\>adb root
adbd is already running as root

D:\>adb remount
remount succeeded

D:\>adb push 9999.0 /system/etc/security/cacerts
330 KB/s (1330 bytes in 0.003s)

D:\>adb shell chmod 644 /system/etc/security/cacerts/9999.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
```
再次输入adb push就能正常传输文件

Android10 抓包问题解决

Android10以上需要刷入Magisk,在模块里搜索move Cert ,安装模块，重启后证书就已经被移动到系统目录（system/etc/security/cacerts），可以正常抓包了

下载地址：https://github.com/topjohnwu/Magisk
- 为了测试域名校验，代码中存在以下校验代码：
```
final HostnameVerifier hostnameVerifier = new HostnameVerifier() {
    @Override
    public boolean verify(String hostname, SSLSession session) {
        Log.e("NetAcitivty", hostname);
        HostnameVerifier hv = HttpsURLConnection.getDefaultHostnameVerifier();
        Boolean result = hv.verify("www.google.com", session);
        return result;
    }
};
1
2
3
4
5
6
7
8
9
```
- 绕过Host校验的方法，只需更改Burp 的请求的Host即可，如下：
配置好Burp为代码中要校验的Host后，点击【只校验host】按钮查看效果，如下：

0x03 HTTPS 忽略证书验证

httpstest APP在对HTTPS证书验证时，可以通过代码实现信任所有证书，以okhttp网络框架为例，发起一个忽略HTTPS证书校验的请求实现如下:
```
/*
* https协议
* 忽略证书验证
*/
button_https_connect_without_ca.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        new Thread(new Runnable(){
            @RequiresApi(api = Build.VERSION_CODES.N)
            @Override
            public void run() {
                OkHttpClient mClient = client.newBuilder().sslSocketFactory(HttpsTrustAllCerts.createSSLSocketFactory(),new HttpsTrustAllCerts()).hostnameVerifier(new HttpsTrustAllCerts.TrustAllHostnameVerifier()).build();
                Request request = new Request.Builder()
                        .url("https://www.baidu.com/?q=trustAllCerts")
                        .build();
                Message message = new Message();
                message.what = 1;
                try (Response response = mClient.newCall(request).execute()) {
                    message.obj = "https connect without ca success";
                    Log.d(TAG, "https connect without ca success return code:"+response.code());
                } catch (IOException e) {
                    message.obj = "https connect without ca failed";
                    Log.d(TAG, "https connect without ca failed");
                    e.printStackTrace();
                }
                mHandler.sendMessage(message);
            }
        }).start();
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
```
HttpsTrustAllCerts对象实现如下，重写checkClientTrusted、checkServerTrusted方法，使其验证逻辑为空，重写域名验证器TrustAllHostnameVerifier 的verify方法，总是返回true，达到信任所有证书的效果:
```
public class HttpsTrustAllCerts implements X509TrustManager {


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

    }

    @SuppressLint("TrustAllX509TrustManager")
    @Override
    public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException { // 验证服务端证书需要重写该函数

    }

    @Override
    public X509Certificate[] getAcceptedIssuers() {
        return new X509Certificate[0]; //返回长度为0的数组，相当于return null
    }


    public static SSLSocketFactory createSSLSocketFactory() { // SSLSocketFactory 创建器
        SSLSocketFactory sSLSocketFactory = null;
        try {
            SSLContext sc = SSLContext.getInstance("TLS");
            sc.init(null, new TrustManager[]{new HttpsTrustAllCerts()},new SecureRandom());
            sSLSocketFactory = sc.getSocketFactory();
        } catch (Exception e) {
        }
        return sSLSocketFactory;
    }


    public static class TrustAllHostnameVerifier implements HostnameVerifier { // 域名验证器
        @Override
        public boolean verify(String s, SSLSession sslSession) {
            return true;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
```
忽略证书校验的https请求和使用http协议的请求报文一样，可以通过直接设置网络代理抓包解密明文。接下来打开Burp，并在Android 设备中配置好代理，然后打开APP后点击【HTTP CONNECT(忽略证书校验)】按钮，APP成功访问，并在显示 http connect without ca success，Burp也成功抓到信息，如下：

0x04 HTTPS 系统证书校验

httpstest APP 中使用的是okhttp3框架，okhttp3框架发起HTTPS请求时，默认就是使用的系统信任库证书链对服务端返回的证书进行验证，示例如下:
```
/*
* https协议
* 默认证书链校验，只信任系统CA(根证书)
*
* tips: OKHTTP默认的https请求使用系统CA验证服务端证书（Android7.0以下还信任用户证书，Android7.0开始默认只信任系统证书）
*/
button_https_connect_with_system_ca.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        new Thread(new Runnable(){
            @RequiresApi(api = Build.VERSION_CODES.N)
            @Override
            public void run() {
                Request request = new Request.Builder()
                        .url("https://www.baidu.com/?q=defaultCerts")
                        .build();
                Message message = new Message();
                message.what = 1;
                try (Response response = client.newCall(request).execute()) {
                    message.obj = "https connect with system ca success";
                    Log.d(TAG, "https connect with system ca success return code:"+response.code());
                } catch (IOException e) {
                    message.obj = "https connect with system ca failed";
                    Log.d(TAG, "https connect with system ca failed");
                    e.printStackTrace();
                }
                mHandler.sendMessage(message);
            }
        }).start();
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
```
设置系统代理，抓取该数据报文，会发现App报错java.security.cert.CertPathValidatorException: Trust anchor for certification path not found.，抓包工具burp会提示certificate_unknown

上图报错的原因在于Burp拦截https流量时，会同时充当客户端和服务端。在面向App时，此时Burp充当服务端，https协议握手过程中，Burp会将自己的证书发送给App，因为App使用系统信任库里面的证书进行校验，而Burp的证书不在系统信任库中，所以导致https握手失败，报错CertPathValidatorException

根据上述分析，绕过系统证书校验的方式，只需要将抓包工具的证书安装到系统信任库里面即可正常抓包或反编译APK在\res\xml\network_security_config.xml和\AndroidManifest.xml中添加如下信息后重打包APK并签名就能抓到数据：
```
  <network-security-config>
    <base-config> 
      <trust-anchors>
          
          <certificates src="system" />
          
          <certificates src="user" />
      trust-anchors>
    base-config>
network-security-config>
1
2
3
4
5
6
7
8
9
10
11
```
AndroidManifest.xml：
```
<application  android:networkSecurityConfig="@xml/network_security_config">
1
```
注：在Android 7.0以前，应用默认会信任系统证书和用户证书，Android 7.0开始，默认只信任系统证书，在root环境下，将证书导入系统目录的方法。只要想办法把证书弄到系统证书列表，就可以抓包解密明文数据，具体的证书安装到系统证书目录的方法，如下：

目前在Android 7.0或以上的系统有启用了对第三方证书的限制，但在Android 7.0以下依旧可以将Fiddler/Charles/Burp的证书安装在用户的CA集中抓取https请求

将Burp或者Charles的证书作为系统级别的信任证书安装。建议重新生产burp证书并重启burp后再导出。系统级别的受信任证书以特殊格式存储在/system/etc/security/cacerts文件夹中。我们可以将Burp的证书写入此位置。

导出一个Burp/Charles证书之后，adb push到模拟器，然后修改后缀为crt直接安全，这种方式在Android 6及之前的版本可用，从Android 7.0开始，Android更改了信任用户安装的证书的默认行为，应用程序仅信任系统级CA。这样就导致安装证书后，如果尝试通过Burp或者Charlse代理访问https网站，系统会提示“该证书并非来自可信的授权中心”

对于Android 7.0 (API 24) 之后，做了些改动，使得系统安全性增加了，导致：
- APP 默认不信任用户域的证书
  - 之前把抓包工具的ssl证书，通过【从SD卡安装】安装到受信任的凭据 -> 用户。就没用了，因为不再受信任了
  - 只信任（安装到）系统域的证书
  - 导致无法抓包https，抓出来的https的请求，都是加了密的，无法看到原文了
对此，总结出相关解决思路和方案：
- 让系统信任抓包工具的ssl证书
  - 作为app的开发者自己：改自己的app的配置，允许https抓包（得到或本身有app的源码，把证书放到受系统信任的系统证书中去）
  - 把证书放到受系统信任的系统证书中去（root权限）
- 绕开https不去校验
  - 借助于其他（JustTrustMe等）工具绕开https的校验（例如XPosed、太极XPosed等框架）
1） Android 7抓包问题解决方法
1. 导出Burp的证书后，使用openssl来做一些改动，最后上传到/system/etc/security/cacerts
```
root@kali:~# openssl x509 -inform DER -in cert-der.crt -out PortSwiggerCA.pem
root@kali:~# openssl x509 -inform PEM -subject_hash_old -in PortSwiggerCA.pem|head -1
root@kali:~# mv PortSwiggerCA.pem 9999.0
1
2
3
```
1. adb传输文件报错couldn‘t create file：Read-only file system解决方法
```
D:\>adb shell
VOG-AL00:/ # mount -o remount -o rw /system
mount -o remount -o rw /system
VOG-AL00:/ # exit;
exit;

D:\>adb root
adbd is already running as root

D:\>adb remount
remount succeeded

D:\>adb push 9999.0 /system/etc/security/cacerts
330 KB/s (1330 bytes in 0.003s)

D:\>adb shell chmod 644 /system/etc/security/cacerts/9999.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
```
再次输入adb push就能正常传输文件

2）Android10 抓包问题解决方法

Android10以上需要刷入Magisk,在模块里搜索move Cert ,安装模块，重启后证书就已经被移动到系统目录（system/etc/security/cacerts），可以正常抓包了

下载地址：https://github.com/topjohnwu/Magisk

0x05 系统代理检测

TCP协议在操作系统中完全被定死了，但是http协议都是各个开发者自己实现的，很多功能实现了多少，支持哪些细节都是开发人员自己决定的

例1：除了校验HTTPS证书防止中间人抓包以外，常见的方法还有通过检测系统代理防止抓包，其原理是检测到设备开启系统代理后，APP中通过代码实现禁用代理，以OkHttp框架为例，示列代码如下:
```
/*
* 检测代理
* 目前仅限OkHttp发出的请求
*/
switch_check_proxy.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
    @Override
    public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
        if(isChecked){
            client = new OkHttpClient().newBuilder().proxy(Proxy.NO_PROXY).build();
        }else {
            client = new OkHttpClient();
        }
    }
});
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
```
例2：很多APP中会设置如下检测
```
String property = System.getProperty("https.proxyHost");
String property = System.getProperty("https.proxyPort");
if(!TextUtils.isEmpty(property)){
	return new Proxy(Proxy,Type.HTTP, new InetSockerAddress(Property, Integer.parseInt(property2)))
}
1
2
3
4
5
```
为了绕过系统代理检测，可以使用iptables对请求进行强制转发或使用Proxy Droid，ProxyDroid全局代理工具就是通过iptables实现的，所以使用ProxyDroid开启代理，可以比较有效的绕过代理检测。手机root后，使用Proxy Droid 或Postern实现强制全局代理，让ssl代理证书生效，proxy Droid可以在UpToDown，ApkHere等的地方下载

1）对ProxyDroid进⾏配置（基本配置）
- Auto Setting不勾选，⼿动进⾏配置
  - Host：输⼊代理服务器IP
  - Port：输⼊代理服务器端⼝
- Proxy Type选择代理服务器提供服务类型：选择HTTP
- Auto Connect为当2G/3G/WIFI⽹络开启时，⾃动开启代理服务。不勾选，⼿动启动，以获取最⼤灵活性
- Bypass Addresses：相当于⿊名单列表，选择排除代理的IP范围，有需要的可以⾃⼰⼿动设置
2）认证信息配置
- Enable Authentication：如果代理服务器需要账户、密码认证，勾选
- User：认证账户名
- Password：认证密码
- NTLM Authentication：NTLM/ NTLM2，Windows早期的⼀种认证⽅式，不⽤勾选
3）特征设置
- Global Proxy：⼀定要勾选，即为全局代理，代理所有App
- Individual Proxy：单独代理所选App，勾选了第⼀条的不⽤管
- Bypass Mode：勾选了代表第⼆条中所选App不代理，勾选了第⼀条的不⽤管
- DNS Proxy：开启DNS代理。
4）通知设置
- Ringtone：选择通知铃声
5）都设置完成后，开启Proxy Switch即可。注意：如果使⽤ProxyDroid，⽆需在系统wifi处设置代理

下载地址：https://apkpure.com/proxydroid/org.proxydroid

Postern是Android系统里一款非常流行的代理/ 虚拟专用网络管理程序，是一个Android下的全局代理工具，可以说是安卓版surge，它可以添加规则，屏蔽广告。

Postern支持的代理协议有:
- SSH隧道
- Shadowsocks
- SOCKS5代理
- HTTPS/HTTP CONNECT method隧道
- gfw.press
下载地址：https://apkpure.com/postern/com.tunnelworkshop.postern

上面说的是要root的情况下，免root的可以使用如下Drony 或 VProxid、Postern
- Drony
Drony 支持 App 定向的 http,https 抓包。手机上装的 app 多了，会很多数据上来，要加过滤规则，正式环境测试环境都要加连上了代理，有些普通使用的 app （非抓包 app）会没法使用，会出现经常要设置代理，关闭代理，需要又要设置（有些手机会保存代理 ip 还好，不保存的还要每次手写）

将手机上的所有流量都重定向到 drony 自身，这样 drony 就可以管理所有手机上的网络流量，然后对手机上不同 APP 的流量进行单独配置，再转发到 BurpSuite上

Drony 可以解决上述痛点，不需要手机在 wifi 里设置代理。可以通过该 app 直接指定目标 app 才走代理，对其他 app 不可见

下载地址：https://www.apkshub.com/app/org.sandroproxy.drony
- VProxid
VProxid是Android平台上的Proxifier替代工具，VProxid允许不支持通过代理服务器工作的网络应用程序通过SOCKS或HTTP(S)代理进行操作。使用VProxid，可以轻松地将所选应用程序上的所有TCP连接隧道传输到不同的代理服务器，这意味着VProxid可以为每个应用程序设置不同的代理来抓取数据，配合Burp使用更佳
```
1. 通过代理服务器运行任何网络应用程序
2. 该软件不需要特殊配置;整个过程是完全透明的
3. 同时为选定的应用程序设置不同的代理
4. 通过代理服务器网关从受限网络访问Internet
5. 绕过防火墙限制
6. 通过隐藏您的IP地址来保护隐私
7. 实时查看状态,公共IP,流量等信息
8. VProxid限制
9. 不支持UDP连接
10. 不支持https代{过}{滤}理
1
2
3
4
5
6
7
8
9
10
```
下载地址：https://github.com/EasyLazyBean/VProxid

0x06 HTTPS 双向验证

双向验证(或称为双向认证)，顾名思义就是客户端验证服务器端证书的正确性，服务器端也验证客户端的证书正确性（当服务器启用了证书双向认证之后，除了客户端去验证服务器端的证书外，服务器也同时需要验证客户端的证书，也就是会要求客户端提供自己的证书，如果没有通过验证，则会拒绝连接，如果通过验证，服务器获得用户的公钥）。所以基本原则上客户端要持有服务器端证书，服务端也要持有客户端的证书，对于Android APP来说打包发布的时候既要内置一个服务端证书也要生成一个客户端证书给服务器存储起来。这种双向认证非常可以做到非常高的安全性，但是同时服务端要想保持所有服务端的证书比较困难，因此这种方式只适用于某些点对点的高安全性需求的通信场合，对于Android APP来说可能是某类高机密性的内网业务才会使用这种双向HTTPS认证

 6.1 单向认证流程

单向认证流程中，服务器端保存着公钥证书和私钥两个文件，整个握手过程如下：
1. 客户端发起建立HTTPS连接请求，将SSL协议版本的信息发送给服务器端
2. 服务器端将本机的公钥证书（server.crt）发送给客户端
3. 客户端读取公钥证书（server.crt），取出了服务端公钥
4. 客户端生成一个随机数（密钥R），用刚才得到的服务器公钥去加密这个随机数形成密文，发送给服务端
5. 服务端用自己的私钥（server.key）去解密这个密文，得到了密钥R
6. 服务端和客户端在后续通讯过程中就使用这个密钥R进行通信了
6.2 双向认证流程
1. 客户端发起建立HTTPS连接请求，将SSL协议版本的信息发送给服务端
2. 服务器端将本机的公钥证书（server.crt）发送给客户端
3. 客户端读取公钥证书（server.crt），取出了服务端公钥
4. 客户端将客户端公钥证书（client.crt）发送给服务器端
5. 服务器端使用根证书（root.crt）解密客户端公钥证书，拿到客户端公钥
6. 客户端发送自己支持的加密方案给服务器端
7. 服务器端根据自己和客户端的能力，选择一个双方都能接受的加密方案，使用客户端的公钥加密999后发送给客户端
8. 客户端使用自己的私钥解密加密方案，生成一个随机数R，使用服务器公钥加密后传给服务器端
9. 服务端用自己的私钥去解密这个密文，得到了密钥R
10. 服务端和客户端在后续通讯过程中就使用这个密钥R进行通信了
6.3 HTTPS 单向验证/HTTPS 双向验证的区别

单向验证过程中，客户端会验证自己访问的服务器，服务器对来访的客户端身份不做任何限制。如果服务器需要限制客户端的身份，则可以选择开启服务端验证，这就是双向验证。从这个过程中我们不难发现，使用单向验证还是双向验证，是服务器决定的。

一般而言，我们的服务器都是对所有客户端开放的，所以服务器默认都是使用单向验证。如果你使用的是Tomcat服务器，在配置文件server.xml中，配置Connector节点的clientAuth属性即可。若为true，则使用双向验证，若为false，则使用单向验证。如果你的服务，只允许特定的客户端访问，那就需要使用双向验证了。

双向验证基本过程与单向验证相同，不同在于：

1）第二步服务器第一次回应客户端的SeverHello消息中，会要求客户端提供“客户端的证书”

2）第三步客户端验证完服务器证书后的回应内容中，会增加两个信息：
- 客户端的证书
- 客户端证书验证消息（CertificateVerify message）：客户端将之前所有收到的和发送的消息组合起来，并用hash算法得到一个hash值，然后用客户端密钥库的私钥对这个hash进行签名，这个签名就是CertificateVerify message
3）服务器收到客户端证书后：
- 确认这个证书是否在自己的信任库中（当然也会校验是否过期等信息），如果验证不通过则会拒绝连接
- 用客户端证书中的公钥去验证收到的证书验证消息中的签名。作用是为了确认证书确实是客户端的
所以，在双向验证中，客户端需要用到密钥库，保存自己的私钥和证书，并且证书需要提前发给服务器，由服务器放到它的信任库中

 6.4 HTTPS 单向验证/HTTPS 双向验证的总结

HTTPS 单向验证：
- 如果是你客户端，你需要拿到服务器的证书，并放到你的信任库中
- 如果是服务端，你要生成私钥和证书，并将这两个放到你的密钥库中，并且将证书发给所有客户端。
HTTPS 双向验证：
- 如果你是客户端，你要生成客户端的私钥和证书，将它们放到密钥库中，并将证书发给服务端，同时，在信任库中导入服务端的证书
- 如果你是服务端，除了在密钥库中保存服务器的私钥和证书，还要在信任库中导入客户端的证书
6.5 HTTPS 双向验证实例

补充知识：
如果想自己生成证书的话，可以通过以下命令生成证书：
- 生成自签名服务器端证书：
```
openssl genrsa -out server-key.key 2048
openssl req -new -out server-req.csr -key server-key.key
openssl x509 -req -in server-req.csr -out server-cert.cer -signkey server-key.key  -CAcreateserial -days 3650
1
2
3
```
- 生成自签名客户端证书：
```
openssl genrsa -out client-key.key 2048
openssl req -new -out client-req.csr -key client-key.key
openssl x509 -req -in client-req.csr -out client-cert.cer -signkey client-key.key -CAcreateserial -days 3650
1
2
3
```
生成客户端带密码的p12证书（双向认证的话，浏览器访问时候要导入该证书才行；可能某些Android系统版本请求的时候需要把它转成bks来请求双向认证，或某些设备用p12格式）：
```
openssl pkcs12 -export -clcerts -in client-cert.cer -inkey client-key.key -out client.p12
1
```
需要使用的证书都在源码certs目录，对应证书密码如下：
- 客户端证书client.p12密码：clientpassword
- 服务端证书server密码：serverpassword
APP解密的代码逻辑，一般步骤如下：
- 客户端发送数据包
- 去从app中读取这个证书文件，密码是以硬编码形式放在了代码中
- 寻找到硬编码形式的这个代码，然后利用这个代码中的密码字段去解密证书文件，从中读取以后，再进行解密并回传给服务器端进行确认
- 由此可寻找证书名称来获得证书密码
证书后缀名一般为：
- .p12
- .bks
- .pfx
SSL双向校验一般都将证书放到/asset目录下, 也就是app的资源目录下, 也有可能放在/res/raw目录下，如果都不再就使用*.p12、*.bks、.pfx来快速定位位置

反编译APK，通过关键词"PKCS12"能够定位到加载证书的位置，获得证书密码：clientpassword

或使用IDA加载dex文件，然后在String窗口搜索证书的名称，搜索后进入对应的类进行查找；有些APP为了安全性会把证书密码放到native层保护，如果想知道密码就要去找到对应的函数，查看具体加载的是哪个so文件（利用IDA工具）

6.5.1 实验开始之前

在开始之前，我们通过PC 浏览器来验证一下概念，如下步骤：
- 创建Python服务端代码，文件名保存为server_https.py：
```
import os
import sys
import ssl
from http.server import HTTPServer, BaseHTTPRequestHandler

#服务端证书和私钥
serverCerts = "D:\\t\\httpstest-master\\certs\\server-cert.cer"
serverKey = "D:\\t\\httpstest-master\\certs\\server-key.key"
#客户端证书
clientCerts = "D:\\t\\httpstest-master\\certs\\client-cert.cer"

class RequestHandler(BaseHTTPRequestHandler):
    def _writeheaders(self):
        self.send_response(200)
        self.send_header('Content-type','text/plain')
        self.end_headers()
    def do_GET(self):
        self._writeheaders()
        self.wfile.write("OK".encode("utf-8"))

def main():
    if (len(sys.argv) != 2):
        port = 443
    else:
        port = sys.argv[1]
    server_address = ("0.0.0.0", int(port))
    server = HTTPServer(server_address, RequestHandler)
    #双向校验
    server.socket = ssl.wrap_socket(server.socket, certfile = serverCerts, server_side = True,  
                               keyfile = serverKey,
                               cert_reqs = ssl.CERT_REQUIRED,
                               ca_certs = clientCerts,
                               do_handshake_on_connect = False
                               )
    print("Starting server, listen at: %s:%s" % server_address)
    server.serve_forever()

if __name__ == "__main__":
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
```
- 物理机启动该python脚本：
```
python3  server_https.py
1
```
- 虚拟机Host文件需配置一下：
```
格式：物理机的IP   www.test.com
192.168.66.55   www.test.com
1
2
```
- 将httpstest-master\certs 下的client.p12 拷贝到虚拟机并安装：
- 输入我们已知道的密码：clientpassword
- 最后打开浏览器访问地址：https://www.test.com
从上看到，访问test.com成功会返回OK字样的空白页，也输出ERROR错误，但还是访问成功了，报错的错误原因是证书为自签名证书，客户端并不想认可该证书。只需要手动确认即可打开对应的内容

 6.5.2 实验正式开启

1）需要做一些简单的配置：
- 修改Android模拟器中的 hosts，将 www.test.com 域名定向到正确IP（之前用的哪个Python脚本启动的服务端机器的IP）
```
adb root
adb remount
adb pull /system/etc/hosts
adb push hosts /system/etc/hosts
adb shell
echo -e \\n >> /system/etc/hosts
1
2
3
4
5
6
```
- 本地PC未开启代理软件
- APP 通过frida hook 模式启动
client app包含server-cert.cer 对服务端证书PIN，这个过程需要验证服务端证书的签发单位是否为合法CA Issuer，但是我们的证书是自签名的，所以就算是不使用代理还是不能通过SSL PINNING，大概率是报错：

Caused by: java.security.cert.CertificateException: java.security.cert.CertPathValidatorException: Trust anchor for certification path not found.

APP 通过frida hook 模式启动：
```
D:>adb shell
root@VOG-AL00:/ #  cd /data/local/tmp
root@VOG-AL00:/data/local/tmp # ./frida-server-15.1.21-android-x86
1
2
3
```
JS脚本：
```
/*  Android ssl certificate pinning bypass script for various methods

	Run with:
	frida -U -f [APP_ID] -l fridascript.js --no-pause
*/
setTimeout(function() {
Java.perform(function () {
    // 绕过OpenSSLSocketImpl Conscrypt
    var OpenSSLSocketImpl = Java.use('com.android.org.conscrypt.OpenSSLSocketImpl');
	OpenSSLSocketImpl.verifyCertificateChain.implementation = function (certRefs, JavaObject, authMethod) {
	     console.log('[+] Bypassing OpenSSLSocketImpl Conscrypt');
	};

});
}, 0);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
```
最后运行启动APP
```
frida -U -f com.example.httpstest -l D:\t\fridascript.js --no-paus
1
```
2）都完成后，我们来查看查看当前APP 包名
```
adb shell "dumpsys window | grep mCurrentFocus"
1
```
3）Frida 启动app，Android无配置抓包代理的情况下，点击【HTTPS双向验证】按钮，可以看到收到了一个请求，但此处我点击按钮后，会闪退，大家不用管，可能是我打包APK的时候出了一些问题
```
frida -U -f com.example.httpstest -l D:\t\fridascript.js --no-paus
1
```
4）接下来配置抓包代理，然后用Burp直接抓包，请求是抓到了，但并未返回信息，Burp能抓包HTTPS协议报文的原理是: Burp在中间即充当客户端，又充当服务端。在Burp冒充客户端时，因为服务端要求APP发送客户端证书进行验证，而burp没有客户端证书，所以导致握手失败（双向验证）：

5）此时，BurpSuite需要给代理软件加客户端证书，该证书在前面的哪个已经说过了，解压缩APK里面查找，加密的密码反编译或IDA动态调试获取密码，然后将客户端证书安装给Burp，如下：

选择client.p12证书文件，证书文件密码为：clientpassword

接下来，再次重复之前的步骤，再Frida 打开APP以及设置Android Burp代理，可以成功的发送请求并返回信息，结果如下：

参考链接：

https://www.jianshu.com/p/1546e606028b

https://blog.csdn.net/lgxzzz/article/details/124645489

https://mp.weixin.qq.com/s/A-bPf6uNGiEQVu-dFvHnVw

https://ch3nye.top/Android-HTTPS%E8%AE%A4%E8%AF%81%E7%9A%84N%E7%A7%8D%E6%96%B9%E5%BC%8F%E5%92%8C%E5%AF%B9%E6%8A%97%E6%96%B9%E6%B3%95%E6%80%BB%E7%BB%93/

我自横刀向天笑，去留肝胆两昆仑
相关阅读:
防火墙技术基础篇：认识安全策略、安全区域、域间转发及报文转发流程
 升级版弹跳的小球
 H3C交换机如何查环路
 redis的详解和项目应用（一）
python基于PHP+MySQL的在线考试系统
 Windows安装nvm【node.js版本管理工具】
【linux】Linux第一个小程序－进度条
 【Cherno的OpenGL视频】Batch rendering - An intro
2022年9月8号Java的23设计模式学习(课时一)单例模式
 笛卡尔树【模板】
原文地址：https://blog.csdn.net/Ananas_Orangey/article/details/126219975

0x01 HTTP 直连

0x02 HOST校验

0x03 HTTPS 忽略证书验证

0x04 HTTPS 系统证书校验

0x05 系统代理检测

0x06 HTTPS 双向验证

6.1 单向认证流程

6.2 双向认证流程

6.3 HTTPS 单向验证/HTTPS 双向验证的区别

6.4 HTTPS 单向验证/HTTPS 双向验证的总结

6.5 HTTPS 双向验证实例

6.5.1 实验开始之前

6.5.2 实验正式开启