前言：
受人所托，需要对他们的产品进行反爬测试，所以就有了以下内容。
不过，我知道，针对这方面的文章太多了，是真的多，而且好早就有了，但是目前为止，很多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
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的一样的可以抓：
上面看到的https的还是会隧道，但是紧接着就有数据出现，说明还是抓到了数据包了
ok，绕过ssl pinning成功！！！
其实如果你觉得需要做些改动的话，可以写个python脚本来调用，js代码就作为文件内容读取就行了，然后进行hook操作
最后得出的结论就是，我朋友他们的产品，其实反爬做得挺好，上面的截图也可以看到，其实还是有些数据拿不到的
补充：
如果你用的模拟器在安装了app之后打不开，说明app有检测是否是模拟器或者对安卓版本做了检测，版本太低直接不给使用，那么你就只能用真机操作了，adb连接真机操作区别不大，详细的自行百度
检测模拟器的办法：
- 1.检测模拟器上特有的文件
- 2.检测qemu pipes驱动程序
- 3.检测手机号是否是155552155开头的
- 4.检测设备ID是否是15个0
- 5.检测IMSI ID是否是31026+10个0
- 6.检测运营商是否是“Android”
- 7.代码里用getInstance()方法调用任意一个方法，返回true就是模拟器
- 8.检测IMEI或者入网许可证
以上都是我以前搜集的数据，但是，根据现在的时代发展，可能模拟器也早就更新迭代了，把一些特征给抹除或者改的跟真机一样了，所以有些方法并不是有用了，这个就只有自行选择了
免root使用frida
其实不root也可以使用frida，这里我就不展开了，给一个大神写的链接，里面还有其他方法的hook，感兴趣自己看吧，点我