抖音数据采集Frida进阶：脱壳、自动化、高频问题

抖音数据采集Frida进阶：脱壳、自动化、高频问题

短视频、直播数据实时采集接口，请查看文档： TiToData

免责声明：本文档仅供学习与参考，请勿用于非法用途！不然一切后果自负。

1 Frida用于脱壳

安全工程师在拿到应用评测的任务以后，第一件事情是抓到他的收包发包，第二件事情应该就是拿到它的apk，打开看看里面是什么内容，若是不幸它加了壳，可能打开就是这样的场景，见下图，什么内容都看不到，这时候就要首先对它进行脱壳。

壳的种类很是多，根据其种类不一样，使用的技术也不一样，这里稍微简单分个类：

• 一代总体型壳：采用Dex总体加密，动态加载运行的机制；
• 二代函数抽取型壳：粒度更细，将方法单独抽取出来，加密保存，解密执行；
• 三代VMP、Dex2C壳：独立虚拟机解释执行、语义等价语法迁移，强度最高。

先说最难的Dex2C目前是没有办法还原的，只能跟踪进行分析；VMP虚拟机解释执行保护的是映射表，只要心思细、功夫深，是能够将映射表还原的；二代壳函数抽取目前是能够从根本上进行还原的，dump出全部的运行时的方法体，填充到dump下来的dex中去的，这也是fart的核心原理；最后也就是目前咱们推荐的几个内存中搜索和dump出dex的Frida工具，在一些场景中能够知足你们的需求。

1.1 文件头搜dex

地址是：https://github.com/r0ysue/frida_dump

# frida -U --no-pause -f com.xxxxxx.xxxxxx  -l dump_dex.js
     ____
    / _  |   Frida 12.8.9 - A world-class dynamic instrumentation toolkit
   | (_| |
    > _  |   Commands:
   /_/ |_|       help      -> Displays the help system
   . . . .       object?   -> Display information about 'object'
   . . . .       exit/quit -> Exit
   . . . .
   . . . .   More info at https://www.frida.re/docs/home/
Spawned `com.xxxxx.xxxxx`. Resuming main thread!                
[Google Pixel::com.xxxxx.xxxxx]-> [dlopen:] libart.so
_ZN3art11ClassLinker11DefineClassEPNS_6ThreadEPKcmNS_6HandleINS_6mirror11ClassLoaderEEERKNS_7DexFileERKNS9_8ClassDefE 0x7adcac4f74
[DefineClass:] 0x7adcac4f74
[find dex]: /data/data/com.xxxxx.xxxxx/files/7abfc00000_8341c4.dex
[dump dex]: /data/data/com.xxxxx.xxxxx/files/7abfc00000_8341c4.dex
[find dex]: /data/data/com.xxxxx.xxxxx/files/7ac4096000_6e6c8.dex
[dump dex]: /data/data/com.xxxxx.xxxxx/files/7ac4096000_6e6c8.dex 
[find dex]: /data/data/com.xxxxx.xxxxx/files/7ac37c4028_8781c4.dex
[dump dex]: /data/data/com.xxxxx.xxxxx/files/7ac37c4028_8781c4.dex

其核心逻辑原理就是下面一句话magic.indexOf("dex") == 0，只要文件头中含有魔数dex，就把它dump下来。

if (dex_maps[base] == undefined) {
    dex_maps[base] = size;
    var magic = ptr(base).readCString();
    if (magic.indexOf("dex") == 0) {
        var process_name = get_self_process_name();
        if (process_name != "-1") {
            var dex_path = "/data/data/" + process_name + "/files/" + base.toString(16) + "_" + size.toString(16) + ".dex";
            console.log("[find dex]:", dex_path);
            var fd = new File(dex_path, "wb");
            if (fd && fd != null) {
                var dex_buffer = ptr(base).readByteArray(size);
                fd.write(dex_buffer);
                fd.flush();
                fd.close();
                console.log("[dump dex]:", dex_path);
            }
        }
    }
}

1.2 DexClassLoader：objection

安卓只能使用继承自BaseDexClassLoader的两种ClassLoader，一种是PathClassLoader，用于加载系统中已经安装的apk；一种就是DexClassLoader，加载未安装的jar包或apk。
能够用objcetion直接在堆上暴力搜索全部的dalvik.system.DexClassLoader实例，效果见下图：

# android heap search instances dalvik.system.DexClassLoader

连热补丁都被搜出来了，在某些一代壳上效果不错。

1.3 暴力搜内存：DEXDump

地址：https://github.com/hluwa/FRIDA-DEXDump

• 对于完整的dex，采用暴力搜索dex035便可找到。
• 而对于抹头的dex，经过匹配一些特征来找到，而后自动修复文件头。

效果很是好：

root@roysuekali:~/Desktop/FRIDA-DEXDump# python main.py 
[DEXDump]: found target [7628] com.xxxxx.xxxxx
[DEXDump]: DexSize=0x8341c4, SavePath=./com.xxxxx.xxxxx/0x7abfc00000.dex
[DEXDump]: DexSize=0x8341c4, SavePath=./com.xxxxx.xxxxx/0x7ac0600000.dex
root@roysuekali:~/Desktop/FRIDA-DEXDump# du -h com.xxxxx.xxxxx/*
8.3M    com.xxxxx.xxxxx/0x7abfc00000.dex
8.3M    com.xxxxx.xxxxx/0x7ac0600000.dex
root@roysuekali:~/Desktop/FRIDA-DEXDump# file com.xxxxx.xxxxx/*
com.xxxxx.xxxxx/0x7abfc00000.dex: Dalvik dex file version 035
com.xxxxx.xxxxx/0x7ac0600000.dex: Dalvik dex file version 035

打开dump下来的dex，很是完整，能够用jadx直接解析。用010打开能够看到完整的文件头——dexn035，其实现代码也是简单粗暴，直接搜索：64 65 78 0a 30 33 35 00：

Memory.scanSync(range.base, range.size, "64 65 78 0a 30 33 35 00").forEach(function (match) {
var range = Process.findRangeByAddress(match.address);
if (range != null && range.size < match.address.toInt32() + 0x24 - range.base.toInt32()) {
    return;
}
var dex_size = match.address.add("0x20").readInt();
if (range != null) {
    if (range.file && range.file.path
        && (range.file.path.startsWith("/data/app/")
            || range.file.path.startsWith("/data/dalvik-cache/")
            || range.file.path.startsWith("/system/"))) {
        return;
    }
    if (match.address.toInt32() + dex_size > range.base.toInt32() + range.size) {
        return;
    }
}

还有一部分想要特征匹配的功能还在实现中：

// @TODO improve fuzz
if (
    range.size >= 0x60
    && range.base.readCString(4) != "dexn"
    && range.base.add(0x20).readInt() <= range.size //file_size
    // && range.base.add(0x24).readInt() == 112 //header_size
    && range.base.add(0x34).readInt() < range.size
    && range.base.add(0x3C).readInt() == 112 //string_id_off
) {
    result.push({
        "addr": range.base,
        "size": range.base.add(0x20).readInt()
    });
}

1.4 暴力搜内存：objection

既然直接使用Frida的API能够暴力搜索内存，那么别忘了咱们上面介绍过的objection也能够暴力搜内存。

# memory search "64 65 78 0a 30 33 35 00"

搜出来的offset是：0x79efc00000，大小是c4 41 83 00，也就是0x8341c4，转化成十进制就是8602052，最后dump下来的内容与FRIDA-DEXDump脱下来的如出一辙，拖到jdax里能够直接解析。

2 Frida用于自动化

在Frida出现以前，没有任何一款工具，能够在语言级别支持直接在电脑上调用app中的方法。像Xposed是纯Java，根本就没有电脑上运行的版本；各类Native框架也是同样，都是由C/C++/asm实现，根本与电脑毫无关系。
而Frida主要是一款在电脑上操做的工具，其自己就决定了其“高并发”、“多联通”、“自动化”等特性：

• “高并发”：同时操做多台手机，同时调用多个手机上的多个app中的算法；
• “多联通”：电脑与手机互联互通，手机上处理不了的在电脑上处理、反之亦然；
• “自动化”：手机电脑互相协同，实现横跨桌面、移动平台协同自动化利器。

2.1 链接多台设备

Frida用于自动化的场景中，必然是不可能在终端敲frida-tools里的那些命令行工具的，有人说能够将这些命令按顺序写成脚本，那为啥不直接写成python脚本呢？枉费大胡子叔叔（Frida的做者oleavr的头像）为咱们写好了Python bindings，咱们只须要直接调用便可享受。
Python bindings在安装好frida-tools的时候已经默认安装在咱们的电脑上了，能够直接使用。
链接多台设备很是简单，若是是USB口直接链接的，只要确保adb已经链接上，若是是网络调试的，也要用adb connect链接上，而且都开启frida server，键入adb devices或者frida-ls-devices命令时多台设备的id都会出现，最终可使用frida.get_device(id)的API来选择设备，以下图所示。

2.2 互联互通

互联互通是指把app中捕获的内容传输到电脑上，电脑上处理结束后再发回给app继续处理。看似很简单的一个功能，目前却仅有Frida能够实现。
好比说咱们有这样一个app，其中最核心的地方在于判断用户是否为admin，若是是，则直接返回错误，禁止登录。若是不是，则把用户和密码上传到服务器上进行验证登陆操做，其核心代码逻辑以下：

public class MainActivity extends AppCompatActivity {
    EditText username_et;
    EditText password_et;
    TextView message_tv;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        password_et = (EditText) this.findViewById(R.id.editText2);
        username_et = (EditText) this.findViewById(R.id.editText);
        message_tv = ((TextView) findViewById(R.id.textView));
        this.findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (username_et.getText().toString().compareTo("admin") == 0) {
                    message_tv.setText("You cannot login as admin");
                    return;
                }
                //咱们hook的目标就在这里
                message_tv.setText("Sending to the server :" + Base64.encodeToString((username_et.getText().toString() + ":" + password_et.getText().toString()).getBytes(), Base64.DEFAULT));
            }
        });
    }
}

运行起来的效果以下图：

咱们的目标就是在电脑上“获得”输入框输入的内容，而且修改其输入的内容，而且“传输”给安卓机器，使其经过验证。也就是说，咱们的目标是哪怕输入admin的帐户名和密码，也能够绕过本地校验，进行服务器验证登录的操做。
因此最终咱们的hook代码的逻辑就是，截取输入，传输给电脑，暂停执行，获得电脑传回的数据以后，继续执行，用js来写就这么写：

Java.perform(function () {
    var tv_class = Java.use("android.widget.TextView");
    tv_class.setText.overload("java.lang.CharSequence").implementation = function (x) {
        var string_to_send = x.toString();
        var string_to_recv;
        send(string_to_send); // 将数据发送给kali主机的python代码
        recv(function (received_json_object) {
            string_to_recv = received_json_object.my_data
            console.log("string_to_recv: " + string_to_recv);
        }).wait(); //收到数据以后，再执行下去
        return this.setText(string_to_recv);
    }
});

在电脑上的处理流程是，将接受到的JSON数据解析，提取出其中的密码部分保持不变，而后将用户名替换成admin，这样就实现了将admin和password发送给服务器的结果。咱们的代码以下：

import time
import frida
def my_message_handler(message, payload):
    print message
    print payload
    if message["type"] == "send":
        print message["payload"]
        data = message["payload"].split(":")[1].strip()
        print 'message:', message
        data = data.decode("base64") # 解码
        user, pw = data.split(":") # 提取用户名和密码
        data = ("admin" + ":" + pw).encode("base64") # 组成新的组合并编码
        print "encoded data:", data
        script.post({"my_data": data})  # 将JSON对象发送回去
        print "Modified data sent"
device = frida.get_usb_device()
pid = device.spawn(["com.roysue.demo04"])
device.resume(pid)
time.sleep(1)
session = device.attach(pid)
with open("s4.js") as f:
    script = session.create_script(f.read())
script.on("message", my_message_handler)  # 注册消息处理函数
script.load()
raw_input()

一样不少手机上没法处理的数据，也能够编码后发送到电脑上进行处理，好比处理GBK编码的中文字符集数据，再好比对dump下来的内存或so进行二次解析还原等，这些在js几乎是没法处理的（或难度很是大），可是到了电脑上就易如反掌，用python导入几个库就能够。
在一些(网络)接口的模糊测试的场景中，一些字典和畸形数据的构造也会在电脑上完成，app端最多做为执行端接受和发送这些数据，这时候也须要使用到Frida互联互通动态修改的功能。

2.3 远程调用（RPC）

在脚本里定义一个导出函数，并用rpc.exports的字典进行声明：

function callSecretFun() { //定义导出函数
    Java.perform(function () {
        //to-do 作本身想作的事情 
        //好比这里是找到隐藏函数而且调用
        Java.choose("com.roysue.demo02.MainActivity", {
            onMatch: function (instance) {
                console.log("Found instance: " + instance);
                console.log("Result of secret func: " + instance.secret());
            },
            onComplete: function () { }
        });
    });
}
rpc.exports = {
    callsecretfunction: callSecretFun //把callSecretFun函数导出为callsecretfunction符号，导出名不能够有大写字母或者下划线
};

在电脑上就能够直接在py代码里调用这个方法：

import time
import frida
def my_message_handler(message, payload):
    print message
    print payload
device = frida.get_usb_device()
pid = device.spawn(["com.roysue.demo02"])
device.resume(pid)
time.sleep(1)
session = device.attach(pid)
with open("s3.js") as f:
    script = session.create_script(f.read())
script.on("message", my_message_handler)
script.load()
command = ""
while 1 == 1:
    command = raw_input("Enter command:n1: Exitn2: Call secret functionnchoice:")
    if command == "1":
        break
    elif command == "2": #在这里调用
        script.exports.callsecretfunction()

最终效果就是按一下2，function callSecretFun()就会被执行一次，而且结果会显示在电脑上的py脚本里，以供后续继续处理，很是方便。
笔者有一位朋友甚至将该接口使用python的flask框架暴露出去，让网络里的每一个人均可以调用该方法，给本身的发包进行签名，可用说是一个需求很是庞大的场景。

3 Frida更多技巧

最后收集和整理一下你们在学习Frida的过程当中可能会遇到的几个高频问题，以餮读者。

3.1 必须上版本管理

Frida从面世到如今已经有四五年了，大概17~18年那会儿开始火爆起来，大量的脚本和工具代码都是那段时间写出来的，而Frida又升级特别快，新的Frida对老的脚本兼容性不是很好，见下图最新的Frida运行老的脚本，日志格式已经乱掉了，而老版本（12.4.8）就没问题，见图2-18。若是要运行一些两三年历史的代码，必然须要安装两三年前左右的版本，这样才能跑起来，而且不出错。

版本管理用pyenv便可，熟练使用pyenv能够基本上知足同时安装几十个Frida版本的需求。

3.2 反调试基本思路

几个最基本的思路，首先frida-server的文件名改掉，相似于frida-server-12.8.9-android-arm64这样的文件名，我通常改为fs1289amd64，固然读者能够想改为啥就改为啥。
有些反调试还会检查端口，好比frida-server的默认端口是27042，这个端口通常不会有人用，若是27042端口打开而且正在监听，反调试就会工做，能够把端口改为非标准端口，方法下一小节就讲。
最后还有一种经过Frida内存特征对maps中elf文件进行扫描匹配特征的反调试方法，支持frida-gadget和frida-server，项目地址在这里。
其核心代码以下：

void *check_loop(void *) {
    int fd;
    char path[256];
    char perm[5];
    unsigned long offset;
    unsigned int base;
    long end;
    char buffer[BUFFER_LEN];
    int loop = 0;
    unsigned int length = 11;
    //"frida:rpc"的内存布局特征
    unsigned char frida_rpc[] =
            {
                    0xfe, 0xba, 0xfb, 0x4a, 0x9a, 0xca, 0x7f, 0xfb,
                    0xdb, 0xea, 0xfe, 0xdc
            };
    for (unsigned char &m : frida_rpc) {
        unsigned char c = m;
        c = ~c;
        c ^= 0xb1;
        c = (c >> 0x6) | (c << 0x2);
        c ^= 0x4a;
        c = (c >> 0x6) | (c << 0x2);
        m = c;
    }
    //开始检测frida反调试循环
    LOGI("start check frida loop");
    while (loop < 10) {
        fd = wrap_openat(AT_FDCWD, "/proc/self/maps", O_RDONLY, 0);
        if (fd > 0) {
            while ((read_line(fd, buffer, BUFFER_LEN)) > 0) {
                // 匹配frida-server和frida-gadget的内存特征
                if (sscanf(buffer, "%x-%lx %4s %lx %*s %*s %s", &base, &end, perm, &offset, path) !=
                    5) {
                    continue;
                }
                if (perm[0] != 'r') continue;
                if (perm[3] != 'p') continue; 
                if (0 != offset) continue;
                if (strlen(path) == 0) continue;
                if ('[' == path[0]) continue;
                if (end - base <= 1000000) continue;
                if (wrap_endsWith(path, ".oat")) continue;
                if (elf_check_header(base) != 1) continue;
                if (find_mem_string(base, end, frida_rpc, length) == 1) {
                    //发现其内存特征
                    LOGI("frida found in memory!");
#ifndef DEBUG
                    //杀掉本身的进程
                    wrap_kill(wrap_getpid(),SIGKILL);
#endif
                    //退出
                    break;
                }
            }
        } else {
            LOGI("open maps error");
        }
        wrap_close(fd);
        //休息三秒，进入下一个检查循环，也就是这个反调试一共会运做30秒，30秒后结束
        loop++;
        sleep(3);
    }
    return nullptr;
}
void anti_frida_loop() {
    pthread_t t;
    //建立一个线程，执行反调试工做
    if (pthread_create(&t, nullptr, check_loop, (void *) nullptr) != 0) {
        exit(-1);
    };
    pthread_detach(t);
}

想过这种反调试，得找到反调试在哪一个so的哪里，nop掉建立check_loop线程的地方，或者nop掉kill本身进程的地方，均可以。也能够直接kill掉反调试进程，笔者就曾经遇到过这种状况，frida命令注入后，app调不起来，这时候用ps -e命令查看多一个反调试进程，直接kill掉那个进程后，app就起来了，这个app是使用的一个大厂的加固服务，这个进程就是壳的一部分。

3.3 非标准端口链接

好比将frida-server启动在6666端口：

# ./fs1287amd64 -l 0.0.0.0:6666

使用frida-tools工具和objection分别链接的方法以下：

# frida-ps -H 192.168.1.102:6666
# objection -N -h 192.168.1.102 -p 6666 -g com.android.settings explore

效果如图所示：

图 链接非标准端口
在python bindings中链接的话，会稍微复杂一点点，由于python bindings只认adb，因此要经过adb命令将手机的6666端口映射到电脑的27042端口：

$ adb forward tcp:27042 tcp:6666

这样python bindings也能够正常使用了。

3.4 打印byte[]``[B

ByteString.of是用来把byte[]数组转成hex字符串的函数, 安卓系统自带ByteString，app里面没有也不要紧，能够去系统里面拿，这里给个小案例：

var ByteString = Java.use("com.android.okhttp.okio.ByteString");
var j = Java.use("xxxxxxx.business.comm.j");
j.x.implementation = function() {
    var result = this.x();
    console.log("j.x:", ByteString.of(result).hex());
    return result;
};
j.a.overload('[B').implementation = function(bArr) {
    this.a(bArr);
    console.log("j.a:", ByteString.of(bArr).hex());
};

3.5 hook管理子进程

常常有人会问，像那种com.xxx.xxx:push、com.xxx.xxx:service、com.xxx.xxx:notification、com.xxx.xxx:search这样的进程如何hook，或者说如何在其建立伊始进行hook，由于这样的进程通常都是由主进程fork()出来的。
这种的就要用到Frida最新的Child gating机制，能够参考个人过往的文章，官方的完整代码在这里。能够在进程建立之初对该进程进行控制和hook，已经不少人用了，效果很好，达成目标。

3.6 hook混淆方法名

有些方法名上了很强的混淆，如何处理？其实很简单，能够看上面ZenTracer的源码，hook类的全部子类，hook类的全部方法，而且hook方法的全部重载。

3.7 中文参数问题

hook某些方法的时候，发现传进来的参数居然是中文的，如何打印出来？若是是utf8还好，Frida的CLI也是直接支持utf8的，若是是GBK字符集的，目前没有找到在js里进行打印的方法，能够send()到电脑上进行打印。

3.8 hook主动注册

使用Frida来hook JNI的一些函数，打印出主动调用的执行路径。下面是hook Google play Market的例子：

frida -U --no-pause -f com.android.vending -l hook_RegisterNatives.js
     ____
    / _  |   Frida 12.6.13 - A world-class dynamic instrumentation toolkit
   | (_| |
    > _  |   Commands:
   /_/ |_|       help      -> Displays the help system
   . . . .       object?   -> Display information about 'object'
   . . . .       exit/quit -> Exit
   . . . .
   . . . .   More info at http://www.frida.re/docs/home/
Spawning `com.android.vending`...                                      
GetFieldID is at  0xf1108e4d _ZN3art3JNI10GetFieldIDEP7_JNIEnvP7_jclassPKcS6_
AllocObject is at  0xf10f1809 _ZN3art3JNI11AllocObjectEP7_JNIEnvP7_jclass
GetMethodID is at  0xf10f3175 _ZN3art3JNI11GetMethodIDEP7_JNIEnvP7_jclassPKcS6_
NewStringUTF is at  0xf111fc71 _ZN3art3JNI12NewStringUTFEP7_JNIEnvPKc
GetObjectClass is at  0xf10f2841 _ZN3art3JNI14GetObjectClassEP7_JNIEnvP8_jobject
RegisterNatives is at  0xf11301fd _ZN3art3JNI15RegisterNativesEP7_JNIEnvP7_jclassPK15JNINativeMethodi
CallObjectMethod is at  0xf10f3745 _ZN3art3JNI16CallObjectMethodEP7_JNIEnvP8_jobjectP10_jmethodIDz
GetStaticFieldID is at  0xf111949d _ZN3art3JNI16GetStaticFieldIDEP7_JNIEnvP7_jclassPKcS6_
GetStaticMethodID is at  0xf110e6d1 _ZN3art3JNI17GetStaticMethodIDEP7_JNIEnvP7_jclassPKcS6_
GetStringUTFChars is at  0xf11203e1 _ZN3art3JNI17GetStringUTFCharsEP7_JNIEnvP8_jstringPh
ReleaseStringUTFChars is at  0xf11207fd _ZN3art3JNI21ReleaseStringUTFCharsEP7_JNIEnvP8_jstringPKc
FindClass is at  0xf10ec7a1 _ZN3art3JNI9FindClassEP7_JNIEnvPKc
Spawned `com.android.vending`. Resuming main thread!                   
[Google Pixel XL::com.android.vending]-> [RegisterNatives] method_count: 0x6
[RegisterNatives] java_class: org.chromium.base.CommandLine name: nativeInit sig: ([Ljava/lang/String;)V fnPtr: 0xd454f349 module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130349
[RegisterNatives] java_class: org.chromium.base.CommandLine name: nativeHasSwitch sig: (Ljava/lang/String;)Z fnPtr: 0xd454f369 module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130369
[RegisterNatives] java_class: org.chromium.base.CommandLine name: nativeGetSwitchValue sig: (Ljava/lang/String;)Ljava/lang/String; fnPtr: 0xd454f3bd module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x1303bd
[RegisterNatives] java_class: org.chromium.base.CommandLine name: nativeAppendSwitch sig: (Ljava/lang/String;)V fnPtr: 0xd454f461 module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130461
[RegisterNatives] java_class: org.chromium.base.CommandLine name: nativeAppendSwitchWithValue sig: (Ljava/lang/String;Ljava/lang/String;)V fnPtr: 0xd454f499 module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130499
[RegisterNatives] java_class: org.chromium.base.CommandLine name: nativeAppendSwitchesAndArguments sig: ([Ljava/lang/String;)V fnPtr: 0xd454f4f1 module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x1304f1
[RegisterNatives] method_count: 0x3
[RegisterNatives] java_class: org.chromium.base.EarlyTraceEvent name: nativeRecordEarlyEvent sig: (Ljava/lang/String;JJIJ)V fnPtr: 0xd454f94d module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x13094d
[RegisterNatives] java_class: org.chromium.base.EarlyTraceEvent name: nativeRecordEarlyStartAsyncEvent sig: (Ljava/lang/String;JJ)V fnPtr: 0xd454fa3d module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130a3d
[RegisterNatives] java_class: org.chromium.base.EarlyTraceEvent name: nativeRecordEarlyFinishAsyncEvent sig: (Ljava/lang/String;JJ)V fnPtr: 0xd454fae5 module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130ae5
[RegisterNatives] method_count: 0x4
[RegisterNatives] java_class: org.chromium.base.FieldTrialList name: nativeFindFullName sig: (Ljava/lang/String;)Ljava/lang/String; fnPtr: 0xd454fb8d module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130b8d
[RegisterNatives] java_class: org.chromium.base.FieldTrialList name: nativeTrialExists sig: (Ljava/lang/String;)Z fnPtr: 0xd454fbff module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130bff
[RegisterNatives] java_class: org.chromium.base.FieldTrialList name: nativeGetVariationParameter sig: (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String; fnPtr: 0xd454fc2f module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130c2f
[RegisterNatives] java_class: org.chromium.base.FieldTrialList name: nativeLogActiveTrials sig: ()V fnPtr: 0xd454fd1d module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130d1d
[RegisterNatives] method_count: 0x2

源码地址：https://github.com/lasting-yang/frida_hook_libart

3.9 追踪JNI API

地址：https://github.com/chame1eon/jnitrace

3.10 延迟hook

不少时候在带壳hook的时候，善用两个frida提供的延时hook机制：

• frida --no-pause是进程直接执行，有时候会hook不到，若是把--no-pause拿掉，进入CLI以后延迟几秒再使用%resume恢复执行，就会hook到；
• js中的setTimeout(func, delay[, ...parameters])函数，会延时delay毫秒来调用func，有时候不加延时会hook不到，加个几百到几千毫秒的延时就会hook到。