JNI / NDK / 交叉编译：从 .so 生产流程到 Hook 动态注册

armv7a-linux-androideabi-*   → 32 位 ARM（armeabi-v7a）
aarch64-linux-android-*      → 64 位 ARM（arm64-v8a）
i686-linux-android-*         → 32 位 x86
x86_64-linux-android-*       → 64 位 x86

JNIEnv*  ──▶  ┌──────────────────┐
              │  JNINativeInterface*  │  （函数表基址）
              └──────────────────┘
                        │
                        ▼
              ┌──────────────────────────┐
   index 0    │  reserved0               │
   index 4    │  GetVersion              │
   ...        │  ...                     │
   index 215  │  RegisterNatives         │  ← 我们关心的
   index 216  │  UnregisterNatives       │
   index 219  │  GetJavaVM               │
              └──────────────────────────┘

JNIEXPORT jstring JNICALL
Java_com_example_MainActivity_stringFromJNI(JNIEnv *env, jobject thiz) {
    return env->NewStringUTF("Hello from C++");
}

(ILjava/lang/String;)V
 │└──────────────┘│└┬┘
 │   参数2: String│  └── 返回值: void
 └── 参数1: int

Java_包名_类名_方法名

// Java: com.example.MainActivity.stringFromJNI()
JNIEXPORT jstring JNICALL
Java_com_example_MainActivity_stringFromJNI(JNIEnv *env, jobject thiz) {
    ...
}

static jstring stringFromJNI(JNIEnv *env, jobject thiz) {
    return env->NewStringUTF("Hello from C++");
}

static const JNINativeMethod methods[] = {
    {"stringFromJNI", "()Ljava/lang/String;", (void *)stringFromJNI},
};

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env = nullptr;
    vm->GetEnv((void **)&env, JNI_VERSION_1_6);

    jclass clazz = env->FindClass("com/example/MainActivity");
    env->RegisterNatives(clazz, methods, sizeof(methods) / sizeof(methods[0]));

    return JNI_VERSION_1_6;
}

static jobject g_callback = nullptr;

JNIEXPORT void JNICALL
Java_com_example_Native_setCallback(JNIEnv *env, jclass clazz, jobject cb) {
    if (g_callback != nullptr) {
        env->DeleteGlobalRef(g_callback);   // 先释放旧的
    }
    g_callback = env->NewGlobalRef(cb);     // 建全局引用
}

JavaVM *g_vm = nullptr;   // 在 JNI_OnLoad 里保存下来

void *thread_func(void *arg) {
    JNIEnv *env = nullptr;
    // 附加当前线程到 JVM
    g_vm->AttachCurrentThread(&env, nullptr);

    // 现在可以调 JNI 函数了
    jclass clazz = env->FindClass("com/example/MainActivity");
    ...

    // 线程退出前必须 detach，否则 ART 会报错
    g_vm->DetachCurrentThread();
    return nullptr;
}

Java 侧：
  System.loadLibrary("native-lib")
       │
       ▼
  JVM 加载 libnative-lib.so
       │
       ▼
  存在 JNI_OnLoad？ → 调用它（动态注册在这里发生）
       │
       ▼
  Java 调用 native 方法 stringFromJNI()
       │
       ▼
  JVM 查找对应的 C 函数
       ├─ 静态注册：按 Java_... 命名查找符号表
       └─ 动态注册：从 RegisterNatives 注册的表中查找
       │
       ▼
  C 函数执行，通过 JNIEnv 回调 Java 或返回结果

C/C++ 源码 + jni.h
       │
       ▼
NDK 交叉编译工具链（aarch64-linux-android-clang）
       │
       ▼
libnative-lib.so（ARM64 机器码）
       │
       ▼
打包进 APK 的 lib/arm64-v8a/ 目录
       │
       ▼
运行时由 System.loadLibrary 加载

typedef struct {
    const char *name;       // Java 方法名（C 字符串）
    const char *signature;  // 方法签名（C 字符串）
    void       *fnPtr;      // Native 函数指针
} JNINativeMethod;

methods + i * S           →  name 指针
methods + i * S + ptrSize →  signature 指针
methods + i * S + ptrSize*2 → fnPtr

jint RegisterNatives(JNIEnv *env, jclass clazz,
                     const JNINativeMethod *methods, jint nMethods);

// 这样几乎总是返回 null
Module.findExportByName("libart.so", "RegisterNatives");

_ZN3art3JNI15RegisterNativesEP7_JNIEnvP7_jclassPK15JNINativeMethodi

Java.perform(function () {
    var env = Java.vm.getEnv();              // 当前线程的 JNIEnv*
    var table = env.handle.readPointer();    // 解引用一次 → 函数表基址
    var fn = table.add(215 * Process.pointerSize).readPointer();
    // fn 就是 RegisterNatives 的真实地址
});

env.handle          →  JNIEnv*（值的本身）
  .readPointer()    →  *env = JNINativeInterface*（函数表基址）
  .add(215 * 8)     →  第 215 个槽位的地址
  .readPointer()    →  该槽位里的函数指针

// hook_register_natives.js
Java.perform(function () {
    var env = Java.vm.getEnv();
    var table = env.handle.readPointer();
    var REGISTER_NATIVES_IDX = 215;

    var fn = table.add(REGISTER_NATIVES_IDX * Process.pointerSize).readPointer();
    if (fn.isNull()) {
        console.log("[-] 定位失败，请检查 JNIEnv 解引用");
        return;
    }

    var stride = Process.pointerSize * 3;   // JNINativeMethod 大小

    Interceptor.attach(fn, {
        onEnter: function (args) {
            var clazz = args[1];
            var methods = args[2];
            var count = args[3].toInt32();

            // 类名是加分项，拿不到不影响主要信息
            var className = "(unknown)";
            try {
                var ClassCls = Java.use("java.lang.Class");
                className = Java.cast(clazz, ClassCls).getName();
            } catch (e) {
                // Java.cast 在部分场景会失败，忽略即可
            }

            console.log("\n[RegisterNatives] class: " + className
                + "  methods: " + count);

            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();

                // 反查这个 native 函数属于哪个模块
                var mod = Process.findModuleByAddress(fnPtr);
                var where = mod
                    ? mod.name + "+0x" + fnPtr.sub(mod.base).toString(16)
                    : "?";

                console.log("  [" + i + "] " + name + sig
                    + "\n        fnPtr = " + fnPtr + "  (" + where + ")");
            }
        }
    });

    console.log("[*] RegisterNatives hooked at " + fn);
});

# spawn 模式：从进程启动就注入，确保赶在 JNI_OnLoad 之前
frida -U -f com.example.app -l hook_register_natives.js

[RegisterNatives] class: com.example.game.NativeBridge  methods: 2
  [0] init(Ljava/lang/String;)V
        fnPtr = 0x7a3e4c00  (libnative-lib.so+0x1c00)
  [1] getSign(Ljava/lang/String;J)Ljava/lang/String;
        fnPtr = 0x7a3e5100  (libnative-lib.so+0x2100)

Interceptor.attach(fnPtr, {
    onEnter: function (args) {
        // 普通 JNI 函数（非 static）：
        //   args[0] = JNIEnv*
        //   args[1] = jobject（Java 的 this）
        //   args[2] = 第 1 个 Java 参数
        console.log("[>] getSign called");
        console.log("    JNIEnv :", args[0]);
        console.log("    this   :", args[1]);

        // 第 1 个参数是 String（jstring），要转字符串得走 JNI
        try {
            var s = Java.cast(args[2], Java.use("java.lang.String"));
            console.log("    arg0   :", s);
        } catch (e) {
            console.log("    arg0   :", args[2]);
        }
    },
    onLeave: function (retval) {
        console.log("    retval :", retval);
        try {
            var r = Java.cast(retval, Java.use("java.lang.String"));
            console.log("    retval(str) :", r);
        } catch (e) {}
    }
});

第 1 遍：分开三个概念
        └─ 能用自己的话说出 JNI / NDK / 交叉编译各自解决什么问题

第 2 遍：JNI 的最小闭环
        └─ 写一个 Java native 方法 + 静态注册的 C 函数，
           跑通 System.loadLibrary → 调用

第 3 遍：类型与签名
        └─ 能手写 (ILjava/lang/String;)V 这样的签名，解释每个字符的含义

第 4 遍：动态注册
        └─ 在 JNI_OnLoad 中用 RegisterNatives 注册一个方法，
           观察不再需要 Java_ 命名

第 5 遍：引用与线程
        └─ 理解局部引用为什么不能跨调用保存；
           写一个 AttachCurrentThread 的 Native 线程

第 6 遍：构建视角
        └─ 用 ndk-build 或 CMake 交叉编译一个 .so，
           用 file / readelf -h 确认目标架构

第 7 遍：Hook 视角
        └─ 用 Frida Hook 静态注册函数，
           再 Hook RegisterNatives 捕获动态注册函数，
           把 fnPtr 反查到模块偏移后回 IDA 定位

# 确认目标架构（是 arm64 还是 arm）
file libnative-lib.so

# 看 ELF 头：Machine 字段能看出 ARM aarch64
readelf -h libnative-lib.so | grep Machine

# 找静态注册的 JNI 函数（Java_ 开头）
readelf -sW libnative-lib.so | grep "Java_"

# 找 JNI_OnLoad（说明可能用了动态注册）
readelf -sW libnative-lib.so | grep "JNI_OnLoad"

# 列出依赖库
readelf -d libnative-lib.so | grep NEEDED