跳到主要内容

汇编基础

汇编基础​

在讨论逆向、脱壳、漏洞利用之前,我们先把最底下的东西搭清楚:CPU 到底在读什么,寄存器里放着什么,一条 call 指令背后发生了什么。这一节以 x86-64 为主线,顺带对比一下 ARM64,把逆向工程师日常打交道最多的那一小块指令集讲透。

从 C 到汇编​

先看一个最简单的例子。下面这段 C 代码:

int add(int a, int b) {
return a + b;
}

int main() {
return add(3, 4);
}

用 gcc -O0 -S -masm=intel add.c 编出来的 x86-64 汇编,核心几行大致是这样:

add:
push rbp
mov rbp, rsp
mov DWORD PTR [rbp-4], edi
mov DWORD PTR [rbp-8], esi
mov edx, DWORD PTR [rbp-4]
mov eax, DWORD PTR [rbp-8]
add eax, edx
pop rbp
ret

main:
push rbp
mov rbp, rsp
mov esi, 4
mov edi, 3
call add
pop rbp
ret

只看这十几行,我们就能读出好几件事:参数怎么传,栈帧怎么建,返回值放哪儿,函数怎么调用又怎么返回。这一节接下来就是把这些"到底怎么回事"讲清楚。

寄存器​

x86-64 有 16 个通用寄存器,每个 64 位。旧名字继承自 32 位时代,rax 是 64 位,eax 是它的低 32 位,ax 是低 16 位,al/ah 是低 16 位里的低/高 8 位。写 32 位子寄存器时,高 32 位会被自动清零——这个"隐式清零"的行为经常在逆向时救命,看到 mov eax, ... 就知道 rax 高位也没了。

16 个通用寄存器里,有几个在约定俗成的用法上有特殊角色:

寄存器常见用途
rax返回值、部分指令的隐式操作数
rbxcallee-saved,被调用方要保留
rcx,rdx,rsi,rdi,r8,r9System V ABI 下前六个整型参数
rsp栈顶指针
rbp栈帧基址,-O0 下常见,-O2 会被优化掉
r10-r15剩下的通用寄存器,r12-r15 是 callee-saved

除此之外还有 rip(指令指针,永远指向下一条要执行的指令)、rflags(标志寄存器,存 ZF/SF/CF/OF 之类的比较结果)、以及一堆做浮点和 SIMD 用的 xmm0-xmm15。

ARM64 的通用寄存器数量翻倍,有 31 个 x0-x30,加上专门的 sp。参数从 x0 开始传,x30 是链接寄存器(相当于 x86 里被 call 隐式压栈的返回地址),这也是为什么 ARM 下你会看到 bl 后紧跟着 stp x29, x30, [sp, #-16]! 这种保存返回地址的模式。

常见指令​

真正需要认熟的指令并不多。我们按功能分几组。

数据移动。mov dst, src 是最常见的一条,把源搬到目的。lea dst, [expr] 长得像 mov,但它不读内存,而是把方括号里的地址表达式算出来放进 dst——这是逆向里非常爱用的一个技巧,lea rax, [rdi + rsi*2 + 5] 一条指令就干了乘法加法。看到 lea 千万别以为是访存。

算术和逻辑。add、sub、imul、idiv、and、or、xor、shl、shr、sar。有几个惯用法要记住:xor eax, eax 是编译器写"清零"最喜欢用的形式,比 mov eax, 0 编码更短;test rax, rax 后接条件跳转,是判断寄存器是否为零的标准写法,比 cmp rax, 0 少一个立即数编码。

比较和跳转。cmp a, b 内部做的是 a - b 但不写回,只更新 rflags。紧跟其后的条件跳转看 flags 决定去哪儿:je(等于)、jne(不等于)、jl/jg(有符号小于/大于)、jb/ja(无符号小于/大于)。区分有符号无符号这一点非常重要——CTF 里常见的一类漏洞,就是签名比较后再强转成无符号做数组索引,负数被解释成大正数,越界访问。

栈和调用。push 把值压栈,pop 弹出,call target 相当于 "把返回地址 push 上去,然后 jmp",ret 相当于 "pop 一个地址到 rip"。因此栈溢出改返回地址这种攻击手法,本质上就是让 ret 从被污染的栈上读出攻击者控制的地址。

调用约定​

调用约定规定了参数怎么传、返回值怎么给、谁负责恢复寄存器。同一个 CPU 架构可以有好几套约定,写逆向的时候一定要先搞清目标程序用的是哪一套。

Linux/macOS 下的 x86-64 用的是 System V AMD64 ABI。前六个整型参数走 rdi、rsi、rdx、rcx、r8、r9,再多的溢出到栈上;浮点参数走 xmm0-xmm7;返回值放 rax(小整数)或 rax:rdx(128 位)。rbx、rbp、r12-r15 是被调用方要保存的寄存器,调用者可以放心用剩下的。

Windows x64 完全不一样。整型参数只用四个寄存器:rcx、rdx、r8、r9,而且不管你用不用,栈上都要给这四个参数留出 32 字节的"影子空间"(shadow space),这样被调用方要 spill 参数时就有地方放。

看到反汇编时怎么快速判断?看函数入口对 rdi/rsi 的使用是 Linux,看对 rcx/rdx 的使用是 Windows。这条经验在逆向不知道系统平台的样本时格外有用。

ARM64 更整齐:参数从 x0-x7,返回值 x0,x19-x28 是 callee-saved。没有影子空间,没有那么多历史包袱。

栈帧和函数调用​

一个典型的 x86-64 函数,-O0 编出来的开头结尾是这样:

push    rbp             ; 保存调用者的 rbp
mov rbp, rsp ; 建立新的栈帧基址
sub rsp, 32 ; 给局部变量分配 32 字节
... ; 函数体
mov rsp, rbp ; 释放局部变量空间(或 leave)
pop rbp ; 恢复调用者的 rbp
ret ; 返回

栈从高地址往低地址增长。进入函数瞬间,栈上的样子是这样:

高地址
...调用方的栈...
参数 7(如果有)
参数 8(如果有)
返回地址 <-- rsp 刚 call 完指向这里
旧的 rbp <-- push rbp 之后
局部变量 <-- sub rsp 之后
...
低地址

看栈溢出的时候,这张图要在脑子里常驻:攻击者往局部变量数组写超长数据,顺着栈往高地址覆盖,先覆盖旧的 rbp,再覆盖返回地址,ret 时程序就跳到了攻击者选的地方。金丝雀(stack canary)保护就是在旧的 rbp 前面插一个随机值,函数返回前检查这个值有没有被改。

-O2 优化之后,如果函数用不到 rbp,编译器会把它当普通寄存器用,栈帧序言变成只有 sub rsp, N。这是逆向时判断优化级别的一个明显信号。

寻址方式​

x86 的内存操作数可以写得很花,通用形式是:

[base + index * scale + displacement]

其中 base 和 index 是寄存器,scale 是 1/2/4/8,displacement 是常数偏移。举几个例子:

  • [rax]:间接寻址,读 rax 指向的内存
  • [rbp - 8]:栈上的局部变量
  • [rdi + rsi*4]:数组访问,32 位元素
  • [rip + 0x2000]:相对当前指令的偏移,PIC 代码里非常常见

最后一种叫 RIP-relative addressing,是 x86-64 相对 x86-32 的一个重要变化。地址无关代码(PIE/PIC)几乎全靠它——引用全局变量时不再需要重定位,直接 "相对当前指令偏移多少" 就能算出来。逆向时看到 mov rax, QWORD PTR [rip + 0x2020],这就是在读一个全局变量。

从这里往哪走​

到这里,我们已经能读懂大部分函数的入口、参数传递、返回、简单的循环和条件分支了。剩下的功夫在两个方向:一是熟悉编译器的常见输出模式——switch 语句会被编成跳转表,循环会被展开,虚函数调用会变成两次间接跳转,这些看多了就有了 pattern-match 的直觉;二是知道 SIMD、加密、内联汇编在反汇编里长什么样,遇到时能认出来跳过去,而不是陷进去逐条读。

[[可执行文件格式]] 那一节我们会往上走一层,看这些汇编指令是怎么被打包进 ELF/PE 文件、又是怎么被加载起来的。有了这两层,才能开始真正的静态分析。