對app的反爬測試之apk逆向分析-frida繞過ssl pinning檢測

受人所托，需要對他們的產品進行反爬測試，所以就有了以下內容，不過，我知道，針對這方面的文章太多了，是真的多，而且好早就有了，但是目前為止，很多app的防護基本也還是用的ssl pinning檢測證書。因為，目前的app要嘛不用ssl，要嘛用就是一般的ssl，基本就是在手機上裝個相關軟體的代理即... ...

前言：

受人所托，需要對他們的產品進行反爬測試，所以就有了以下內容。

不過，我知道，針對這方面的文章太多了，是真的多，而且好早就有了，但是目前為止，很多app的防護基本也還是用的ssl pinning檢測證書。

因為，目前的app要嘛不用ssl，要嘛用就是一般的ssl，基本就是在手機上裝個相關軟體的代理即可，而且這個代理基本就是fiddler，charlels，burpsuite三個抓包軟體自帶的ssl證書，然後即可抓到ssl（https）的請求

以上這些，基本可以解決大部分的app（其實很多使用ssl的網站也是這樣處理）

但是因為很多app為了防止數據被分析爬取，會做ssl pinning驗證

ssl painning

SSL Pinning是一種防止中間人攻擊（MITM）的技術，主要機制是在客戶端發起請求–>收到伺服器發來的證書進行校驗，如果收到的證書不被客戶端信任，就直接斷開連接不繼續求情。

所以在遇到對關鍵請求開啟SSL Pinning的APP時，我們抓包就只能看到APP上提示無法連接網路或者請求失敗之類的提示；而在抓包工具上面，要麼就只能看到一排 CONNECT 請求，獲取到證書卻沒有後續了，要麼就是一些無關的請求，找不到想要的介面

比如如下圖：

針對這種，如果是web網站，我們都知道，在本地裝下抓包軟體自帶的ssl證書就行了，但是app的話，如此操作之後還是不行，而且app還會提示沒網（比如：網路連接失敗，網路有問題等等的），反正意思就是沒網的意思，這種就是因為app自身做了ssl pinning驗證處理，驗證下當前的ssl證書是否是合法允許的，如果不是就會驗證失敗

其實使用ssl pinning目前已經成為了趨勢，那麼我們的目前對象剛好就有這個怎麼辦呢？

目前根據我的經驗，最有效的有三個方法：

1.使用低版本的安卓機抓包
2.使用ios端手機抓包
3.使用frida繞過證書處理

使用低版本的安卓機抓包

因為app的話，目前主流的都是用的前後端分離開發，所以越到後期，app更新新版後，越會有不同版本的後端介面存在，而且新版介面和老版介面其實返回的數據差異性很小，並且有個關鍵點就是，為了相容性，會依舊留下舊版介面，因為每個用戶使用的手機不一樣，安卓或者ios版本不同，系統版本也就會不同，且老款手機因為記憶體太小，不會更新新版的app包，種種情況下來，結果就是會留下舊版介面，而且這個舊版介面安全性比新版低很多，所以可以用低版本的餓安卓機來抓包，就正常的抓包流程即可，不出意外的話，可能還用的普通的http請求。

為什麼高版本的安卓就抓不到包呢，因為高版本的（安卓7以上）開始，安卓自帶了一些安全機制，本質上就是只信任系統證書，不再信任用戶自己安裝的證書了，我們裝的ssl代理證書就是自己裝的，所以就會驗證不通過了

使用ios端手機抓包

這個情況真的很多，因為，蘋果端的appstore管理得很嚴，不能加些自己獨特的東西，但是加ssl是可以的，但是很多app並沒有加我就不知道了，這個情況就很簡單，需要一臺iphone，其他都是正常抓包操作，然後安裝證書，把證書信任下就行了，詳細的操作就不說了，網上很多教程

使用frida繞過證書處理

這個方法就是本篇文章的重點了，這個放到後面再說

其他方法

其實也有其他的方法，這些方法並不是通用的，可能運氣好可以用，運氣不好就沒用：

安卓模擬器

用安卓模擬器，模擬低版本安卓然後抓包

對證書信任

看這個app是否是自有app，如果是自有的，谷歌有debug模式，該模式下讓app預設可以信任用戶域的證書（trust-anchors）,如果是非自有，用xposed+JustTrustMe即可，但是使用Xposed框架需要root，網上那些微信魔改小功能，什麼自動搶紅包，防消息撤回之類的就是用的xposed框架改的，用JustTrustMe來信任用戶安裝的證書

目前市面上有VitualXposed、太極等虛擬的框架，不用root也可以操作，太極這個軟體挺好的，有太極-陰（免root）和太極-陽（需要root），兩個版本都可以用，但是針對有些app的話，太極-陰沒戲，只能太極-陽，但是既然我都已經root了，我就沒必要整這些了

強制信任證書

這個也需要root，把ssl代理證書強制的放到安卓機的/system/etc/security/cacerts/目錄下，這個目錄就是安卓機系統信任的目錄

httpcannary

這個是安卓端的抓包工具，網上吹得很火，根據我（我手機是安卓10）親自操作，發現其實沒有用，也不知道是不是我的姿勢錯誤，或者我手機安卓系統版本太高了失效

VirtualApp

用這個可以免root操作，然後正常抓包，但是這個方法我沒有實際操作過，網上的資料不多，自行查找

強制全局代理

手機root後，使用proxy Droid 實現強制全局代理，讓ssl代理證書生效，proxy Droid可以在UpToDown，ApkHere等的地方下載

VPN抓包

免root，在安卓機上安裝packet capture，然後抓包，我試了下，我的手機（我手機是安卓10）沒用

魔改JustTrustMe

在JustTrustMe插件上增加一個可以運行時根據實際情況調整ssl檢測的功能，對hook增加動態適配，這個方法我沒試過，我在看雪論壇里找到一個 JustTrustMePlus，點我下載

反編譯app包

用apktools修改配置文件里的ssl證書檢測部分，可利用jadx等工具分析源碼，然後重新打包，再抓包分析，這個方法是可行的，詳細的步驟自行百度吧，後續有時間的話，我單獨發一篇對app的脫殼重新打包

以上的方法就是我所知道的方法，各位朋友自行操作

接下來進入正題，frida hook

什麼是frida

官網：https://frida.re/

Frida是個輕量級別的hook框架，是Python API，用JavaScript調試來邏輯

Frida的核心是用C編寫的，並將Google的V8引擎註入到目標進程中，在這些進程中，JS可以完全訪問記憶體，掛鉤函數甚至調用進程內的本機函數來執行。

使用Python和JS可以使用無風險的API進行快速開發。Frida可以幫助您輕鬆捕獲JS中的錯誤併為您提供異常而不是崩潰。

frida是平臺原生app的Greasemonkey，說的專業一點，就是一種動態插樁工具，可以插入一些代碼到原生app的記憶體空間去，（動態地監視和修改其行為），這些原生平臺可以是Win、Mac、Linux、Android或者iOS。而且frida還是開源的。

Greasemonkey可能大家不明白，它其實就是firefox的一套插件體系，使用它編寫的腳本可以直接改變firefox對網頁的編排方式，實現想要的任何功能。而且這套插件還是外掛的，非常靈活機動。

frida框架主要分為兩部分：
1）一部分是運行在系統上的交互工具frida CLI。
2）另一部分是運行在目標機器上的代碼註入工具 frida-server

註：以下相關操作，終端里凡是 C:\Users\Administrator 開頭的都是在pc機上操作的，需要在安卓機目錄里操作的我都有說明，不要搞混了

環境準備

安裝frida

沒有python的安裝python，然後安裝frida:

pip  install frida

pip install frida-tools

安裝過程很慢，這個只能耐心等待，然後如果你是macbook的話，如果你遇到安裝出錯，可以看看我這篇文章的解決方法 macos 安裝frida的坑

然後frida是mac,linux,windows都可以安裝使用的，這個根據你自己的條件選擇了

安裝adb

這個就很簡單，去安卓開髮網然後下載這個工具：

如果你下載太慢可以在我這裡下載：點我

下載完畢後，解壓，然後放到你想放的路徑，然後配置下環境變數即可，此電腦（我的電腦）- 屬性-高級系統設置-環境變數-系統變數的path，新增即可

然後，打開終端：

敲adb，回車，如果有以下提示，說明你adb安裝成功

以上配置是windows平臺，如果是其他平臺的話，自行查找，這裡就不展示了

找一個安卓機（已root）

根據現在的行情，要找到一個已root的手機，問題不大也不小，但是很多時候沒有必要，所以我這裡就選擇用安卓模擬器來輔助操作了

安裝夜神模擬器，夜神預設是安卓5，你可以自行選擇安卓版本，在夜神里設置已root即可

打開開發者選項里的USB調試

設置裡面，關於本機，然後狂點系統版本號，開啟開發者模式：

返回，會多一個開發者選項：

打開調試

adb連接安卓機（模擬器）

在安裝了frida和adb的真機操作系統下，打開終端，用 adb connect IP 連接安卓機：

夜神的ip是127.0.0.1:62001，這裡註意，如果你創建了多個安卓系統的話，那麼你待連接的安卓機不一定是62001，可能是其他的，這個就你自己去找了，我就因為這個，我查了很久才找到

我這裡已經連接上了，所以提示已連接

連接之後可以用 adb devices查看已連接的機器：

安裝frida-server

frida-server這個需要安裝在安卓機上，但是安卓機我們都知道有很多個版本，對應架構才行，要查看當前安卓機的架構：

adb shell getprop ro.product.cpu.abi

然後去這裡下載對應架構的frida-server : 點我

我這裡是x86，安卓，所以選下麵我選中那個下載，你的安卓機是什麼你就選哪個就行了

然後下載很慢，我這裡也提供了，點我下載

解壓，然後用adb 傳到安卓機上

adb push （本機的frida-sever文件所在目錄） （安卓機目錄）

這裡提示太長了，看不出來，可以用adb shell 去那個目錄下看下是否有frida-server即可：

修改frida-server的許可權：

chmod 700 frida-server

下載一個frida hook 的js文件

這個文件，有好幾個版本，我選用了兩個版本，放到下麵，你們自己選擇吧

版本1：

setTimeout(function(){
    Java.perform(function (){
    	console.log("");
	    console.log("[.] Cert Pinning Bypass/Re-Pinning");

	    var CertificateFactory = Java.use("java.security.cert.CertificateFactory");
	    var FileInputStream = Java.use("java.io.FileInputStream");
	    var BufferedInputStream = Java.use("java.io.BufferedInputStream");
	    var X509Certificate = Java.use("java.security.cert.X509Certificate");
	    var KeyStore = Java.use("java.security.KeyStore");
	    var TrustManagerFactory = Java.use("javax.net.ssl.TrustManagerFactory");
	    var SSLContext = Java.use("javax.net.ssl.SSLContext");

	    // Load CAs from an InputStream
	    console.log("[+] Loading our CA...")
	    cf = CertificateFactory.getInstance("X.509");
	    
	    try {
	    	var fileInputStream = FileInputStream.$new("/data/local/tmp/cert-der.crt");
	    }
	    catch(err) {
	    	console.log("[o] " + err);
	    }
	    var bufferedInputStream = BufferedInputStream.$new(fileInputStream);
	  	var ca = cf.generateCertificate(bufferedInputStream);
	    bufferedInputStream.close();

		var certInfo = Java.cast(ca, X509Certificate);
	    console.log("[o] Our CA Info: " + certInfo.getSubjectDN());

	    // Create a KeyStore containing our trusted CAs
	    console.log("[+] Creating a KeyStore for our CA...");
	    var keyStoreType = KeyStore.getDefaultType();
	    var keyStore = KeyStore.getInstance(keyStoreType);
	    keyStore.load(null, null);
	    keyStore.setCertificateEntry("ca", ca);
	    
	    // Create a TrustManager that trusts the CAs in our KeyStore
	    console.log("[+] Creating a TrustManager that trusts the CA in our KeyStore...");
	    var tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
	    var tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
	    tmf.init(keyStore);
	    console.log("[+] Our TrustManager is ready...");

	    console.log("[+] Hijacking SSLContext methods now...")
	    console.log("[-] Waiting for the app to invoke SSLContext.init()...")

	   	SSLContext.init.overload("[Ljavax.net.ssl.KeyManager;", "[Ljavax.net.ssl.TrustManager;", "java.security.SecureRandom").implementation = function(a,b,c) {
	   		console.log("[o] App invoked javax.net.ssl.SSLContext.init...");
	   		SSLContext.init.overload("[Ljavax.net.ssl.KeyManager;", "[Ljavax.net.ssl.TrustManager;", "java.security.SecureRandom").call(this, a, tmf.getTrustManagers(), c);
	   		console.log("[+] SSLContext initialized with our custom TrustManager!");
	   	}
    });
},0);

版本2：

Java.perform(function() {
    var array_list = Java.use("java.util.ArrayList");
    var ApiClient = Java.use('com.android.org.conscrypt.TrustManagerImpl');

    ApiClient.checkTrustedRecursive.implementation = function(a1, a2, a3, a4, a5, a6) {
        // console.log('Bypassing SSL Pinning');
        var k = array_list.$new();
        return k; 
        }
}, 0);

然後你自己複製以上的任何一個版本的代碼，然後在本地新建一個js文件，粘貼進去就行了

或者這個：

這裡補充一個完全版：

Java.perform(function() {

/*
hook list:
1.SSLcontext
2.okhttp
3.webview
4.XUtils
5.httpclientandroidlib
6.JSSE
7.network\_security\_config (android 7.0+)
8.Apache Http client (support partly)
9.OpenSSLSocketImpl
10.TrustKit
11.Cronet
*/

	// Attempts to bypass SSL pinning implementations in a number of
	// ways. These include implementing a new TrustManager that will
	// accept any SSL certificate, overriding OkHTTP v3 check()
	// method etc.
	var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');
	var HostnameVerifier = Java.use('javax.net.ssl.HostnameVerifier');
	var SSLContext = Java.use('javax.net.ssl.SSLContext');
	var quiet_output = false;

	// Helper method to honor the quiet flag.

	function quiet_send(data) {

		if (quiet_output) {

			return;
		}

		send(data)
	}


	// Implement a new TrustManager
	// ref: https://gist.github.com/oleavr/3ca67a173ff7d207c6b8c3b0ca65a9d8
	// Java.registerClass() is only supported on ART for now(201803). 所以android 4.4以下不相容,4.4要切換成ART使用.
	/*
06-07 16:15:38.541 27021-27073/mi.sslpinningdemo W/System.err: java.lang.IllegalArgumentException: Required method checkServerTrusted(X509Certificate[], String, String, String) missing
06-07 16:15:38.542 27021-27073/mi.sslpinningdemo W/System.err:     at android.net.http.X509TrustManagerExtensions.<init>(X509TrustManagerExtensions.java:73)
        at mi.ssl.MiPinningTrustManger.<init>(MiPinningTrustManger.java:61)
06-07 16:15:38.543 27021-27073/mi.sslpinningdemo W/System.err:     at mi.sslpinningdemo.OkHttpUtil.getSecPinningClient(OkHttpUtil.java:112)
        at mi.sslpinningdemo.OkHttpUtil.get(OkHttpUtil.java:62)
        at mi.sslpinningdemo.MainActivity$1$1.run(MainActivity.java:36)
*/
	var X509Certificate = Java.use("java.security.cert.X509Certificate");
	var TrustManager;
	try {
		TrustManager = Java.registerClass({
			name: 'org.wooyun.TrustManager',
			implements: [X509TrustManager],
			methods: {
				checkClientTrusted: function(chain, authType) {},
				checkServerTrusted: function(chain, authType) {},
				getAcceptedIssuers: function() {
					// var certs = [X509Certificate.$new()];
					// return certs;
					return [];
				}
			}
		});
	} catch (e) {
		quiet_send("registerClass from X509TrustManager >>>>>>>> " + e.message);
	}





	// Prepare the TrustManagers array to pass to SSLContext.init()
	var TrustManagers = [TrustManager.$new()];

	try {
		// Prepare a Empty SSLFactory
		var TLS_SSLContext = SSLContext.getInstance("TLS");
		TLS_SSLContext.init(null, TrustManagers, null);
		var EmptySSLFactory = TLS_SSLContext.getSocketFactory();
	} catch (e) {
		quiet_send(e.message);
	}

	send('Custom, Empty TrustManager ready');

	// Get a handle on the init() on the SSLContext class
	var SSLContext_init = SSLContext.init.overload(
		'[Ljavax.net.ssl.KeyManager;', '[Ljavax.net.ssl.TrustManager;', 'java.security.SecureRandom');

	// Override the init method, specifying our new TrustManager
	SSLContext_init.implementation = function(keyManager, trustManager, secureRandom) {

		quiet_send('Overriding SSLContext.init() with the custom TrustManager');

		SSLContext_init.call(this, null, TrustManagers, null);
	};

	/*** okhttp3.x unpinning ***/


	// Wrap the logic in a try/catch as not all applications will have
	// okhttp as part of the app.
	try {

		var CertificatePinner = Java.use('okhttp3.CertificatePinner');

		quiet_send('OkHTTP 3.x Found');

		CertificatePinner.check.overload('java.lang.String', 'java.util.List').implementation = function() {

			quiet_send('OkHTTP 3.x check() called. Not throwing an exception.');
		}

	} catch (err) {

		// If we dont have a ClassNotFoundException exception, raise the
		// problem encountered.
		if (err.message.indexOf('ClassNotFoundException') === 0) {

			throw new Error(err);
		}
	}

	// Appcelerator Titanium PinningTrustManager

	// Wrap the logic in a try/catch as not all applications will have
	// appcelerator as part of the app.
	try {

		var PinningTrustManager = Java.use('appcelerator.https.PinningTrustManager');

		send('Appcelerator Titanium Found');

		PinningTrustManager.checkServerTrusted.implementation = function() {

			quiet_send('Appcelerator checkServerTrusted() called. Not throwing an exception.');
		}

	} catch (err) {

		// If we dont have a ClassNotFoundException exception, raise the
		// problem encountered.
		if (err.message.indexOf('ClassNotFoundException') === 0) {

			throw new Error(err);
		}
	}

	/*** okhttp unpinning ***/


	try {
		var OkHttpClient = Java.use("com.squareup.okhttp.OkHttpClient");
		OkHttpClient.setCertificatePinner.implementation = function(certificatePinner) {
			// do nothing
			quiet_send("OkHttpClient.setCertificatePinner Called!");
			return this;
		};

		// Invalidate the certificate pinnet checks (if "setCertificatePinner" was called before the previous invalidation)
		var CertificatePinner = Java.use("com.squareup.okhttp.CertificatePinner");
		CertificatePinner.check.overload('java.lang.String', '[Ljava.security.cert.Certificate;').implementation = function(p0, p1) {
			// do nothing
			quiet_send("okhttp Called! [Certificate]");
			return;
		};
		CertificatePinner.check.overload('java.lang.String', 'java.util.List').implementation = function(p0, p1) {
			// do nothing
			quiet_send("okhttp Called! [List]");
			return;
		};
	} catch (e) {
		quiet_send("com.squareup.okhttp not found");
	}

	/*** WebView Hooks ***/

	/* frameworks/base/core/java/android/webkit/WebViewClient.java */
	/* public void onReceivedSslError(Webview, SslErrorHandler, SslError) */
	var WebViewClient = Java.use("android.webkit.WebViewClient");

	WebViewClient.onReceivedSslError.implementation = function(webView, sslErrorHandler, sslError) {
		quiet_send("WebViewClient onReceivedSslError invoke");
		//執行proceed方法
		sslErrorHandler.proceed();
		return;
	};

	WebViewClient.onReceivedError.overload('android.webkit.WebView', 'int', 'java.lang.String', 'java.lang.String').implementation = function(a, b, c, d) {
		quiet_send("WebViewClient onReceivedError invoked");
		return;
	};

	WebViewClient.onReceivedError.overload('android.webkit.WebView', 'android.webkit.WebResourceRequest', 'android.webkit.WebResourceError').implementation = function() {
		quiet_send("WebViewClient onReceivedError invoked");
		return;
	};

	/*** JSSE Hooks ***/

	/* libcore/luni/src/main/java/javax/net/ssl/TrustManagerFactory.java */
	/* public final TrustManager[] getTrustManager() */
	/* TrustManagerFactory.getTrustManagers maybe cause X509TrustManagerExtensions error  */
	// var TrustManagerFactory = Java.use("javax.net.ssl.TrustManagerFactory");
	// TrustManagerFactory.getTrustManagers.implementation = function(){
	//     quiet_send("TrustManagerFactory getTrustManagers invoked");
	//     return TrustManagers;
	// }

	var HttpsURLConnection = Java.use("javax.net.ssl.HttpsURLConnection");
	/* libcore/luni/src/main/java/javax/net/ssl/HttpsURLConnection.java */
	/* public void setDefaultHostnameVerifier(HostnameVerifier) */
	HttpsURLConnection.setDefaultHostnameVerifier.implementation = function(hostnameVerifier) {
		quiet_send("HttpsURLConnection.setDefaultHostnameVerifier invoked");
		return null;
	};
	/* libcore/luni/src/main/java/javax/net/ssl/HttpsURLConnection.java */
	/* public void setSSLSocketFactory(SSLSocketFactory) */
	HttpsURLConnection.setSSLSocketFactory.implementation = function(SSLSocketFactory) {
		quiet_send("HttpsURLConnection.setSSLSocketFactory invoked");
		return null;
	};
	/* libcore/luni/src/main/java/javax/net/ssl/HttpsURLConnection.java */
	/* public void setHostnameVerifier(HostnameVerifier) */
	HttpsURLConnection.setHostnameVerifier.implementation = function(hostnameVerifier) {
		quiet_send("HttpsURLConnection.setHostnameVerifier invoked");
		return null;
	};

	/*** Xutils3.x hooks ***/
	//Implement a new HostnameVerifier
	var TrustHostnameVerifier;
	try {
		TrustHostnameVerifier = Java.registerClass({
			name: 'org.wooyun.TrustHostnameVerifier',
			implements: [HostnameVerifier],
			method: {
				verify: function(hostname, session) {
					return true;
				}
			}
		});

	} catch (e) {
		//java.lang.ClassNotFoundException: Didn't find class "org.wooyun.TrustHostnameVerifier"
		quiet_send("registerClass from hostnameVerifier >>>>>>>> " + e.message);
	}

	try {
		var RequestParams = Java.use('org.xutils.http.RequestParams');
		RequestParams.setSslSocketFactory.implementation = function(sslSocketFactory) {
			sslSocketFactory = EmptySSLFactory;
			return null;
		}

		RequestParams.setHostnameVerifier.implementation = function(hostnameVerifier) {
			hostnameVerifier = TrustHostnameVerifier.$new();
			return null;
		}

	} catch (e) {
		quiet_send("Xutils hooks not Found");
	}

	/*** httpclientandroidlib Hooks ***/
	try {
		var AbstractVerifier = Java.use("ch.boye.httpclientandroidlib.conn.ssl.AbstractVerifier");
		AbstractVerifier.verify.overload('java.lang.String', '[Ljava.lang.String', '[Ljava.lang.String', 'boolean').implementation = function() {
			quiet_send("httpclientandroidlib Hooks");
			return null;
		}
	} catch (e) {
		quiet_send("httpclientandroidlib Hooks not found");
	}

	/***
android 7.0+ network_security_config TrustManagerImpl hook
apache httpclient partly
***/
	var TrustManagerImpl = Java.use("com.android.org.conscrypt.TrustManagerImpl");
	// try {
	//     var Arrays = Java.use("java.util.Arrays");
	//     //apache http client pinning maybe baypass
	//     //https://github.com/google/conscrypt/blob/c88f9f55a523f128f0e4dace76a34724bfa1e88c/platform/src/main/java/org/conscrypt/TrustManagerImpl.java#471
	//     TrustManagerImpl.checkTrusted.implementation = function (chain, authType, session, parameters, authType) {
	//         quiet_send("TrustManagerImpl checkTrusted called");
	//         //Generics currently result in java.lang.Object
	//         return Arrays.asList(chain);
	//     }
	//
	// } catch (e) {
	//     quiet_send("TrustManagerImpl checkTrusted nout found");
	// }

	try {
		// Android 7+ TrustManagerImpl
		TrustManagerImpl.verifyChain.implementation = function(untrustedChain, trustAnchorChain, host, clientAuth, ocspData, tlsSctData) {
			quiet_send("TrustManagerImpl verifyChain called");
			// Skip all the logic and just return the chain again :P
			//https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2017/november/bypassing-androids-network-security-configuration/
			// https://github.com/google/conscrypt/blob/c88f9f55a523f128f0e4dace76a34724bfa1e88c/platform/src/main/java/org/conscrypt/TrustManagerImpl.java#L650
			return untrustedChain;
		}
	} catch (e) {
		quiet_send("TrustManagerImpl verifyChain nout found below 7.0");
	}
	// OpenSSLSocketImpl
	try {
		var OpenSSLSocketImpl = Java.use('com.android.org.conscrypt.OpenSSLSocketImpl');
		OpenSSLSocketImpl.verifyCertificateChain.implementation = function(certRefs, authMethod) {
			quiet_send('OpenSSLSocketImpl.verifyCertificateChain');
		}

		quiet_send('OpenSSLSocketImpl pinning')
	} catch (err) {
		quiet_send('OpenSSLSocketImpl pinner not found');
	}
	// Trustkit
	try {
		var Activity = Java.use("com.datatheorem.android.trustkit.pinning.OkHostnameVerifier");
		Activity.verify.overload('java.lang.String', 'javax.net.ssl.SSLSession').implementation = function(str) {
			quiet_send('Trustkit.verify1: ' + str);
			return true;
		};
		Activity.verify.overload('java.lang.String', 'java.security.cert.X509Certificate').implementation = function(str) {
			quiet_send('Trustkit.verify2: ' + str);
			return true;
		};

		quiet_send('Trustkit pinning')
	} catch (err) {
		quiet_send('Trustkit pinner not found')
	}

	try {
		//cronet pinner hook
		//weibo don't invoke

		var netBuilder = Java.use("org.chromium.net.CronetEngine$Builder");

		//https://developer.android.com/guide/topics/connectivity/cronet/reference/org/chromium/net/CronetEngine.Builder.html#enablePublicKeyPinningBypassForLocalTrustAnchors(boolean)
		netBuilder.enablePublicKeyPinningBypassForLocalTrustAnchors.implementation = function(arg) {

			//weibo not invoke
			console.log("Enables or disables public key pinning bypass for local trust anchors = " + arg);

			//true to enable the bypass, false to disable.
			var ret = netBuilder.enablePublicKeyPinningBypassForLocalTrustAnchors.call(this, true);
			return ret;
		};

		netBuilder.addPublicKeyPins.implementation = function(hostName, pinsSha256, includeSubdomains, expirationDate) {
			console.log("cronet addPublicKeyPins hostName = " + hostName);

			//var ret = netBuilder.addPublicKeyPins.call(this,hostName, pinsSha256,includeSubdomains, expirationDate);
			//this 是調用 addPublicKeyPins 前的對象嗎? Yes,CronetEngine.Builder
			return this;
		};

	} catch (err) {
		console.log('[-] Cronet pinner not found')
	}
});

上面這個完全版本包含瞭如下功能，如果你想一步到位的話，就可以用這個完全版

SSLcontext(ART only)
okhttp
webview
XUtils(ART only)
httpclientandroidlib
JSSE
network_security_config (android 7.0+)
Apache Http client (support partly)
OpenSSLSocketImpl
TrustKit
Cronet

任意一個都可以，不要三個都用，都用也沒用，根據實際情況選用

安卓機配置代理

配置代理到開啟了抓包工具的IP上：

長按wiredssid

補充一句，當配置完代理後，pc端電腦上一定要打開對應的抓包軟體，不然安卓機會沒網

安卓機上安裝ssl證書

根據你選用的抓包工具，fiddler,charles,burpsuite，安裝證書即可，你可以訪問區域網下帶的ip來下載，然後安裝：

配置了代理再執行此步驟，不然打不開下載證書的區域網址

也可以用adb 像傳frida-server一樣，用adb push把證書push到安卓機上，然後在安卓機的設置-安全里本地導入證書：

用adb push 之後，還是把代理配置上，不然後面操作也無法繼續，不管怎麼操作，反正必須要ssl證書安裝上即可

開始hook

hook的本質意思就是鉤子，在開發裡面通俗的說就是可以在任意流程里插一手，然後做些手腳，比如打開一個app，在啟動到完全打開app，顯示app的首頁，這個過程就可以hook一下，比如把本來要打開首頁的，改成打開第二頁數據，當然這隻是舉個例子

啟動frida-server:

/data/local/tmp/frida-server

補充下，有的高級點的app會檢測本地是否啟動了frida-server的程式，以及監聽是否開啟了27042埠，所以，如果有反調試的話，建議將frida-server改個自定義的名字，比如fsx86之類的，反正就是別讓app檢測到，然後啟動：

/data/local/tmp/fsx86 -l 0.0.0.0:6666  (6666就是自定義埠)

這裡要用絕對路徑來啟動，我也不知道為啥，啟動，如下，warning是個警告，無所謂，說明啟動成功了，只要沒報錯就行了

映射埠

在pc端電腦，裝adb的機器上使用如下命令映射埠

adb forward tcp:27042 tcp:27042
adb forward tcp:27043 tcp:27043

找到需要hook的app包名

這個包名不是app的名字，是安裝之後存在目錄里的文件夾名，一般是com.xxxx.xxx之類的，但是有少部分奇葩的報名並不是com開頭

查看當前所有的包名：

frida-ps -U

註意要安卓機里先啟動了firda-server，然後adb連上了安卓機，才可以調用frida命令， 如果不啟動的話，運行frida這樣，Failed，失敗的意思

以上查看app包，顯示出來太多了，你根本不知道哪個才是我們需要的包名，可以使用下麵的命令查看

adb shell pm list packages：列印設備上的所有軟體包

adb shell pm list packages -f：輸出包和包相關聯的文件

adb shell pm list packages -d：只輸出禁用的包由於本機禁用沒有，輸出為空

adb shell pm list packages -e：只輸出啟用的包

adb shell pm list packages -s：只輸出系統的包

adb shell pm list packages -3：只輸出第三方的包

adb shell pm list packages -i：只輸出包和安裝信息（安裝來源）

adb shell pm list packages -u：只輸出包和未安裝包信息（安裝來源）

adb shell pm list packages --user <USER_ID>：根據用戶id查詢用戶的空間的所有包，USER_ID代表當前連接設備的順序，從零開始

如果還找不到，可以先在安卓機上啟動了目標app後，再用命令查看：

adb shell "dumpsys window | grep mCurrentFocus"

hook操作

frida -U -f （app包名） -l  （js目錄）  --no-pause

註意了，這段js是放在安裝了frida和adb的電腦上，不是放在安卓機上

運行完這條命令，安卓機會自動打開目標app，

app打開界面我就不展示了

如果打開的就是我們預期的那個app，那就是對的，如果打開錯了，請重新獲取app包名，打開之後就可以用抓包工具進行抓包了，ssl的一樣的可以抓：