Hook:C 语言的函数可以一层套一层地调用,可是函数返回时它怎么知道该回到哪里?它把答案写在了内存里——写在一块叫「堆栈」的地方。
Why:编译器必须解决「嵌套调用后如何正确返回」这个核心问题。递归调用时同一个函数会同时存在多份局部变量,因此不能放在固定地址,只能放在一块后进先出、随调用自动伸缩的内存里。C 语言编译器对堆栈的使用有一套规则,不同编译器规则有差异;而了解堆栈存在的目的和编译器使用堆栈的规则,是理解操作系统一些关键性代码的基础——后面讲中断、系统调用、进程切换,全都复用这套栈帧机制。
What:堆栈在函数调用中提供四项服务:① 函数调用框架——记录每个活跃函数的栈帧边界;② 传递参数——32 位 x86 通过压栈传参(讲义特别标注 x86-64 改为使用寄存器传递参数);③ 保存返回地址——函数执行完能回到调用点;④ 提供局部变量空间——函数内的局部变量就分配在自己的栈帧里。
How:把这四项对应到后面要学的具体指令:保存返回地址靠 call 压栈、ret 弹栈;传递参数靠调用前的 pushl 与被调函数的 8(%ebp)、0xc(%ebp) 读取;提供局部变量空间靠 subl $0x18, %esp 这类减法开辟、靠 -4(%ebp) 之类负偏移访问;而「调用框架」本身由 pushl %ebp + movl %esp,%ebp 建立、由 movl %ebp,%esp + popl %ebp 拆除。一句话串起来:栈帧就是「一块用 EBP 圈定边界的内存」,返回地址在它上面、参数在它上面更远处、局部变量在它下面。
易错:把「传递参数」当成堆栈的普适职责。讲义明确提示 x86-64 改用寄存器传参,堆栈传参只是 32 位 x86 的约定,做 64 位题目前先确认位宽。
必考
Hook:堆栈在内存里只是一段普通地址,没有任何「栈」的物理标记。是谁在维护这个抽象的栈?只有两个寄存器。
Why:栈的「后进先出」完全由 esp 的移动方向实现。既然 push 让地址变小,说明栈是从高地址向低地址生长的——所以「栈顶」在数值上反而是较小的地址。这个反直觉的约定是画栈题的第一道坎,也是缓冲区溢出利用中「往低地址写、覆盖高地址的返回地址」这一方向的来源。
What:两个堆栈寄存器:esp(堆栈指针)永远指向当前栈顶,随 push/pop 自动移动;ebp(基址指针)在函数内固定不动,用作记录当前函数调用的基址,是访问参数与局部变量的锚点。两个操作:push 栈顶地址减 4 字节、pop 栈顶地址加 4 字节(均指 32 位环境)。
| 项目 | esp | ebp |
|---|---|---|
| 全称 | stack pointer | base pointer |
| 指向 | 当前栈顶 | 当前函数栈帧基址 |
| 是否自动变 | push/pop 时自动变 | 函数内固定不变 |
| 典型用途 | 定位栈顶、分配局部空间 | 定位参数与局部变量 |
How:画图时把讲义的两个标注记牢:图上低地址在上、高地址在下,ebp 在中间、esp 在下方(更靠高地址一侧)——因为栈向低地址生长,esp 越往下移表示栈越「深」。实操验证:在 gdb 里执行 info registers esp ebp 看两值,再 stepi 单步一条 push,立刻看到 esp 减 4;执行 pop 看到 esp 加 4。用 x/8xw $esp 还能看到每格的 4 字节内容,与讲义堆栈图一一对应。
易错:把栈图画成「低地址在下」。x86 栈向低地址生长,push 之后新数据在更小的地址上,画图时务必标清哪端是低地址,否则栈帧里参数与局部变量的上下关系会全部颠倒。
必考
Hook:函数调用看起来是个高级概念,但 CPU 眼里它只是两条指令:一条把「回来的路」记在栈上,另一条照着这条路跳回去。
Why:CPU 只有一套 cs:eip,函数调用却是嵌套的——所以「回来的路」必须存在某个可嵌套的地方,而栈天然满足后进先出:最后调用的函数最先返回,正好对应栈顶。这也解释了为什么破坏栈上的返回地址就能劫持控制流。
What:cs:eip 的行为分三种情形:顺序执行时总指向地址连续的下一条指令;跳转/分支时其值根据程序需要被修改;call 时先把 eip 中下一条指令的地址 A 保存到栈顶,再把 eip 设为被调用函数代码的起始处;ret 时从栈顶弹出原来保存的值(即执行跳转/调用之前 eip 指向的指令),放入 cs:eip。
How:讲义给出的完整框架分三段:
建立 func() 的堆栈框架:pushl %ebp、movl %esp, %ebp;
拆除 func() 的堆栈框架:movl %ebp, %esp、popl %ebp、ret;
调用者:... call func() ...,func 函数体 do sth.。
注意 call 的两步语义:先保存「下一条指令地址 A」到栈顶(不是当前 eip,而是已经自增后的下一条),再把 eip 指向 func 入口。ret 做的事正好相反:把地址 A 恢复到 eip 中。所以 call 与 ret 是一对严格对称的操作,中间夹着的 pushl %ebp 与 popl %ebp 只是在保护调用者的基址。
易错:以为 call 保存的是「call 指令自身的地址」。保存的是 call 之后那条指令的地址,所以函数返回后不会重新执行 call,而是继续往下走。
必考
Hook:一次函数调用,内存里其实只发生了四次指针移动和一个入栈。把这五步背下来,任何画栈题都只是照着走一遍。
pushl %ebp 保存旧基址 --> movl %esp,%ebp 建立新基址 --> 执行函数体(堆栈相应变化)--> 退出时 movl %ebp,%esp、popl %ebp、ret。Why:为什么要先保存旧 ebp 再赋新值?因为 ebp 只有一个,被调用函数要用它定位自己的栈帧,就必须先把调用者的基址存起来,等自己退出时再恢复——否则返回后调用者就找不到自己的局部变量了。这就是「保存现场 / 恢复现场」的最小版本,进程切换、中断处理都是它的放大版。
What:按讲义 slides 6–14 的推进顺序:① 执行 call 前的堆栈布局;② 执行 call 时,cs:eip 原来的值指向 call 下一条指令,该值被保存到栈顶,然后 cs:eip 指向 func() 入口地址;③ 进入 func() 第一条指令 pushl %ebp——把调用者的 ebp 压栈;④ 第二条指令 movl %esp, %ebp——ebp 从此指向保存旧 ebp 的那一格;⑤ 执行函数体 do sth.,堆栈会相应变化(压参数、开局部空间);⑥ 退出时 movl %ebp,%esp 把 esp 重新指回 ebp 的位置(因为函数执行过程中 esp 已经变了),再 popl %ebp 恢复调用者基址,最后 ret 弹出返回地址。
| 步骤 | 指令 | esp 变化 | ebp 变化 |
|---|---|---|---|
| 调用 | call func | 减 4,写入返回地址 | 不变 |
| 建立① | pushl %ebp | 减 4,写入旧 ebp | 不变 |
| 建立② | movl %esp, %ebp | 不变 | = 新 esp |
| 函数体 | do sth. | 随指令变化 | 固定不变 |
| 拆除① | movl %ebp, %esp | = ebp | 不变 |
| 拆除② | popl %ebp | 加 4 | = 旧 ebp |
| 返回 | ret | 加 4 | 不变 |
How:拆解退出阶段三个动作的因果:函数体里可能反复 push/pop、可能 subl 开了局部空间,所以此刻 esp 的位置已经不能代表栈帧底部;movl %ebp,%esp 就是「把 esp 强行拉回 ebp」这一动作,一步丢弃所有局部变量空间;接着 popl %ebp 弹出的是当初 pushl 保存的旧 ebp,栈顶因此上移到返回地址;最后 ret 弹出返回地址写入 cs:eip,程序回到 call 的下一句。三步缺一不可:少第一步会漏掉局部空间,少第二步 ebp 会永久错位,少第三步就回不去。
易错:以为 movl %ebp,%esp 之后局部变量就「被清零」了。它只是移动指针,数据仍留在栈上——这正是后续课程里栈上残留信息泄露与格式化字符串读取栈内容的物理基础。
必考
Hook:怎么证明书上画的栈帧是真的?不看源码,看机器码——objdump 会把编译器偷偷做的事全打印出来。
Why:教材上的栈帧图是抽象的,而真实编译器会插入额外的对齐、优化和冗余指令。只有亲自反汇编一次,你才知道哪些指令是「必须的骨架」、哪些是编译器自由发挥。这也是后续逆向分析与漏洞定位的基本功——拿到一个未知二进制,第一件事就是 objdump 看函数序和函数尾声。
What:操作链:gcc -g test.c 获得 test.c 的可执行文件 --> objdump -S 获得 test 的反汇编文件(-S 让源码与汇编交错)。以 int p2(int x, int y){return x+y;} 为例,反汇编里能看到:建立堆栈 pushl %ebp + movl %esp,%ebp;函数体 movl 0xc(%ebp), %eax + addl 0x8(%ebp), %eax;拆除堆栈 movl %ebp,%esp + popl %ebp + ret。
How:对着反汇编读参数偏移:ebp 指向保存的旧 ebp,ebp+4 是返回地址,于是 第一个参数 x 在 0x8(%ebp)、第二个参数 y 在 0xc(%ebp)。注意 p2 里先取 0xc(%ebp) 再 addl 0x8(%ebp)——因为 addl 是「把源加到目的」,目的必须是 eax,所以先把 y 装进 eax,再把 x 加上去。这解释了为什么加法函数的反汇编看起来是「先取第二个参数」。函数尾声用 movl %ebp,%esp 而不是 leave,本质等价。图上还要标注:ebp 以上(高地址侧)是调用者的堆栈框架与参数,ebp 以下(低地址侧)是被调用函数的局部空间。
易错:把 0x8(%ebp) 读成「ebp 加 8 个元素」。偏移单位是字节,0x8 就是 8 字节,正好跳过 4 字节旧 ebp 与 4 字节返回地址,所以它才是第一个参数。
重点
Hook:一句 z = p2(x, y); 编译出来是五行汇编,其中一行的作用是「把栈擦干净」。谁擦的、为什么擦,直接关系到参数由谁负责回收。
Why:参数从右往左压,是为了让第一个参数落在最低地址、也就是离 ebp+8 最近的位置,这样被调用函数用固定偏移 0x8(%ebp)、0xc(%ebp) 就能顺序访问所有参数,不必知道实参个数。返回值走 eax 而不是栈,是因为栈上的返回值需要调用者预先分配空间并处理尺寸,寄存器最快且天然只有一个返回值。
What:z = p2(x, y); 的汇编:
pushl 0xfffffff8(%ebp) —— 压 y(即 -8(%ebp));
pushl 0xfffffff4(%ebp) —— 压 x(即 -4(%ebp));
call 804839b <p2> —— 调用;
add $0x8, %esp —— 调用者清理 8 字节参数;
movl %eax, 0xffffffc(%ebp) —— 把返回值存入 z。
局部变量存储:main 用 subl $0x18, %esp 一次开辟 24 字节,然后 char c = 'a' 写成 movb $0x61, 0xffffff3(%ebp),x = 1 写成 movl $0x1, 0xffffff4(%ebp),y = 2 写成 movl $0x2, 0xffffff8(%ebp)。
| 变量/动作 | 汇编表示 | 说明 |
|---|---|---|
| 局部空间 | subl $0x18, %esp | 一次开 24 字节 |
| c = 'a' | movb $0x61, -0xd(%ebp) | 1 字节,用 movb |
| x = 1 | movl $0x1, -0xc(%ebp) | 4 字节,用 movl |
| y = 2 | movl $0x2, -0x8(%ebp) | 4 字节,用 movl |
| z = 返回值 | movl %eax, -0x4(%ebp) | 返回值走 eax |
How:printf 调用进一步验证「从右往左压栈」:printf("%d = %d + %d\n", z, x, y) 编译为 pushl -8(%ebp)(y)、pushl -4(%ebp)(x)、pushl -0xc(%ebp)(z)、pushl $0x8048510(格式串地址)、call printf@plt。压栈顺序是 y --> x --> z --> 格式串,正好与参数列表从右往左一致,于是栈顶是格式串、第一个可变参数紧邻其后。这也解释了格式化字符串漏洞为什么能按顺序读栈:%d 一个个往上取,就是依次取到 z、x、y。
易错:以为被调用函数负责清理参数。32 位 cdecl 约定下是调用者在 call 之后执行 add $0x8, %esp 清理,因为只有调用者知道压了几个参数。另外注意 0xfffffff8(%ebp) 与 -0x8(%ebp) 是同一个地址的两种写法(补码)。
必考
Hook:代码段里 main、p1、p2 三个函数各占一块固定位置,而堆栈里会同时出现三份栈帧——同一个程序,两种「空间」。
Why:这个演练把前面所有零散知识合成一张图。理解了「代码段固定 + 堆栈随调用增长」,就能理解递归为什么会栈溢出、为什么深度嵌套调用会耗尽栈空间——因为栈帧是一层叠一层占内存的。
What:讲义练习题代码:void p1(char c){printf("%c\n", c);};int p2(int x,int y){char c='a'; p1(c); return x+y;};int main(void){int x,y,z; x=1; y=2; z=p2(x,y); printf("%d + %d = %d\n", x, y, z); return 0;}。图上要求补全 main、p1、p2 三层堆栈内容,并标出每层的 eip(返回地址)位置。
How:按调用顺序叠栈:① main 建立自己的栈帧,subl 开辟局部空间,x=1、y=2 落在负偏移处;② z = p2(x, y) 时先压 y 再压 x,call 压返回地址,p2 建立栈帧,此时栈上从低到高是:p2 的局部 c、p2 保存的旧 ebp、p2 的返回地址、参数 x、参数 y、main 的局部变量……③ p2 内 p1(c) 再压 c 与返回地址,p1 建立栈帧,于是栈顶是 p1 的帧;④ p1 返回,printf 输出字符,拆除 p1 栈帧;⑤ p2 执行 return x+y 把结果放 eax,拆除 p2 栈帧,返回地址把控制权交回 main;⑥ main 执行 add $0x8,%esp 清参数,把 eax 存入 z,再调 printf。画图要点:三层栈帧的 ebp 各自指向本层的「保存旧 ebp」格,每层的返回地址都在本层 ebp+4,参数在 ebp+8 及以上;p1 的帧在最上方(地址最小),main 的帧在最下方(地址最大)。
易错:把三层栈帧画成并列的三块,或把 p1 的栈帧画在 main 之下。栈是向下生长的,后调用的 p1 帧地址最小,必须画在最上面(低地址端)。
重点
Hook:想验证「寄存器到底怎么被用」,最直接的办法是把汇编直接写进 C 代码里——让编译器别管这一段,你说了算。
Why:操作系统内核里有大量必须精确控制寄存器和指令的代码(开关中断、切换页表、读写特殊寄存器),C 语言无法表达,只能内嵌汇编。掌握这套语法,才能读懂后续课程里的内核源码片段。同时它也是实验手段:写一段内嵌汇编,就能亲手验证 eax、ecx、edx 的取值。
What:讲义示例把 val1 + val2 存入 val3:
asm volatile(
"movl $0,%%eax\n\t" —— 把 eax 清零;
"addl %1,%%eax\n\t" —— eax += val1;
"addl %2,%%eax\n\t" —— eax += val2;
"movl %%eax,%0\n\t" —— val3 = eax;
: "=m" (val3) —— 输出部分,"=m" 表示只写内存变量;
: "c" (val1), "d" (val2) —— 输入部分,c/d 表示使用 %ecx/%edx;
);
| 符号 | 含义 |
|---|---|
| %%eax | 真实寄存器 eax(双 % 转义) |
| %0 / %1 / %2 | 操作数占位符,按输出、输入顺序编号 |
| "=m" | 只写(output)内存变量 |
| "c" / "d" | 约束使用 ecx / edx 寄存器 |
| volatile | 禁止编译器优化掉这段汇编 |
How:编译与观察:gcc -S -o assembly_in_C.s assembly_in_C.c 生成汇编文件,打开就能看到内嵌的几条指令被原样插入。若在 64 位机器上要编出 32 位代码,讲义给出两步:先 sudo apt-get install gcc-multilib 安装多架构支持,再 gcc -S -o assembly_in_C.s assembly_in_C.c -m32。注意第 2 讲这里用的是 gcc-multilib,而第 1 讲 32 位链接缺库时用的是 libc6-dev-i386——前者提供 -m32 所需的头文件与库集合,后者补 32 位 libc 开发包,两者场景不同别混。验证结果:val1=1、val2=2,eax 依次变 0、1、3,最终 val3=3。
易错:在指令串里只写一个 %,如"movl $0,%eax"。单 % 会被当成操作数占位符解析,寄存器必须写%%eax;另外输出约束写成 "=m" 表示内存,若写成 "=r" 则让编译器挑寄存器,语义不同。
重点
call func 之后、进入 func 执行 pushl %ebp 之前,栈顶存放的是什么?请说明它由谁写入、又由谁在什么时候取走。z = p2(x, y),反汇编为 pushl -8(%ebp)、pushl -4(%ebp)、call p2、add $0x8,%esp、movl %eax,-0x4(%ebp)。请解释为什么先压 -8(%ebp) 而不是 -4(%ebp),以及 add $0x8,%esp 的作用与执行者。共 15 题
答案已下载为 JSON 文件(通常在下载文件夹)。将以下命令发送给 Claude Code EPA skill,AI 会自动批改并生成报告:
将 <路径> 替换为刚下载的 JSON 文件的完整路径。