Frida 实战进阶：从 Java Hook 到 SO 层、RPC 与反调试绕过

阶段 1  Java 层 Hook：从 Java.use 到方法追踪
  ↓
阶段 2  SO 层 Hook：模块基址、导出函数与 Interceptor
  ↓
阶段 3  JNI 与 libart.so：深入到 Native 调用链
  ↓
阶段 4  主动调用与 RPC：让 Hook 脚本可被 Python 驱动
  ↓
阶段 5  自动化与群控：从单次 Hook 到批量流水线
  ↓
阶段 6  实战对抗：反调试与 SSL Pinning 绕过

Java.perform(function () {
    var TargetClass = Java.use("com.target.ClassName");

    TargetClass.targetMethod.implementation = function (a, b) {
        console.log("[*] targetMethod called:", a, b);

        // 调用原函数（注意 this 和参数传递方式）
        var ret = this.targetMethod(a, b);

        console.log("[*] returned:", ret);
        return ret;
    };
});

// 写法一：显式传参（推荐，参数个数固定时最清晰）
TargetClass.targetMethod.implementation = function (a, b) {
    return this.targetMethod(a, b);   // 这里调的是原方法（因为已经备份）
};

// 写法二：透传所有参数（参数个数不定或不想关心签名时）
TargetClass.targetMethod.implementation = function () {
    return this.targetMethod.apply(this, arguments);
};

var TargetClass = Java.use("com.target.ClassName");

// 只 Hook 签名是 (int, String) 的那一个
TargetClass.targetMethod
    .overload('int', 'java.lang.String')
    .implementation = function (a, b) {
        console.log("[*] int/String overload:", a, b);
        return this.targetMethod(a, b);
    };

// 枚举所有重载
TargetClass.targetMethod.overloads.forEach(function (m) {
    var types = m.argumentTypes
        .map(function (t) { return t.className; })
        .join(', ');
    console.log("[*] overload: (" + types + ")");
});

// Java 源码里的 Outer.Inner → Frida 里写 Outer$Inner
var Inner = Java.use("com.example.Activity$InnerClasses");

Java.enumerateClassLoaders({
    onMatch: function (loader) {
        try {
            // 尝试用这个 loader 加载目标类，成功说明找到了
            var factory = Java.ClassFactory.get(loader);
            var cls = factory.use("com.target.ClassName");
            console.log("[+] Found class in loader:", loader);
        } catch (e) {
            // 这个 loader 加载不了目标类，继续下一个
        }
    },
    onComplete: function () {
        console.log("[*] enumeration complete");
    }
});

Java.enumerateLoadedClasses({
    onMatch: function (className) {
        if (className.indexOf("com.target") >= 0) {
            console.log(className);
        }
    },
    onComplete: function () {}
});

遍历所有类 → 按规则匹配目标类 → 枚举类的方法 → 枚举重载 → Hook implementation
  → 记录入参 → 调用原函数 → 记录返回值

function traceClass(classNamePattern, methodWhitelist) {
    Java.perform(function () {
        Java.enumerateLoadedClasses({
            onMatch: function (className) {
                if (!className.match(classNamePattern)) return;

                var cls;
                try {
                    cls = Java.use(className);
                } catch (e) {
                    return;   // 某些系统类无法 use，跳过
                }

                var methods;
                try {
                    methods = cls.class.getDeclaredMethods();   // 反射拿方法列表
                } catch (e) {
                    return;
                }

                methods.forEach(function (method) {
                    var name = method.getName();
                    // 没有白名单就 trace 全部；有白名单只 trace 指定方法
                    if (methodWhitelist && methodWhitelist.indexOf(name) < 0) return;

                    // 拿到这个方法的所有重载
                    var overloads;
                    try {
                        overloads = cls[name].overloads;
                    } catch (e) {
                        return;
                    }

                    overloads.forEach(function (overload) {
                        var sig = overload.argumentTypes
                            .map(function (t) { return t.className; })
                            .join(', ');
                        console.log("[+] hooking " + className + "." + name + "(" + sig + ")");

                        overload.implementation = function () {
                            var args = Array.prototype.slice.call(arguments);
                            console.log("[>] " + name + "(" + args.join(', ') + ")");

                            var ret = overload.apply(this, arguments);

                            console.log("[<] " + name + " -> " + ret);
                            return ret;
                        };
                    });
                });
            },
            onComplete: function () {
                console.log("[*] trace setup done");
            }
        });
    });
}

// 用法：只 trace com.target.crypto 包里，且只关心这三个方法
traceClass(/com\.target\.crypto/, ['encrypt', 'decrypt', 'getKey']);

// 主动调用静态方法
Java.perform(function () {
    var cls = Java.use("com.target.Util");
    var result = cls.calcKey("input");
    console.log("[*] calcKey('input') =", result);
});

// 读写类的静态字段
var cls = Java.use("com.target.Config");
console.log(cls.API_KEY.value);      // 读
cls.API_KEY.value = "hacked";        // 写

// 创建实例（new 一个对象）
var obj = cls.$new();                // 无参
var obj2 = cls.$new(1, "arg");       // 带参

// 1. 获取模块基址
var base = Module.findBaseAddress("libmyjni.so");
console.log("[*] libmyjni.so base:", base);

// 2. 按名称查找导出函数（最简单，但只能找导出符号）
var n2 = Module.findExportByName("libmyjni.so", "n2");
console.log("[*] n2 addr:", n2);

// 3. 通过模块 + 偏移定位未导出函数（偏移需自己逆向分析）
var module = Process.findModuleByName("libart.so");
var addr = module.base.add(0x1234);

// 4. 枚举模块的所有导出
var mod = Process.findModuleByName("libmyjni.so");
mod.enumerateExports().forEach(function (exp) {
    if (exp.name.indexOf("Java_") >= 0) {
        console.log("[+] export:", exp.name, exp.address);
    }
});

Interceptor.attach(n2, {
    onEnter: function (args) {
        // args 是 NativePointer 数组，args[0] 是第一个参数
        console.log("[>] n2 called");
        console.log("    arg0:", args[0]);
        console.log("    arg1:", args[1]);

        // 读字符串参数（x0/x1 指向 C 字符串时）
        if (!args[0].isNull()) {
            console.log("    arg0 as string:", args[0].readCString());
        }

        // 保存现场，方便 onLeave 或后续分析使用
        this.arg0 = args[0];
        this.backtrace = Thread.backtrace(this.context, Backtracer.ACCURATE)
            .map(DebugSymbol.fromAddress).join('\n');
    },
    onLeave: function (retval) {
        console.log("[<] n2 returned:", retval);
        console.log("    call stack:\n" + this.backtrace);

        // 修改返回值（常见需求：让校验函数返回 true）
        // retval.replace(ptr(1));
    }
});

// 读内存
args[0].readCString();        // 读 C 字符串（遇到 \0 停）
args[0].readUtf8String(16);   // 按长度读 UTF-8
args[0].readU32();            // 读 32 位无符号整数
args[0].readPointer();        // 读一个指针

// 写内存
args[0].writeU32(0x1234);

// 修改返回值
onLeave: function (retval) {
    retval.replace(ptr(0));     // 返回 NULL
    // 或 retval.replace(1);    // 返回整数 1
}

// 拿到调用地址（定位是谁调用了这个函数）
onEnter: function (args) {
    console.log("caller:", this.returnAddress);
}

// 用 Interceptor.replace 完全替换函数实现
var target = Module.findExportByName("libmyjni.so", "check_license");
Interceptor.replace(target, new NativeCallback(function (key) {
    console.log("[*] check_license bypassed");
    return 1;   // 永远返回 1（通过）
}, 'int', ['pointer']));

var n2 = Module.findExportByName("libmyjni.so", "n2");
var n2Func = new NativeFunction(n2, 'int', ['int', 'pointer']);

// 主动调用
var ret = n2Func(42, Memory.allocUtf8String("hello"));
console.log("[*] n2(42, 'hello') =", ret);

枚举 libart.so 的符号 → 找到目标 JNI 函数 → 计算地址 → Interceptor.attach

var module = Process.findModuleByName("libart.so");
var symbols = module.enumerateSymbols();

symbols.forEach(function (sym) {
    if (sym.name.indexOf("NewStringUTF") >= 0) {
        console.log("[+] symbol:", sym.name, sym.address);
    }
});

// JNI 函数表顺序（节选，完整表见 JNI 规范 jni.h）
const jniStructArray = [
    "reserved0", "reserved1", "reserved2", "reserved3",
    "GetVersion",
    "DefineClass", "FindClass",
    "FromReflectedMethod", "FromReflectedField",
    "ToReflectedMethod",
    "GetSuperclass", "IsAssignableFrom",
    "ToReflectedField",
    "Throw", "ThrowNew",
    "ExceptionOccurred", "ExceptionDescribe", "ExceptionClear", "FatalError",
    "PushLocalFrame", "PopLocalFrame",
    "NewGlobalRef", "DeleteGlobalRef", "DeleteLocalRef", "IsSameObject",
    "NewLocalRef", "EnsureLocalCapacity",
    "AllocObject", "NewObject", "NewObjectV", "NewObjectA",
    "GetObjectClass", "IsInstanceOf",
    "GetMethodID",
    "CallObjectMethod", "CallObjectMethodV", "CallObjectMethodA",
    // ... 后面还有几百个，按 jni.h 顺序补全
    "GetStringUTFLength", "GetStringUTFChars",
    "ReleaseStringUTFChars",
    "GetArrayLength", "NewObjectArray",
    "NewStringUTF",
];

// 定位 NewStringUTF 的地址
var env = Java.vm.getEnv();        // 拿到 JNIEnv*
var envPtr = env.handle.readPointer();  // 解引用到 JNINativeInterface*

var offset = jniStructArray.indexOf("NewStringUTF") * Process.pointerSize;
var newStringUTFAddr = envPtr.add(offset).readPointer();

console.log("[*] NewStringUTF at:", newStringUTFAddr);

Interceptor.attach(newStringUTFAddr, {
    onEnter: function (args) {
        // args[0] = env, args[1] = const char*
        console.log("[>] NewStringUTF:", args[1].readCString());
    },
    onLeave: function (retval) {
        // retval = jstring
    }
});

// 找到 RegisterNatives 地址（同样可以用 JNIEnv 偏移法）
var idx = jniStructArray.indexOf("RegisterNatives");
var regNativesAddr = envPtr
    .add(idx * Process.pointerSize)
    .readPointer();

var JNINativeMethod = {
    "name": "pointer",      // const char* name
    "signature": "pointer", // const char* signature
    "fnPtr": "pointer"      // void* fnPtr
};

Interceptor.attach(regNativesAddr, {
    onEnter: function (args) {
        // args[0]=env, args[1]=jclass
        // args[2]=JNINativeMethod*, args[3]=nMethods
        var methods = args[2];
        var count = parseInt(args[3]);

        console.log("[*] RegisterNatives count =", count);

        // JNINativeMethod 是 3 个指针，步长 = 3 * pointerSize
        var stride = Process.pointerSize * 3;

        for (var i = 0; i < count; i++) {
            var base = methods.add(i * stride);

            var namePtr = base.readPointer();
            var sigPtr  = base.add(Process.pointerSize).readPointer();
            var fnPtr   = base.add(Process.pointerSize * 2).readPointer();

            var name = namePtr.readCString();
            var sig  = sigPtr.readCString();

            console.log("    [" + i + "] " + name + sig + " -> " + fnPtr);

            // 顺手 Hook 上这个函数
            Interceptor.attach(fnPtr, {
                onEnter: function (a) {
                    console.log("    [>] " + name + " called");
                }
            });
        }
    }
});

setImmediate(function () {
    // 主逻辑放在这里
});

setImmediate(function () {
    console.log("[*] script loaded, rpc ready");
});

rpc.exports = {
    // 导出为 Python 的 script.exports.call_secret_function(...)
    callSecretFunction: function (arg) {
        var result = null;

        Java.perform(function () {
            var cls = Java.use("com.target.Crypto");
            result = cls.calcKey(arg);
        });

        return result;   // 返回值会自动序列化传给 Python
    },

    // 无参方法
    getVersion: function () {
        return Java.perform(function () {
            return Java.use("android.os.Build").VERSION.SDK.value.toString();
        });
    },

    // 返回对象（会被序列化成 JS 对象 → Python dict）
    dumpConfig: function () {
        var out = {};
        Java.perform(function () {
            var cls = Java.use("com.target.Config");
            out.key = cls.API_KEY.value;
            out.url = cls.BASE_URL.value;
        });
        return out;
    }
};

import frida
import sys

JS_CODE = open("hook.js", "r", encoding="utf-8").read()

def on_message(message, data):
    if message["type"] == "send":
        print("[Python] got:", message["payload"])
    else:
        print("[Python] error:", message)

# 连接设备
device = frida.get_usb_device()
pid = device.spawn(["com.target.app"])   # spawn 方式：先启动再 Hook
session = device.attach(pid)
script = session.create_script(JS_CODE)
script.on("message", on_message)
script.load()
device.resume(pid)                       # 恢复进程，让 App 跑起来

# 调用 RPC 导出的方法
result = script.exports.call_secret_function("input_data")
print("[Python] calcKey('input_data') =", result)

# 批量跑不同输入
for i in range(10):
    r = script.exports.call_secret_function(f"input_{i}")
    print(f"[Python] input_{i} -> {r}")

sys.stdin.read()

① 把常用 Hook 沉淀为可复用的 Frida 脚本库
② 用 Frida RPC + Python 驱动，把脚本变成可编程调用的函数
③ 串联成批量扫描 App 的流水线，接入 CI

scripts/
├── common/
│   ├── anti_debug.js        # 反反调试
│   ├── ssl_bypass.js        # SSL Pinning 绕过
│   └── trace.js             # 通用方法 trace
├── crypto/
│   ├── hook_aes.js          # AES 相关
│   └── hook_jni.js          # JNI 层加密函数
└── app/
    └── target_app.js        # 具体 App 的定制 Hook

def build_script(*modules):
    parts = []
    for m in modules:
        with open(f"scripts/{m}.js", "r", encoding="utf-8") as f:
            parts.append(f.read())
    return "\n".join(parts)

js = build_script("common/anti_debug", "common/ssl_bypass", "crypto/hook_jni")
script = session.create_script(js)

import frida
from concurrent.futures import ThreadPoolExecutor

def process_device(device):
    try:
        session = device.attach("com.target.app")
        script = session.create_script(JS_CODE)
        msgs = []
        script.on("message", lambda m, d: msgs.append(m))
        script.load()

        result = script.exports.call_secret_function("probe")
        return {"device": device.id, "result": result, "logs": len(msgs)}
    except Exception as e:
        return {"device": device.id, "error": str(e)}

devices = [d for d in frida.get_device_mgr().enumerate_devices()
           if d.type == "usb"]

with ThreadPoolExecutor(max_workers=4) as pool:
    results = list(pool.map(process_device, devices))

for r in results:
    print(r)

FCAnd.anti.anti_debug();               // 反反调试
FCAnd.traceArtMethods([...], {...});   // Java 方法 trace
FCAnd.jni.hookJNI('NewStringUTF', {}); // Hook JNI 函数

var fgets = Module.findExportByName(null, "fgets");

Interceptor.attach(fgets, {
    onEnter: function (args) {
        this.buf = args[0];
        this.size = args[1];
        this.stream = args[2];

        // 顺便记下调用者，方便定位反调试点
        this.caller = this.returnAddress;
    },
    onLeave: function (retval) {
        if (retval.isNull()) return;

        var content = retval.readCString();
        if (content === null) return;

        // 过滤掉暴露调试状态的特征
        if (content.indexOf("TracerPid") >= 0 ||
            content.indexOf("frida") >= 0 ||
            content.indexOf("gum-js-loop") >= 0 ||
            content.indexOf("TracerPid:\t0") < 0 && content.indexOf("TracerPid:\t") >= 0) {

            // 直接把 TracerPid 改成 0
            if (content.indexOf("TracerPid") >= 0) {
                var fake = content.replace(/TracerPid:\s*\d+/, "TracerPid:\t0");
                this.buf.writeUtf8String(fake);
            }
        }
    }
});

["exit", "_exit", "_Exit", "kill", "raise", "abort"].forEach(function (name) {
    var addr = Module.findExportByName(null, name);
    if (!addr) return;

    Interceptor.attach(addr, {
        onEnter: function (args) {
            console.log("[!] " + name + " called!");
            console.log("    arg0:", args[0]);

            // 打印调用栈，直接告诉你是谁触发了退出
            console.log("    backtrace:\n" +
                Thread.backtrace(this.context, Backtracer.ACCURATE)
                    .map(DebugSymbol.fromAddress).join("\n"));

            this.skip = true;
        },
        onLeave: function (retval) {
            // 想彻底阻止退出，在这里 replace 掉（但可能引起其他问题）
        }
    });
});

function bypassSSLPinning() {
    Java.perform(function () {
        // ---- 1. 系统 TrustManager ----
        try {
            var TrustManagerImpl = Java.use("com.android.org.conscrypt.TrustManagerImpl");
            TrustManagerImpl.checkTrustedRecursive.implementation = function () {
                console.log("[*] TrustManagerImpl.checkTrustedRecursive bypassed");
                return Java.use("java.util.ArrayList").$new();
            };
        } catch (e) { console.log("[-] TrustManagerImpl not found"); }

        // ---- 2. X509TrustManager（兜底，覆盖老版本和自定义实现） ----
        try {
            var X509TrustManager = Java.use("javax.net.ssl.X509TrustManager");
            var TrustManager = Java.registerClass({
                name: "org.frida.TrustAll",
                implements: [X509TrustManager],
                methods: {
                    checkClientTrusted: function (chain, authType) {},
                    checkServerTrusted: function (chain, authType) {},
                    getAcceptedIssuers: function () { return []; }
                }
            });

            // 替换 SSLContext 的初始化
            var SSLContext = Java.use("javax.net.ssl.SSLContext");
            SSLContext.init.overload(
                '[Ljavax.net.ssl.KeyManager;',
                '[Ljavax.net.ssl.TrustManager;',
                'java.security.SecureRandom'
            ).implementation = function (km, tm, sr) {
                console.log("[*] SSLContext.init bypassed");
                this.init(km, [TrustManager.$new()], sr);
            };
        } catch (e) { console.log("[-] X509TrustManager hook failed:", e); }

        // ---- 3. OkHttp 3.x CertificatePinner ----
        try {
            var CertificatePinner = Java.use("okhttp3.CertificatePinner");
            var check3 = CertificatePinner.check.overload(
                'java.lang.String', 'java.util.List'
            );
            check3.implementation = function () {
                console.log("[*] OkHttp3 CertificatePinner bypassed");
            };
        } catch (e) { console.log("[-] OkHttp3 not used"); }

        // ---- 4. 老版本 OkHttp 2.x（包名不同） ----
        try {
            var OldPinner = Java.use("com.squareup.okhttp.CertificatePinner");
            var check2 = OldPinner.check.overload(
                'java.lang.String', 'java.util.List'
            );
            check2.implementation = function () {
                console.log("[*] OkHttp2 CertificatePinner bypassed");
            };
        } catch (e) {}
    });
}

第 1 遍：Java 层基础——Java.perform / Java.use / implementation 改写
        └─ 能 Hook 一个普通 Java 方法，打印入参和返回值

第 2 遍：类枚举与内部类——enumerateClassLoaders / enumerateLoadedClasses
        └─ 能定位动态加载的 DEX 中的类

第 3 遍：SO 层基础——Module.findBaseAddress / findExportByName / Interceptor.attach
        └─ 能 Hook 一个导出函数，打印 args 和 retval

第 4 遍：JNI 深入——libart.so 枚举符号 / JNIEnv 指针偏移 / RegisterNatives
        └─ 能 Hook 动态注册的 JNI 函数

第 5 遍：RPC 与主动调用——setImmediate / rpc.exports / Python 驱动
        └─ 能把一个 Hook 脚本导出为 Python 可调用的接口

第 6 遍：对抗实战——反调试绕过 / SSL Pinning 绕过
        └─ 能在有检测的环境下稳定运行 Hook 脚本