1
2
3
4
5
6

; 调用 int add(int a, int b)  => add(1, 2)
PUSH  2              ; 第二个参数 (从右往左压栈)
PUSH  1              ; 第一个参数
CALL  add            ; 调用函数
ADD   ESP, 8         ; 调用者清理栈 (2 个参数 * 4 字节)
; 返回值在 EAX 中

1
2
3
4
5
6
7
8

; 调用 int __stdcall MessageBoxA(HWND, LPCSTR, LPCSTR, UINT)
PUSH  0              ; uType = MB_OK
PUSH  offset szTitle ; lpCaption
PUSH  offset szText  ; lpText
PUSH  0              ; hWnd = NULL
CALL  MessageBoxA    ; 调用函数
; 不需要 ADD ESP —— 被调用者已经清理了
; 函数内部以 RET 16 结尾

1
2
3
4
5

; 调用 int __fastcall func(int a, int b, int c)  => func(1, 2, 3)
PUSH  3              ; 第三个参数通过栈
MOV   EDX, 2         ; 第二个参数 -> EDX
MOV   ECX, 1         ; 第一个参数 -> ECX
CALL  func

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

; 调用 long func(long a, long b, long c, long d, long e, long f, long g)
; func(1, 2, 3, 4, 5, 6, 7)
PUSH  7              ; 第 7 个参数通过栈
MOV   R9, 6          ; 第 6 个参数
MOV   R8, 5          ; 第 5 个参数
MOV   RCX, 4         ; 第 4 个参数
MOV   RDX, 3         ; 第 3 个参数
MOV   RSI, 2         ; 第 2 个参数
MOV   RDI, 1         ; 第 1 个参数
CALL  func
ADD   RSP, 8         ; 调用者清理栈上的参数

1
2
3
4
5
6
7

; x86 可以直接对内存操作:
;   ADD [EBP-4], 10       ; 直接把内存中的值加 10

; ARM 必须三步走:
LDR  R0, [R11, #-4]      ; 1. 从内存加载到寄存器
ADD  R0, R0, #10          ; 2. 在寄存器中运算
STR  R0, [R11, #-4]      ; 3. 将结果存回内存

1
2
3
4
5
6

; === x86-64 (System V): 调用 func(1, 2, 3) ===
MOV   EDI, 1             ; 第 1 个参数 -> RDI
MOV   ESI, 2             ; 第 2 个参数 -> RSI
MOV   EDX, 3             ; 第 3 个参数 -> RDX
CALL  func               ; CALL 会把返回地址压栈
; 返回值在 RAX

1
2
3
4
5
6

; === AArch64 (AAPCS64): 调用 func(1, 2, 3) ===
MOV   W0, #1             ; 第 1 个参数 -> X0
MOV   W1, #2             ; 第 2 个参数 -> X1
MOV   W2, #3             ; 第 3 个参数 -> X2
BL    func               ; BL 把返回地址存入 LR (X30)
; 返回值在 X0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

; === x86 函数序言/结语 ===
; 序言 (Prologue)
PUSH  EBP                ; 保存旧的帧指针
MOV   EBP, ESP           ; 建立新的帧指针
SUB   ESP, 0x20          ; 分配 32 字节局部变量空间
PUSH  EBX                ; 保存被调用者保存寄存器

; 结语 (Epilogue)
POP   EBX                ; 恢复被调用者保存寄存器
LEAVE                    ; MOV ESP, EBP; POP EBP
RET                      ; 从栈弹出返回地址并跳转

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

; === AArch64 函数序言/结语 ===
; 序言 (Prologue)
STP   X29, X30, [SP, #-32]!  ; 保存 FP 和 LR，分配栈空间
MOV   X29, SP                ; 建立帧指针
STP   X19, X20, [SP, #16]    ; 保存被调用者保存寄存器

; 结语 (Epilogue)
LDP   X19, X20, [SP, #16]    ; 恢复被调用者保存寄存器
LDP   X29, X30, [SP], #32    ; 恢复 FP 和 LR
RET                           ; 返回 (跳转到 LR)

1
2
3
4
5

APK 中的 native 库选择顺序:
1. lib/x86_64/libfoo.so     (如果模拟器是 x86_64 且存在此目录)
2. lib/x86/libfoo.so        (如果模拟器是 x86 且存在此目录)
3. lib/arm64-v8a/libfoo.so  (通过 ARM 翻译层运行)
4. lib/armeabi-v7a/libfoo.so (通过 ARM 翻译层运行)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

; bool check_password(const char* input, int length)
; X0 = input (const char*), W1 = length (int)

check_password:
    STP   X29, X30, [SP, #-48]!   ; 保存 FP, LR
    MOV   X29, SP                  ; 建立栈帧
    STP   X19, X20, [SP, #16]     ; 保存 callee-saved 寄存器
    STR   X21, [SP, #32]          ; 保存 X21

    MOV   X19, X0                  ; X19 = input (保存参数)
    MOV   W20, W1                  ; W20 = length

    ; 第一步：检查长度
    CMP   W20, #8                  ; length == 8?
    B.NE  .fail                    ; 如果长度不是 8，直接失败

    ; 第二步：逐字符校验
    MOV   W21, #0                  ; W21 = i = 0 (循环计数器)
    ADRP  X8, .secret_key@PAGE
    ADD   X8, X8, .secret_key@PAGEOFF ; X8 = secret_key 数组地址

.loop:
    CMP   W21, W20                 ; i < length?
    B.GE  .success                 ; 如果 i >= length，循环结束，密码正确

    LDRB  W9, [X19, X21]          ; W9 = input[i]
    LDRB  W10, [X8, X21]          ; W10 = secret_key[i]
    EOR   W9, W9, #0x37           ; W9 = input[i] ^ 0x37
    CMP   W9, W10                  ; input[i] ^ 0x37 == secret_key[i]?
    B.NE  .fail                    ; 不相等则失败

    ADD   W21, W21, #1             ; i++
    B     .loop                    ; 继续循环

.success:
    MOV   W0, #1                   ; 返回 true
    B     .epilogue

.fail:
    MOV   W0, #0                   ; 返回 false

.epilogue:
    LDR   X21, [SP, #32]          ; 恢复 X21
    LDP   X19, X20, [SP, #16]     ; 恢复 X19, X20
    LDP   X29, X30, [SP], #48     ; 恢复 FP, LR
    RET

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 还原后的 C 代码
static const unsigned char secret_key[8] = { /* ... */ };

bool check_password(const char* input, int length) {
    // 长度必须为 8
    if (length != 8) {
        return false;
    }

    // 逐字符校验: input[i] ^ 0x37 == secret_key[i]
    for (int i = 0; i < length; i++) {
        if ((input[i] ^ 0x37) != secret_key[i]) {
            return false;
        }
    }

    return true;
}

1
2
3
4
5
6
7
8

var base = Module.findBaseAddress("libfoo.so");
var key = base.add(0x1234).readByteArray(8); // 替换为实际偏移
var keyBytes = new Uint8Array(key);
var password = "";
for (var i = 0; i < 8; i++) {
    password += String.fromCharCode(keyBytes[i] ^ 0x37);
}
console.log("password:", password);