[原创]ARM64 动态二进制插桩的原理与实现-Android安全-看雪安全社区

### 原理

动态二进制插桩（Dynamic Binary Instrumentation）简称 DBI，其根本原理可以简单概括为：

> 在每条汇编指令的前后插入额外的指令，实现控制程序的执行流与读取程序的数据流。

- 控制程序的执行流是为了**让程序能够按照原本的逻辑照常运行**。
- 读取程序的数据流是为了**监控程序**。

我们要想在一条指令的前后插入指令，首当其冲面临的问题便是：内存空间不足。因为，ELF 文件在被加载进内存时，已经按照编译时所确定的固定内存大小被加载到进程。几乎没有多余的空间供我们使用。因此，我们必须申请与管理一段新内存，让原本的代码段运行在我们新申请的内存中。所以在 DBI 中必须有一个**内存管理模块。**

我们在拥有了足够的内存之后，便能够写入指令了。而想要写入指令，我们必须能够先生成指令，因此我们也需要一个**汇编器模块。** 而在 DBI 中由于内存地址的改变，部分 ARM64 的指令已经不能简单的复制过去就能与原程序逻辑一样运行了。因为，ARM64 的部分指令是与 PC 相关的指令。比如：B.cond、ADRP、TBNZ……等指令，这些指令的寻址能力各不相同，我们将代码段复制到新开辟的内存空间运行后，运行的 PC 基址已经改变，此时如果寻址能力不足以跳转到目标地址的话，那么将引发错误。拿 B.EQ 指令来举例：

![](d8fK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6E0L8h3u0A6P5W2)9J5k6i4q4H3K9h3y4Q4x3X3g2U0L8W2)9J5c8X3#2E0j5X3W2*7i4K6g2X3M7r3&6Y4i4K6u0r3L8q4W2f1g2%4q4s2L8U0l9I4f1h3W2S2x3V1)9#2L8%4A6B7L8#2k6y4x3$3W2S2j5W2g2%4g2h3H3I4y4e0m8*7M7#2u0H3z5f1E0*7z5p5S2G2d9s2W2b7K9s2q4Y4K9$3E0r3N6p5R3%4y4X3g2V1K9h3u0F1d9e0N6F1c8f1A6n7x3W2j5&6M7f1W2g2K9X3k6i4b7V1I4m8d9h3k6B7e0U0m8T1f1$3#2g2k6Y4N6Q4x3V1j5$3y4o6m8Q4x3@1k6%4P5q4)9#2k6X3k6E0N6q4)9K6c8s2m8F1k6#2)9J5y4X3k6J5L8$3#2Q4x3@1c8S2M7s2m8E0M7$3N6Q4x3U0V1`.

插桩后的 B.EQ 指令将跳转不到 0x7100 地址执行，因为 B.EG 指令的寻址能力只有相对 PC 1MB 的范围，而 0x7000000 - 0x7100 = 0x6FF8F00，已经远远超过 B.EQ 指令的寻址范围了，因此将引发错误。那么这种指令我们该如何处理，让其能按照原有的逻辑运行呢？我们可以将其翻译为这样：

![](d99K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6E0L8h3u0A6P5W2)9J5k6i4q4H3K9h3y4Q4x3X3g2U0L8W2)9J5c8X3#2E0j5X3W2*7i4K6g2X3M7r3&6Y4i4K6u0r3L8q4W2f1g2%4q4s2L8U0l9I4f1h3A6H3x3o6g2x3c8r3I4j5g2s2m8K9N6s2g2I4N6$3W2T1h3f1W2t1M7p5@1$3h3q4q4%4P5r3u0g2g2@1&6@1M7Y4k6w2g2h3S2A6j5X3I4W2f1%4k6n7e0U0N6A6j5W2k6V1g2V1I4$3L8X3W2T1x3%4k6o6c8o6W2U0N6@1!0n7b7e0y4D9z5o6N6J5g2$3W2S2M7%4N6f1c8$3q4d9b7g2)9J5c8U0m8Q4x3@1k6%4P5q4)9#2k6X3k6E0N6q4)9K6c8s2m8F1k6#2)9J5y4X3k6J5L8$3#2Q4x3@1c8S2M7s2m8E0M7$3N6Q4x3U0V1`.

这样就能利用 B 指令的 128MB 寻址能力为我们跳转到指定的地址。所以，为了完成这样的指令转变，我们还需要一个**翻译器模块。**

我们观察转换后的指令可以发现，原来的一条指令膨胀成了两条指令。如此我们便引申出了 DBI 的一个重大弊端：**几何级的指令膨胀**。在实际的插桩过程中，我们为了完成对每条指令监控的同时保证程序按照原逻辑运行，需要在每条指令的前后插入保存与恢复寄存器状态指令。拿监控 MOV X0, #1 这条指令来举例，通常我们插桩后的指令视图是这样的：

```
STP X29, X30, [SP, #-CPU_CONTEXT_SIZE]!
ADD X29, SP, #CPU_CONTEXT_SIZE  
STP X0, X1, [SP, #(POINTER_SIZE * 2)]
STP X2, X3, [SP, #(POINTER_SIZE * 4)]
STP X4, X5, [SP, #(POINTER_SIZE * 6)]
STP X6, X7, [SP, #(POINTER_SIZE * 8)]
STP X8, X9, [SP, #(POINTER_SIZE * 10)]
STP X10, X11, [SP, #(POINTER_SIZE * 12)]
STP X12, X13, [SP, #(POINTER_SIZE * 14)]
STP X14, X15, [SP, #(POINTER_SIZE * 16)]
STP X16, X17, [SP, #(POINTER_SIZE * 18)]
STR X18, [SP, #(POINTER_SIZE * 20)]
MOV X0, SP
LDR X16, monitor 
BLR X16 // 调用监控程序
LDR X18, [SP, #(POINTER_SIZE * 20)]
LDP X16, X17, [SP, #(POINTER_SIZE * 18)]
LDP X14, X15, [SP, #(POINTER_SIZE * 16)]
LDP X12, X13, [SP, #(POINTER_SIZE * 14)]
LDP X10, X11, [SP, #(POINTER_SIZE * 12)]
LDP X8, X9, [SP, #(POINTER_SIZE * 10)]
LDP X6, X7, [SP, #(POINTER_SIZE * 8)]
LDP X4, X5, [SP, #(POINTER_SIZE * 6)]
LDP X2, X3, [SP, #(POINTER_SIZE * 4)]
LDP X0, X1, [SP, #(POINTER_SIZE * 2)]
LDP X29, X30, [SP], #CPU_CONTEXT_SIZE
MOV X0, #1 // 原指令
```

仅仅看这段指令明面上就由单条指令膨胀成了 27 条指令，而事实上 monitor 函数为了实现监控打印指令信息，可能还会有上百条的指令不止。因此，DBI 后的单条指令时间复杂度由原来的 O(1) 上升到了 O(n) 。我们将保存恢复寄存器状态的指令集记为 A，monitor 函数记为 B。

**N = A + B + 1**

假设：A = 26，B = 200。那么原来的单条指令就转变为了 267 条指令，这还是保守假设。

因为，通常我们会把指令信息输出到文件，那么这时 monitor 函数在运行时还会和内核交互，如此算来的时间复杂度就不可预估了。正是因为运行时间的大幅增加，检测 DBI 的方法之一便是记录开始与结束时间，如果时间相差过于悬殊，则就证明程序的运行环境异常。此时不管是风控上报异常还是自毁，都是合理的选择。当然，我们想要绕过检测也不难。不过，这不是本文的重点就不展开了。

现在我们知道想要实现 DBI 最重要的有三大模块：**内存管理、汇编器、翻译器**。那么我们只要实现这几个模块，就能实现一个完备的 DBI 了吗？并不是。在 ARM64 中有些指令的跳转地址是在运行时才确定的，比如：BLR, X8。这个 X8 可能是运行时动态计算的函数地址，而我们在运行到这条指令之前是不知道 X8 的值的。所以我们必须在运行时拿到 X8 的跳转地址，才能完成这类动态指令的插桩。但是接下来又引申了另外两个问题：我们怎么保证跳转过去的地址是被我们插过桩的呢？又为什么需要保证跳转地址是被我们插过桩的呢？因为，我们需要监控程序。如果运行没被插过桩的代码段，我们是无法调用 monitor 函数监控程序执行状态的。那我们怎么保证跳转的目标地址始终是被插过桩的呢？我们可以构建一个二级跳转路径，让所有的跳转指令首先跳转到我们的**路由函数**，将要跳转的目标地址作为参数传给路由函数，这样所有的跳转指令我们就都能拦截了。然后，我们可以在路由函数中判断目标地址是不是被插过桩，如果没有就先将目标地址的指令插桩一遍，再跳转。

![](18eK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6E0L8h3u0A6P5W2)9J5k6i4q4H3K9h3y4Q4x3X3g2U0L8W2)9J5c8X3#2E0j5X3W2*7i4K6g2X3M7r3&6Y4i4K6u0r3L8q4W2f1g2%4q4s2L8U0l9I4f1h3W2S2x3V1)9#2L8%4A6B7L8#2k6y4x3$3W2S2j5W2g2%4g2h3H3I4y4e0m8*7M7@1W2i4P5X3u0Y4b7g2m8o6c8r3g2d9M7V1q4G2e0W2f1I4k6r3W2T1c8h3g2k6z5r3&6i4L8o6W2a6k6p5!0o6M7p5I4B7j5X3A6j5k6h3R3%4z5r3W2T1e0K6k6H3M7W2c8K9j5U0g2w2K9h3q4y4f1g2)9J5c8U0j5@1x3q4)9K6c8Y4N6^5i4K6g2X3k6X3#2@1i4K6y4p5M7r3&6Y4i4K6t1$3k6Y4u0G2L8g2)9K6c8r3q4H3M7r3#2K6k6#2)9J5z5b7`.`.

而这也是为什么 DBI 需要以基本块为单位插桩的原因，因为前一基本块无法预测下一基本块的落点。所以，干脆设计个二级跳转路径，一旦遇上带有跳转语义的指令标记基本块结束，并把原跳转指令替换为跳转到路由函数的指令。再在路由函数中实现对下一基本块的插桩。

至此，我们就可以勾勒出一幅 DBI 的架构图：
![](bd8K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6E0L8h3u0A6P5W2)9J5k6i4q4H3K9h3y4Q4x3X3g2U0L8W2)9J5c8X3#2E0j5X3W2*7i4K6g2X3M7r3&6Y4i4K6u0r3L8q4W2f1g2%4q4s2L8U0l9I4f1h3W2S2x3V1)9#2L8%4A6B7L8#2k6y4x3$3W2S2j5W2g2%4g2h3H3I4y4e0m8*7M7#2u0a6y4r3g2#2c8e0V1H3L8X3S2A6j5h3R3J5x3W2t1@1K9h3q4D9N6g2y4x3c8o6p5J5g2V1E0D9N6s2q4b7N6r3E0K9z5g2W2#2K9h3u0H3d9h3!0E0c8r3c8G2M7r3E0X3P5X3W2T1e0g2k6z5b7@1q4Q4x3V1j5$3y4o6m8Q4x3@1k6%4P5q4)9#2k6X3k6E0N6q4)9K6c8s2m8F1k6#2)9J5y4X3k6J5L8$3#2Q4x3@1c8S2M7s2m8E0M7$3N6Q4x3U0V1`.

> 以基本块为单位插桩，基本块结束时翻译跳转指令首先跳转到路由函数。再在路由函数中使用内存管理、翻译器、汇编器三大模块对下一基本块实现插桩。

### 实现

我们以插桩一个快排算法为目标，实现一个简单的 DBI 框架。

```c
void quick_sort(int arr[], int left, int right) {
    if (left >= right) return;

int i = left, j = right;
    int pivot = arr[left];

while (i < j) {
 while (i < j && arr[j] >= pivot) j--;
 if (i < j) arr[i++] = arr[j];

while (i < j && arr[i] <= pivot) i++;
 if (i < j) arr[j--] = arr[i];
 }

arr[i] = pivot;
    quick_sort(arr, left, i - 1);
    quick_sort(arr, i + 1, right);
}
```

可以看到，这个函数里包含了条件判断、循环、递归函数调用等语句，是一个极佳的插桩学习样本。函数编译后的汇编为：

```assembly
0x7655fabd3c: stp x29, x30, [sp, #-0x30]!
0x7655fabd40: str x21, [sp, #0x10]
0x7655fabd44: stp x20, x19, [sp, #0x20]
0x7655fabd48: mov x29, sp
0x7655fabd4c: cmp w1, w2
0x7655fabd50: b.ge 0x7655fabe24
0x7655fabd54: mov w19, w2
0x7655fabd58: mov x20, x0
0x7655fabd5c: b 0x7655fabd84
0x7655fabd60: sxtw x9, w1
0x7655fabd64: mov w21, w1
0x7655fabd68: sub w2, w21, #1
0x7655fabd6c: mov x0, x20
0x7655fabd70: str w8, [x20, x9, lsl #2]
0x7655fabd74: bl 0x765620ec00
0x7655fabd78: add w1, w21, #1
0x7655fabd7c: cmp w1, w19
0x7655fabd80: b.ge 0x7655fabe24
0x7655fabd84: ldr w8, [x20, w1, sxtw #2]
0x7655fabd88: cmp w1, w19
0x7655fabd8c: b.ge 0x7655fabd60
0x7655fabd90: mov w21, w1
0x7655fabd94: mov w9, w19
0x7655fabd98: b 0x7655fabdb0
0x7655fabd9c: sub w10, w9, #1
0x7655fabda0: str w11, [x20, w9, sxtw #2]
0x7655fabda4: mov w9, w10
0x7655fabda8: cmp w21, w9
0x7655fabdac: b.ge 0x7655fabe18
0x7655fabdb0: cmp w21, w9
0x7655fabdb4: b.ge 0x7655fabdd8
0x7655fabdb8: sxtw x9, w9
0x7655fabdbc: sxtw x10, w21
0x7655fabdc0: ldr w11, [x20, x9, lsl #2]
0x7655fabdc4: cmp w11, w8
0x7655fabdc8: b.lt 0x7655fabde4
0x7655fabdcc: sub x9, x9, #1
0x7655fabdd0: cmp x9, x10
0x7655fabdd4: b.gt 0x7655fabdc0
0x7655fabdd8: cmp w21, w9
0x7655fabddc: b.ge 0x7655fabda8
0x7655fabde0: b 0x7655fabdf4
0x7655fabde4: add w21, w21, #1
0x7655fabde8: str w11, [x20, x10, lsl #2]
0x7655fabdec: cmp w21, w9
0x7655fabdf0: b.ge 0x7655fabda8
0x7655fabdf4: add x10, x20, w21, sxtw #2
0x7655fabdf8: ldr w11, [x10]
0x7655fabdfc: cmp w11, w8
0x7655fabe00: b.gt 0x7655fabd9c
0x7655fabe04: add w21, w21, #1
0x7655fabe08: add x10, x10, #4
0x7655fabe0c: cmp w9, w21
0x7655fabe10: b.ne 0x7655fabdf8
0x7655fabe14: mov w21, w9
0x7655fabe18: mov w9, w21
0x7655fabe1c: sxtw x9, w9
0x7655fabe20: b 0x7655fabd68
0x7655fabe24: ldp x20, x19, [sp, #0x20]
0x7655fabe28: ldr x21, [sp, #0x10]
0x7655fabe2c: ldp x29, x30, [sp], #0x30
0x7655fabe30: ret 
```

我们整理出所有带有跳转语义的指令，共有 4 类：

- b.cond
- b
- bl
- ret

事实上由于 BL 指令跳转的目标地址是一段间接跳转代码段，所以还会有如下一段指令：

```assembly
0x765620ec00: adrp x16, 0x76563b2000
0x765620ec04: ldr x17, [x16, #0x5d8]
0x765620ec08: add x16, x16, #0x5d8
0x765620ec0c: br x17 
```

会有这段指令原因是：我们在函数中调用了函数。而由于我们的函数在被加载到进程之前是不知道确切的函数地址的，所以编译器生成了一个间接跳转的代码段，等待运行时由 Linker 来重定位函数地址，从而完成跳转。并且我们可以看到，最后的跳转是由 BR 指令来完成的，而不是 BL 指令。那为什么要换一个指令呢？因为 BR 指令的寻址能力只有相对 PC 128MB 的距离，而 BR 使用寄存器跳转，拥有 64bit 全范围的寻址能力。如果调用的目标函数是一个三方库函数，BR 仍然能够寻址到，而 BL 则不一定。编译器为确保万无一失，所以换成 BR 指令来完成跳转。所以实际上我们还要加上 BR 这条跳转指令，加起来共有 5 类带有跳转语义的指令。另外，我们还有一条 ADRP 指令是与 PC 相关的指令。因此，我们一共有 6 条指令需要翻译。接下来，我们开始实现 DBI 框架。

#### 内存管理

```cpp
#define BLOCK_NUMBER 4096
#define BLOCK_SIZE 1024

struct BlockMeta {
    int index;
    void* code_start;
    int code_size;
    void* block_start; //插桩后的基本块起始地址
    int block_size;
    BlockMeta* slice_block_meta; // 当基本块过大时，拆成多个 BLOCK。
    uint32_t code[BLOCK_SIZE];
};

class Memory {
private:
    static Memory* instance;
    Memory() {
        size_t blocks_meta_size = ALIGN_PAGE_UP(sizeof(BlockMeta) * BLOCK_NUMBER);
        // 申请存放插桩代码的内存。使用预分配内存策略，提高效率。
        first_block_meta = (BlockMeta*)mmap(nullptr, blocks_meta_size, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
    }

public:
 // 使用无序 map 来索引插桩后的基本块
 std::unordered_map<uint64_t, int> cache_block_meta;
 int curr_block_index = 0;
 BlockMeta* first_block_meta;
 BlockMeta* block_meta_arr[BLOCK_NUMBER] = {nullptr};

// 获取或创建一个 block_meta
    static BlockMeta* get_or_new_block_meta(int index = 99999999);

// 创建一个 block_meta
    static BlockMeta* new_block_meta();

// 设置与获取已插桩的基本块，避免二次插桩同一基本块
    static bool set_cache_block_meta(uint64_t key, int value);
    static BlockMeta* get_cache_block_meta(uint64_t key);
};
```

#### 汇编器

```cpp
class Assembler {
public:
    // 回调用户函数之前保存寄存器
    static void prolog(uint32_t *&writer);

// 回调用户函数之后恢复寄存器
    static void epilog(uint32_t *&writer);

// 以下都为生成 ARM64 指令机器码的函数

static void movz(uint32_t &instr, ARM64_REGISTER reg, uint16_t immediate, uint8_t shift);

static void movk(uint32_t &instr, ARM64_REGISTER reg, uint16_t immediate, uint8_t shift);

static void str(uint32_t &instr, ARM64_REGISTER src_reg, ARM64_REGISTER dst_reg, int dst_offset);

static void blr(uint32_t &instr, ARM64_REGISTER reg);

static void ret(uint32_t &instr, ARM64_REGISTER  reg);

static void b(uint32_t &instr, uint64_t pc, uint64_t target);

static void mov_sp_to_x(uint32_t &instr, ARM64_REGISTER rd);

static void mov_x_to_x(uint32_t &instr, uint8_t dest_reg, uint8_t src_reg);

static void write_value_to_reg(uint32_t *&writer, ARM64_REGISTER reg, uint64_t value);

static void write_pc_to_cpu(uint32_t *&writer, uint64_t pc);

static void call_dbi_callback(uint32_t *&writer);

static void get_b_addr(uint64_t &addr, uint64_t pc, uint32_t machine_code);

static void get_bl_addr(uint64_t &addr, uint64_t pc, uint32_t machine_code);

static void get_adrp_addr(uint64_t &addr, uint64_t pc, uint32_t machine_code);

static ARM64_REGISTER get_adrp_reg(uint32_t machine_code);

static ARM64_REGISTER get_br_reg(uint32_t machine_code);

static bool b_is_cond(uint32_t machine_code);

static void modify_b_cond_addr(uint32_t &instr, uint32_t machine_code, uint64_t current_pc, uint64_t new_address);

static void br(uint32_t &instr, ARM64_REGISTER reg);

static void br_x16_jump(uint32_t *&writer, uint64_t target_addr);

static void blr_x16_jump(uint32_t *&writer, uint64_t target_addr);
};
```

#### 翻译器

```cpp
class Translator{
public:
    // 扫描与翻译原基本块
    static void scan(uint64_t target_addr, BlockMeta* block_meta, ROUTER_TYPE type);
    // 翻译非跳转与PC无关指令的函数
    static void default_ins_handle(uint32_t *&writer, uint64_t pc);
    // 回调用户函数
    static void callback(uint32_t *&writer, uint64_t pc);
    // 翻译 B 指令
    static void b_ins_handle(uint32_t *&writer, uint64_t pc);
    // 翻译 BL 指令
    static void bl_ins_handle(uint32_t *&writer, uint64_t pc);
    // 翻译 BR 指令
    static void br_ins_handle(uint32_t *&writer, uint64_t pc);
    // 翻译 B.COND 指令
    static void b_cond_ins_handle(uint32_t *&writer, uint64_t pc);
    // 翻译 ADRP 指令
    static void adrp_ins_handle(uint32_t *&writer, uint64_t pc);
    // 翻译 RET 指令
    static void ret_ins_handle(uint32_t *&writer, uint64_t pc);
};
```

所有带有跳转语义的指令都将先跳转到我们的路由函数，以避免跳转到没被插桩的基本块。比如一条 b.cond 指令，将被翻译为：

```assembly
push_register
mov x1 B_ROUTER_TYPE
b.cond pc + 2  // 条件命中
b pc + 3  // 未命中
mov x0 b_addr
mov x16 router
br x16
mov x0 b_next
mov x16 router
br x16
```

可以看到，不管跳转条件怎样都会先跳转到我们的路由函数，并且将跳转地址做为第一个参数传入 router。

#### 路由函数

```cpp
enum ROUTER_TYPE {
    ENDING_ROUTER_TYPE,
    B_ROUTER_TYPE,
    BL_ROUTER_TYPE,
    BR_ROUTER_TYPE,
    BLR_ROUTER_TYPE,
    RET_ROUTER_TYPE
};
      
router:
    BL _router
    BR X0
      
// 检查是否已插桩，如果已插桩直接索引到缓存的基本块返回。否则扫描后再返回
uint64_t _router(uint64_t jump_addr, ROUTER_TYPE type) {
    auto block_meta = Memory::get_cache_block_meta(jump_addr);
    if (block_meta == nullptr) {
        block_meta = Memory::get_or_new_block_meta();
        Translator::scan(jump_addr, block_meta, type);
    }

return (uint64_t )block_meta->block_start;
}

void Translator::scan(uint64_t target_addr, BlockMeta* block_meta, ROUTER_TYPE type) {
    auto dbi_code = (uint32_t *)block_meta->code;
    switch (type) {
        case ENDING_ROUTER_TYPE: {
            Router::save_ending_addr(dbi_code);
            break;
        }
        default: {
            Router::pop_register(dbi_code);
            break;
        }
    }
  
   // ......
}
```

可以看到，有一个 ROUTER_TYPE 参数，这个参数的作用是识别指令类型。以便在下一个基本块的开头恢复我们在跳转路由函数过程中所破坏的寄存器。

#### 运行实例

```cpp
void dbi_callback (const CPU_CONTEXT* cpu_context) {
    auto cs_insn = DBI::disassemble(cpu_context->pc);
    char reg_value_info[1024] = {};
    char *reg_value_info_ptr = reg_value_info;

for (int i = 0; i < cs_insn->detail->aarch64.op_count; i++) {
 auto op = cs_insn->detail->aarch64.operands[i];
 const char* reg_name;
 uint64_t reg_value;
 if (op.type == AARCH64_OP_REG || op.type == AARCH64_OP_MEM_REG) {
 reg_name = cs_reg_name(DBI::get_cs_handle(), op.reg);
 get_register_value(op.reg, cpu_context, reg_value);
 int len = snprintf(reg_value_info_ptr, sizeof(reg_value_info),
 "%s=0x%llx ", reg_name, reg_value);
 reg_value_info_ptr += len;
 }
 }
 LOGE("0x%llx: %s %s; %s", cpu_context->pc, cs_insn->mnemonic, cs_insn->op_str, reg_value_info);
}

extern "C" JNIEXPORT jstring JNICALL
Java_com_lidongyooo_arm64dbidemo_MainActivity_stringFromJNI(
        JNIEnv* env,
        jobject /* this */) {

auto quick_sort_addr = (uint64_t)quick_sort;

int arr[] = {9, 3, 5, 8, 10, 1, 2, 6, 4};
    int n = sizeof(arr) / sizeof(arr[0]);
    auto dbi_quick_sort = (quick_sort_sign)DBI::trace(quick_sort_addr, dbi_callback);
//    quick_sort(arr, 0, n - 1);
    dbi_quick_sort(arr, 0, n - 1);

for (int i = 0; i < n; i++) {
 LOGE("%d", arr[i]);
 }

std::string hello = "Hello from DBI";
    return env->NewStringUTF(hello.c_str());
}
```

![](91bK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6E0L8h3u0A6P5W2)9J5k6i4q4H3K9h3y4Q4x3X3g2U0L8W2)9J5c8X3#2E0j5X3W2*7i4K6g2X3M7r3&6Y4i4K6u0r3L8q4W2f1g2%4q4s2L8U0l9I4f1h3A6H3x3o6g2x3c8r3I4j5g2s2m8K9N6s2g2I4N6$3W2T1h3f1W2t1M7p5@1$3M7Y4u0p5K9V1S2r3j5K6k6&6e0f1I4u0j5X3R3@1K9h3p5^5h3g2N6Y4g2W2R3K6f1h3y4A6j5X3b7@1j5e0W2q4M7@1g2E0P5h3k6T1y4@1E0^5g2$3&6&6g2g2q4^5f1$3u0H3c8$3A6I4L8h3N6Q4x3V1j5H3i4K6y4r3N6%4S2Q4y4h3k6X3L8i4c8Q4x3@1c8H3L8X3N6Q4x3U0k6X3M7X3!0E0i4K6y4p5j5i4m8H3L8i4y4Y4i4K6t1&6

可以看到，最后完美的将数组从小到大排序了，并且输出了每一条指令的状态信息。至此，一个简易的 DBI 框架就完成了。

本文的实现源代码已上传到：930K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6D9K9h3c8G2L8X3N6&6L8$3!0G2i4K6u0r3b7g2u0y4y4U0c8p5b7V1W2Q4c8f1k6Q4b7V1y4Q4z5p5y4Q4c8e0k6Q4z5o6c8Q4z5f1k6Q4c8e0g2Q4z5o6g2Q4b7U0c8Q4c8e0S2Q4b7U0k6Q4b7e0y4Q4c8e0N6Q4z5f1q4Q4z5o6c8Q4c8e0k6Q4z5f1y4Q4z5p5u0Q4c8e0g2Q4z5p5k6Q4z5p5u0Q4c8e0g2Q4z5p5k6Q4b7f1k6Q4c8e0S2Q4z5o6N6Q4b7f1q4Q4c8e0S2Q4b7e0q4Q4z5p5y4Q4c8e0W2Q4z5e0S2Q4z5o6g2Q4c8e0S2Q4b7f1k6Q4b7V1u0Q4c8e0y4Q4z5o6m8Q4z5o6t1`.

建了个交流群，感兴趣的朋友可以加我，拉你入群。vx：lidongyooo

回复或点赞可查看完整内容

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。

#基础理论 #逆向分析 #程序开发 #源码框架

最新回复 (44) 1 2 ▶
@NoBody 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 5 回帖 41 粉丝 4 关注私信	@NoBody 2 楼楼主写的很好，我自己也耗费了很多的时间研究了一套工具，可以做到记录程序启动到结束几乎所有的函数调用流或者所有线程堆内存数据读写流（也就是可以进行非常高效的数据回溯或者算法追踪），但是效率只降低了50%（这其中最关键之一就是我用了十几条指令就完成了几乎所有函数调用记录或者所有线程堆数据读写记录，类似frida这样的插桩最少都需要上百条指令，是无法应付具有海量数据读写的程序的），我就是用静态二进制翻译制作了一个新的ios包，有兴趣可以加我tel(我留个联系方式管理员请不要责怪):nobody_ji 2025-12-9 19:14 0
xianhuimin 雪币： 9341 活跃值： (6228) 能力值： ( LV2，RANK：10 ) 在线值：发帖 5 回帖 231 粉丝 2 关注私信	xianhuimin 3 楼感谢分享 2025-12-10 01:34 0
mb_nkjfyhkg 雪币： 308 活跃值： (180) 能力值： ( LV2，RANK：10 ) 在线值：发帖 4 回帖 78 粉丝 10 关注私信	mb_nkjfyhkg 4 楼 mark 2025-12-10 02:41 0
黑屏雪币： 5508 活跃值： (5839) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 149 粉丝 2 关注私信	黑屏 5 楼 66 2025-12-10 08:05 0
Imxz 雪币： 110 活跃值： (9571) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 775 粉丝 9 关注私信	Imxz 6 楼 tql 2025-12-10 08:48 0
lidongyooo 雪币： 527 活跃值： (1640) 能力值： ( LV3，RANK：20 ) 在线值：发帖 5 回帖 35 粉丝 50 关注私信	lidongyooo 7 楼 @NoBody 楼主写的很好，我自己也耗费了很多的时间研究了一套工具，可以做到记录程序启动到结束几乎所有的函数调用流或者所有线程堆内存数据读写流（也就是可以进行非常高效的数据回溯或者算法追踪），但是效率只降低了50% ... 静态翻译是用 llvm 实现的吗 2025-12-10 09:09 0
KanXue_NG 雪币： 678 能力值： ( LV1，RANK：0 ) 在线值：发帖 7 回帖 100 粉丝 66 关注私信	KanXue_NG 8 楼学习学习 2025-12-10 09:32 0
LQ6H 雪币： 530 活跃值： (2627) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 80 粉丝 1 关注私信	LQ6H 9 楼 666 2025-12-10 09:58 0
mb_pesxllvn 雪币： 378 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 122 粉丝 2 关注私信	mb_pesxllvn 10 楼 66 2025-12-10 10:39 0
mb_szqldxer 雪币： 204 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 7 粉丝 0 关注私信	mb_szqldxer 11 楼看看 2025-12-10 10:48 0
红皮西瓜雪币： 824 活跃值： (490) 能力值： ( LV3，RANK：20 ) 在线值：发帖 5 回帖 40 粉丝 24 关注私信	红皮西瓜 12 楼 6666 2025-12-10 11:43 0
宛枫雪币： 236 活跃值： (485) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 56 粉丝 0 关注私信	宛枫 13 楼感谢分享最后于 2025-12-10 13:45 被宛枫编辑，原因： 2025-12-10 13:28 0
guijingwen 雪币： 7377 活跃值： (7605) 能力值： ( LV2，RANK：10 ) 在线值：发帖 13 回帖 312 粉丝 0 关注私信	guijingwen 14 楼 66 2025-12-10 13:49 0
半个大西瓜雪币： 1411 活跃值： (1422) 能力值： ( LV3，RANK：20 ) 在线值：发帖 5 回帖 51 粉丝 8 关注私信	半个大西瓜 15 楼学习 2025-12-10 19:56 0
拍拖雪币： 2790 活跃值： (7141) 能力值： ( LV6，RANK：90 ) 在线值：发帖 22 回帖 436 粉丝 15 关注私信	拍拖 2 16 楼感谢分享 2025-12-11 18:05 0
Yangser 雪币： 1954 活跃值： (4268) 能力值： ( LV4，RANK：50 ) 在线值：发帖 11 回帖 130 粉丝 220 关注私信	Yangser 17 楼已严肃学习 2025-12-11 23:43 0
Ms135 雪币： 9 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 89 粉丝 0 关注私信	Ms135 18 楼 666 2025-12-11 23:53 0
kingking888 雪币： 3235 活跃值： (6337) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 302 粉丝 6 关注私信	kingking888 19 楼 666 2025-12-12 23:37 0
wx_Roger 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 1 粉丝 0 关注私信	wx_Roger 20 楼 66666 2025-12-13 11:22 0
@NoBody 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 5 回帖 41 粉丝 4 关注私信	@NoBody 21 楼 lidongyooo 静态翻译是用 llvm 实现的吗不是同架构大部分指令不需要编译否则速度会比较慢 2025-12-14 15:58 0
尐进雪币： 5724 活跃值： (3847) 能力值： ( LV5，RANK：60 ) 在线值：发帖 10 回帖 187 粉丝 163 关注私信	尐进 22 楼 mark 2025-12-14 17:31 0
wx_故事与酒雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 55 粉丝 0 关注私信	wx_故事与酒 23 楼 6666666666666666666666666666666 2025-12-16 15:53 0
wx_宇克鴻雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 57 粉丝 0 关注私信	wx_宇克鴻 24 楼 mark 2025-12-18 12:28 0
mb_mihutdve 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 64 粉丝 0 关注私信	mb_mihutdve 25 楼 mark 2025-12-21 13:52 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复