// 整体替换
rpc.exports = {
    ping: function() { return "pong"; },
    add: function(a, b) { return a + b; },
    echo: function(obj) { return { received: obj, ts: Date.now() }; },

    // 读取当前 App 的 package name + label
    getAppName: function() {
        var ActivityThread = Java.use("android.app.ActivityThread");
        var app = ActivityThread.currentApplication();
        var ctx = app.getApplicationContext();
        var pm = ctx.getPackageManager();
        return {
            packageName: String(ctx.getPackageName()),
            label: String(pm.getApplicationLabel(ctx.getApplicationInfo())),
        };
    }
};

// 或者单独追加
rpc.export('version', function() { return "1.0.0"; });

// 基本 hook — 透传
hook(Module.findExportByName("libc.so", "open"), function(path, flags) {
    console.log("open:", Memory.readCString(ptr(path)), "flags=" + flags);
    return this.orig();
});

// 修改返回值（直接 return 覆盖）
hook(Module.findExportByName("libc.so", "getpid"), function() {
    this.orig();
    return 12345;              // 调用方拿到 12345
});

// 修改参数 — 通过 this.xN
hook(target, function(a, b) {
    this.x0 = ptr("0x1234");   // 改第一个参数
    this.x1 = 100;             // 改第二个参数
    return this.orig();         // 用修改后的参数调原函数
});

// 修改参数 — 通过 orig() 传参（按顺序覆盖 x0-xN）
hook(target, function() {
    return this.orig(ptr("0x1234"), 100);
});

// 不 return 也行 — this.x0 赋值会同步回 C 层
hook(Module.findExportByName("libc.so", "getuid"), function() {
    this.orig();
    this.x0 = 77777;          // 调用方拿到 77777
});

// 移除 hook
unhook(Module.findExportByName("libc.so", "open"));

// 直接调用 native 函数（最多 6 个参数，走 x0-x5）
var pid = callNative(Module.findExportByName("libc.so", "getpid"));

var open = new NativeFunction(
    Module.findExportByName("libc.so", "open"),
    "int",                            // 返回类型
    ["pointer", "int"]                // 参数类型
);
var fd = open(Memory.allocUtf8String("/tmp/foo"), 0);

var atan2 = new NativeFunction(
    Module.findExportByName("libm.so", "atan2"),
    "double",
    ["double", "double"]
);
atan2(1.0, 2.0);

// 双阶段 attach: onEnter 前置 + 自动调原函数 + onLeave 后置
var listener = Interceptor.attach(Module.findExportByName("libc.so", "open"), {
    onEnter(args) {
        // args[0..30] 是 NativePointer 代理，args[N] = value 会写回 xN
        this.path = args[0].readCString();
        this.t0 = Date.now();
    },
    onLeave(retval) {
        // retval 是 NativePointer，.replace(v) 改返回值
        console.log("open(" + this.path + ") = " + retval.toInt32()
                  + " took " + (Date.now() - this.t0) + "ms");
        if (retval.toInt32() < 0) retval.replace(0);
    }
});
listener.detach();

// 仅 onEnter — 改参数后让原函数自己跑（C 侧走 tail-jump 快路径，无栈帧残留）
Interceptor.attach(target, {
    onEnter(args) { args[1] = ptr(100); }
});

// Interceptor.replace — 完全替换（等价于 hook()，不跑原函数）
Interceptor.replace(Module.findExportByName("libc.so", "getpid"), function() {
    return 1234;
});

// 清理：单个 / 全部
listener.detach();
Interceptor.detachAll();
Interceptor.flush();           // no-op，兼容脚本

hook(target, callback, Hook.NORMAL)     // 0: mprotect 直写（默认）
hook(target, callback, Hook.WXSHADOW)   // 1: 内核 shadow 页，/proc/mem 不可见
hook(target, callback, Hook.RECOMP)     // 2: 代码页重编译，仅 4B patch
hook(target, callback, 1)               // 数字也行
hook(target, callback, true)            // true = WXSHADOW

Java.ready(function() {
    var Activity = Java.use("android.app.Activity");

    // hook 实例方法
    Activity.onResume.impl = function() {
        console.log("onResume:", this.$className);  // this = 实例 Proxy
        return this.$orig();                         // 调原方法
    };

    // hook 构造函数（参数走 arguments）
    var MyClass = Java.use("com.example.MyClass");
    MyClass.$init.impl = function(a, b) {
        console.log("new MyClass, arg0 =", a);
        return this.$orig(a, b);
    };

    // 修改参数传给原方法
    MyClass.test.impl = function(arg) {
        return this.$orig("patched_arg");
    };

    // 指定 overload（Java 类型名或 JNI 签名都行）
    MyClass.foo.overload("int", "java.lang.String").impl = function(i, s) {
        return this.$orig(i, s);
    };

    // 静态方法：this 没有实例 Proxy，但 $orig / $className / $static 可用
    Java.use("android.util.Log").i
        .overload("java.lang.String", "java.lang.String").impl = function(tag, msg) {
            console.log("[static]", this.$className, this.$static, tag, msg);
            return this.$orig(tag, msg);
        };

    // 直接返回值覆盖（不调 $orig）
    MyClass.getCount.impl = function() { return 42; };

    // 移除 hook
    Activity.onResume.impl = null;
});

var JString = Java.use("java.lang.String");
var s = JString.$new("hello");     // 创建对象
console.log(s.length());           // 调实例方法
console.log(s.$className);         // 类名

var Process = Java.use("android.os.Process");
console.log(Process.myPid());      // 调静态方法

// $new 重载（Frida 兼容 .overload(...)）
var bytes = [65, 66, 67];
var s2 = JString.$new.overload("[B")(bytes);   // String(byte[])
var s3 = JString.$new.overload("java.lang.String")("copy");  // String(String)

// 方法重载
var Arr = Java.use("java.util.Arrays");
Arr.toString.overload("[I")([1, 2, 3]);   // 锁定 int[] 版本
Arr.asList.overload("[Ljava.lang.Object;")([1, "mix", obj]);

// 静态字段
var Build = Java.use("android.os.Build");
console.log(Build.MODEL.value);          // 读: "Pixel 6"
Build.MODEL.value = "FakeModel";         // 写

// 实例字段（hook 回调中 / $new 创建的对象）
var Point = Java.use("android.graphics.Point");
var p = Point.$new(10, 20);
console.log(p.x.value, p.y.value);      // 读: 10, 20
p.x.value = 100;                         // 写: JVM 同步更新
console.log(p.toString());               // "Point(100, 20)"

// hook 中访问 this 字段
Activity.onResume.impl = function() {
    var name = this.mComponent.value;   // 读实例字段
    console.log("resuming:", name);
    return this.$orig();
};

var map = HashMap.$new();
map.size();        // 调用 size() 方法
map.size.value;    // 读取 size 字段

Java.choose("android.app.Activity", {
    onMatch: function(instance) {
        console.log(instance.$className, "=>", instance.toString());
        // return "stop";   // 提前终止
    },
    onComplete: function() { console.log("done"); },
    subtypes: true,         // 包含子类（rustFrida 扩展）
    maxCount: 1000          // 最多枚举数量，默认 16384；0 = 不限
});

// 第三参等价 subtypes（位置参数形式）
Java.choose("java.util.List", { onMatch: fn }, true);

var loaders = Java.classLoaders();             // → 数组: app + boot + system
Java.setClassLoader(loaders[0]);               // 切换 Java.use() 查找上下文
var MyCls = Java.findClassWithLoader(loaders[0], "com.example.MyClass");

Java.setStealth(0);  // Normal: mprotect 直写
Java.setStealth(1);  // WxShadow: shadow 页，CRC 校验不可见
Java.setStealth(2);  // Recomp: 代码页重编译
Java.getStealth();   // 查询当前模式 (0/1/2)

Java.deopt();                  // 清空 JIT 缓存（InvalidateAllMethods）
Java.deoptimizeBootImage();    // boot image AOT 降级为 interpreter (API >= 26)
Java.deoptimizeEverything();   // 全局强制解释执行
Java.deoptimizeMethod("com.example.Test", "foo", "(I)V");  // 单方法降级

void foo(byte[] b)
void foo(int[] i)
void foo(long[] l)

obj.foo.overload("[I")([1, 2, 3]);    // 强制 int[]（否则自动选 byte[]）
obj.foo.overload("[B")([1, 200, 3]);  // 强制 byte[]，200 按位截断为 -56

Jni.addr("RegisterNatives")       // → NativePointer
Jni.FindClass                     // 属性直接取地址
Jni.find("FindClass")             // → { name, index, address }
Jni.table                         // 整张 JNI 函数表
Jni.addr(envPtr, "FindClass")     // 指定 JNIEnv

Jni.env.ptr                         // 当前线程 JNIEnv*
Jni.env.getClassName(jclass)        // → "android.app.Activity"
Jni.env.getObjectClassName(jobject) // → 对象的类名
Jni.env.readJString(jstring)        // → JS string
Jni.env.getObjectClass(obj)         // → jclass
Jni.env.getSuperclass(clazz)        // → jclass (Object 返 null)
Jni.env.isSameObject(a, b)          // → boolean
Jni.env.isInstanceOf(obj, clazz)    // → boolean
Jni.env.exceptionCheck()            // → boolean
Jni.env.exceptionClear()
Jni.env.exceptionOccurred()         // → jthrowable | null

// 构造/引用 (Rust 直路, 不走 callNative → dladdr, hook context 内安全)
Jni.env.findClass("java/lang/String") // → jclass | null
Jni.env.newStringUtf("hello")         // → jstring | null
Jni.env.newLocalRef(obj)              // → jobject | null
Jni.env.deleteLocalRef(obj)           // → undefined

Jni.structs.JNINativeMethod.readArray(addr, count)  // → JNINativeMethodInfo[]
Jni.structs.jvalue.readArray(addr, typesOrSig)      // → any[]

hook(Jni.addr("RegisterNatives"), function(env, clazz, methods_ptr, count) {
    var cls = Jni.env.getClassName(clazz);
    var n = Number(count);
    console.log(cls + " (" + n + " methods)");

    var methods = Jni.structs.JNINativeMethod.readArray(ptr(methods_ptr), n);
    for (var i = 0; i < methods.length; i++) {
        var m = methods[i];
        var mod = Module.findByAddress(m.fnPtr);
        console.log("  " + m.name + " " + m.sig + " → " + mod.name + "+" + m.fnPtr.sub(mod.base));
    }
    return this.orig();
}, 1);

// Memory.* 风格
var pid = Memory.readU32(ptr("0x7f1234"));
Memory.writeU64(dst, 0xdeadbeefn);
var cls = Memory.readCString(ptr(this.x1));

// ptr.* 风格（推荐，支持链式）
var p = ptr("0x7f1234");
p.readU32();
p.writeU64(0xdeadbeefn);
p.add(8).readPointer().readCString();     // 解指针再读字符串
p.add(0x10).readByteArray(32);            // → ArrayBuffer

// 写入代码后刷 I-cache
var code = Memory.alloc(16);
code.writeU32(0xd65f03c0);                // ret
Memory.flushCodeCache(code, 16);

var addr = Module.findExportByName("libc.so", "getpid");

// 隐身短 patch: getpid() → 42, readByteArray 仍看原字节
addr.writeBytes(new Uint8Array([0x40,0x05,0x80,0xd2, 0xc0,0x03,0x5f,0xd6]), 1);

// 指令级替换: 原第一条指令被这 3 条顶替, 原第二条及以后保留
addr.writest(new Uint8Array([
    0x80,0x46,0x82,0x52,  // MOVZ W0, #0x1234
    0xa0,0x79,0xb5,0x72,  // MOVK W0, #0xABCD, LSL #16
    0xc0,0x03,0x5f,0xd6,  // RET
]));

// 写数据段: 先开写权限
Memory.protect(dataAddr, 8, "rwx");
dataAddr.writeU64(0xdeadbeefn);
Memory.protect(dataAddr, 8, "r--");

// 导出：defined + global/weak 符号
Module.enumerateExports("libc.so").slice(0, 3);
// [{type:"function", name:"__cxa_finalize", address:"0x7200f0e0a0"}, ...]

// 按内存权限过滤 (prot 里 '-' 是通配, "r-x" 会匹配 r-x 和 rwx)
Module.enumerateRanges("libc.so", "r-x");

// 外部引用符号 + PLT/GOT slot 地址
Module.enumerateImports("libart.so").filter(i => i.type === "function");

// 短名：走 linker 搜索路径
var m = Module.load("libz.so");
// { name: "libz.so", base: 0x7062dec000, size: 110592, path: "/vendor/lib64/libz.so" }

// 绝对路径
Module.load("/system/lib64/libsqlite.so");

// 自定义 flags（默认 RTLD_NOW = 2；RTLD_LAZY = 1）
Module.load("/data/local/tmp/mylib.so", 1);

// 错误处理
try {
    Module.load("/does/not/exist.so");
} catch (e) {
    console.log(e.message);
    // → "Module.load: dlopen('/does/not/exist.so') failed: library \"...\" not found"
}

// 加载后立刻查符号
var m = Module.load("libcustom.so");
var addr = Module.findExportByName(m.name, "my_func");

var p = ptr("0x7f12345678");   // hex string / number / BigInt / NativePointer
p.add(0x100).sub(0x10);        // 算术，返回新 NativePointer
p.toString();                  // → "0x7f12345678"
p.toInt();                     // → bigint (等价 toNumber)

// Frida 兼容读写（完整 API 见上面 Memory 章节）
p.readU32();                   // 等价 Memory.readU32(p)
p.writeU64(0xdeadbeefn);       // 自动 mprotect
p.readPointer().readCString(); // 链式解引用

var vm = qbdi.newVM();
qbdi.addInstrumentedModuleFromAddr(vm, target);
qbdi.allocateVirtualStack(vm, 0x100000);
qbdi.simulateCall(vm, 0, arg0, arg1);
qbdi.registerTraceCallbacks(vm, target);
qbdi.run(vm, target, 0);
var ret = qbdi.getGPR(vm, qbdi.REG_RETURN);
qbdi.unregisterTraceCallbacks(vm);
qbdi.destroyVM(vm);