Hook:一门讲内核与系统安全的课,为什么要先把「分数怎么算」摊在桌面上?因为这门课的分数结构,直接决定了你后面八周该把时间花在实验室还是自习室。
Why:主讲陈志文老师把联系方式(qq 869321990、zhiwenchen@xtu.edu.cn、信息科技大楼 525)与考核细则放在同一组开篇页,是为了让「遇到问题找谁」和「做到什么程度算合格」这两件事在第一分钟就明确,避免学期末才发现实验分占比高达三成。
What:教材为《庖丁解牛Linux内核分析》(孟宁等著);2.5 学分 / 40 学时,其中理论 32 学时、实验 8 学时;课程属性为专业主干课 / 必修;先修课程是高级语言程序设计、操作系统;授课对象为 2023 级网络空间安全。实验成绩的构成是:4 次实验报告平均成绩×30% + 实验结果成绩×50% + 现场检查成绩×20%。实验时间暂定第 8–11 周周三 5–6 节。
How:把公式代进具体数字就能看出权重分布:假设考试 80、实验 90、平时 100,则期评 = 80×0.6 + 90×0.3 + 100×0.1 = 48 + 27 + 10 = 85 分。实验只占 30%,但实验成绩内部又有 50% 来自「实验结果」,也就是程序真的跑出了预期现象——这正好对应本课程所有实验的共同套路:写代码、编译、看汇编、画栈。
易错:公式里「平时成绩×10」后面没有百分号,实际是 10 分制权重(即 10%)。另外实验必须独立完成,抄袭、不遵守实验室安全规章制度、请他人(含 AI)代做、未提交实验报告,实验成绩直接判 0 分。
了解
Hook:计算机凭什么能「自动」算题?它并不知道自己在算什么,它只是在不停地重复一件极笨的事——取下一条指令、执行它。
Why:如果指令和数据分开存放(哈佛结构),机器就只能执行出厂时写死的程序;把指令也当成数据放进同一片内存,程序才能被加载、被修改、被替换——这就是「存储程序」的意义,也是所有现代通用计算机能跑任意软件的前提。理解了这一条,后面所有「改 EIP 就能改变程序走向」的攻击思路才有根。
What:存储程序计算机(The stored program computer)指把程序(指令序列)与数据一同存入可读写存储器的计算机。本讲的知识地图分五块:The stored program computer(冯诺依曼体系结构)→ X86 implementation(X86 实现)→ Registers and Memory(寄存器与内存)→ Stack memory + operations(堆栈内存与操作)→ From C to running program(从 C 代码到可运行程序),最后是作业。
How:把 CPU 的工作循环拆成可观察的三步:① 按 CS:EIP 从内存取一条指令;② 译码并执行(可能读写内存里的数据);③ EIP 自增,指向下一条指令,回到 ①。关键在于指令和数据住在同一片内存里,CPU 完全靠「当前正在取指令」这个上下文来区分二者——同一串字节,被 EIP 指到就是指令,被 MOV 读到就是数据。这也解释了为什么缓冲区溢出能执行任意代码:攻击者把字节写进数据区,再让 EIP 指过去。
易错:把「CPU 解释指令」理解成「CPU 理解程序语义」。CPU 只做取指—执行,不懂函数、不懂变量,函数调用只是 CALL/RET 指令加一段约定好的栈布局。
必考
Hook:你写的 C 函数能调用别人编译好的库函数,双方从没见过面,凭什么参数就能对上号?靠的是一份「二进制层面的握手协议」。
Why:源码层面的接口叫 API,编译成机器码之后,函数名、类型信息基本都消失了,只剩寄存器里的值和栈上的字节。若没有 ABI 统一「第一个参数放哪、返回值放哪、谁负责清理栈」,两个由不同编译器、不同语言生成的模块就无法链接到一起。所以 ABI 是二进制世界的「交通规则」。
What:ABI 的三个规定:① Instructions encoding(指令编码)——每条汇编指令对应一段确定的机器码字节;② Registers convention in Instructions(寄存器使用约定)——指明什么指令用什么寄存器,例如累加用 EAX、栈顶用 ESP;③ Most instructions can take a Memory address——大部分指令可直接访问内存,有些指令可直接操作内存。
How:以一条 movl $8, (%esp) 为例拆开看 ABI 的三层:操作码 movl 决定指令编码;%esp 的使用遵循寄存器约定(栈顶指针);(%esp) 这种带括号的写法就是「指令直接取内存地址」。记住这个顺序:先有编码规则让 CPU 认识这条指令,再有寄存器约定让指令找到操作数,最后有内存寻址让操作数可以不在寄存器里。后面画栈时每一步 push/pop 之所以能推算,全靠第二、三条。
易错:ABI 不等于 API,也不等于「汇编语法」。AT&T 与 Intel 语法只是书写风格差异,ABI 约束的是二进制层面的调用约定与寄存器职责。
必考
Hook:一个程序的执行顺序,其实只由一个寄存器里的数字决定。谁改了这个数字,谁就控制了程序——这正是栈溢出攻击的靶心。
Why:如果指令等长,EIP 每次加同一个常数就够了;但 X86 是变长指令集,同一条 mov 可能 2 字节也可能 6 字节,所以「下一条在哪」必须由 CPU 译码后才知道。而 CALL/RET/JMP 之所以特殊,是因为它们不按顺序走——它们直接往 EIP 里写新值,这就是「控制流」的物理实现。
What:X86 实现的三个特征:① EIP is incremented after each instruction——顺序执行靠自增;② Instructions are different length——指令变长,自增的幅度由当前指令长度决定;③ EIP modified by CALL, RET, JMP, and conditional JMP——这四类指令能改写 EIP。
How:用一个最小例子跑一遍:执行 call g 时,CPU 先把「下一条指令的地址」压栈(这就是返回地址),再把 g 的入口地址写入 EIP;g 执行到 ret 时,从栈顶弹出刚才那个返回地址写回 EIP,于是回到 call 的下一句。注意这里的因果链:返回地址存在栈上 --> 栈上的数据可以被溢出覆盖 --> EIP 被改成攻击者指定的值。第 1 讲讲机制,后面的漏洞利用课讲后果。
易错:条件跳转并不是「条件成立才改 EIP」,而是根据 EFLAGS 里的标志位决定是否把目标地址写入 EIP;不成立时 EIP 照常自增。
必考
Hook:CPU 里就那么十几个小格子,却能装下整个程序的运行状态。它们各自的分工,是被约定死的还是天生的?
Why:寄存器是 CPU 的工作台(work space),比内存快得多。但工作台面积有限,于是设计上做了两件事:一是让同一物理寄存器可按 8/16/32 位不同宽度访问(兼容老代码、节省空间),二是用约定给部分寄存器分配专门职责(如 ESP 永远指向栈顶),这样指令编码可以更短、编译器可以更简单。
What:32 位通用寄存器及其约定功能:EAX 累加器、EBX 基地址寄存器、ECX 计数寄存器、EDX 数据寄存器、EBP 堆栈基指针、ESI 变址寄存器、EDI、ESP 堆栈顶指针;低 16 位分别是 AX/BX/CX/DX/BP/SI/DI/SP,AX 再拆成高字节 AH 与低字节 AL。段寄存器:CS(Code Segment,代码段段值)、DS(Data Segment,数据段段值)、ES(Extra Segment,附加数据段段值)、SS(Stack Segment,堆栈段段值)。CPU 取指令时根据 CS:EIP 确定指令的具体位置。EFLAGS 寄存器保存标志位。
| 寄存器 | 约定功能 | 常见用途 |
|---|---|---|
| EAX | 累加器 | 算术运算、函数返回值 |
| EBX | 基地址寄存器 | 存放基址 |
| ECX | 计数寄存器 | 循环计数 |
| EDX | 数据寄存器 | 乘除法高位、I/O |
| EBP | 堆栈基指针 | 标记当前栈帧底部 |
| ESP | 堆栈顶指针 | 永远指向栈顶 |
How:记住「名字嵌套」这条线:EAX 的低 16 位是 AX,AX 的高 8 位是 AH、低 8 位是 AL;EBX/BX/BH/BL、ECX/CX/CH/CL、EDX/DX/DH/DL 同理。EBP、ESI、EDI、ESP 只有 32 位与低 16 位(BP/SI/DI/SP),没有高 8 位拆分。画栈时用 EBP 当锚点:EBP 指向栈帧底部,参数在 EBP+8 处(EBP+0 存旧的 EBP、EBP+4 存返回地址),局部变量在 EBP 下方——这就是 1.8 节里 8(%ebp) 取第一个参数的由来。
易错:把 ESP 和 EBP 搞混。ESP 随 push/pop 自动移动,永远指向栈顶;EBP 一旦用 movl %esp, %ebp 设定后在整个函数内固定不动,作为访问参数和局部变量的基准。
必考
Hook:同一条 mov 指令,搬 1 个字节还是 8 个字节,CPU 怎么知道?答案就藏在指令名后缀那个小写字母里。
mov dst, src(目的在前,源在后)。Why:寄存器只有几十个,程序的数据主要放在内存里,所以必须有一套「按需搬运」的指令。而内存是按字节编址的,搬运时必须明确宽度——否则 mov $8, (%esp) 到底写 1 字节还是 4 字节就无从确定。后缀就是给 CPU 的宽度说明书,同时也决定了 ESP 该移动多少。
What:三种典型内存指令:MOV 在寄存器与内存之间搬运数据;PUSH 把数据压入栈(同时减小 ESP);POP 从栈顶弹出数据(同时增大 ESP)。尺寸后缀对应关系:b = 8 位(1 字节)、w = 16 位(2 字节)、l = 32 位(4 字节)、q = 64 位(8 字节)。
| 后缀 | 位宽 | 字节数 | 示例 |
|---|---|---|---|
| b | 8 位 | 1 | movb |
| w | 16 位 | 2 | movw |
| l | 32 位 | 4 | movl |
| q | 64 位 | 8 | movq |
How:把后缀和栈指针的位移直接挂钩:32 位环境下 pushl $8 让 ESP 减 4 并写入 4 字节;popl %esp 让 ESP 加 4。如果误写成 pushb,ESP 只减 1,整个栈帧的地址推算全部错位。实操检验方法:在 gdb 里用 stepi 单步执行,每步 info registers esp ebp 看指针变化,用 x/4xw $esp 看栈上字节——指针动了多少,就是后缀对应的字节数。
易错:AT&T 语法的操作数顺序是「源在前、目的在后」写成movl %eax, (%esp)时含义是「把 eax 写到 esp 指向的内存」;而讲义中mov dst, src的写法是 Intel 风格。做题前先确认语法风格,否则整条指令方向读反。
高频
Hook:给你四行汇编,让你画出内存里那几格数字——这是本课程最经典的送分题,也是最容易翻车的题。翻车点只有一个:栈到底往哪个方向长。
movl %esp, %ebp 之后 EBP 固定为栈帧基准,用 (%esp)、4(%esp) 等偏移访问栈上数据。Why:函数调用需要保存返回地址、参数、局部变量,而且必须支持嵌套与递归——后调用的先返回,正好是「后进先出」。用一块向低地址生长的连续内存 + 一个 ESP 指针,就能零成本实现这个结构:分配就是减 ESP,释放就是加 ESP,不需要任何额外管理。
What:讲义给出的三组练习代码,正是三种典型栈帧形态:
① pushl $8 / movl %esp,%ebp / subl $4,%esp / movl $8,(%esp)——先压参数,建立 EBP,再分配 4 字节局部空间并写入 8;
② pushl $8 / movl %esp,%ebp / pushl $8——建立 EBP 后再压一个 8;
③ pushl $8 / movl %esp,%ebp / pushl %esp / pushl $8 / addl $4,%esp / popl %esp——把 ESP 自身的值当数据压栈,再加 4 撤销一格,最后 pop 回 ESP。
How:以讲义给出的地址 0X1000(EBP)、0X0FFC、0X0FF8 为坐标,按「栈向下长」逐步推:设初始 ESP = 0X1000。执行 pushl $8:ESP = 0X0FFC,内存 [0X0FFC] = 8;执行 movl %esp,%ebp:EBP = 0X0FFC,指向刚才那个 8;执行 subl $4,%esp:ESP = 0X0FF8,只是挪指针,该格内容未定义;执行 movl $8,(%esp):内存 [0X0FF8] = 8。此时栈上有两个 8:0X0FFC 是参数、0X0FF8 是局部变量,EBP 在两者之间当分界线。第二组把 subl+movl 换成 pushl $8,效果相同但一步到位:ESP 减 4 并写入 8,最终 ESP = 0X0FF8、[0X0FF8] = 8。
第三组最考细节,逐步走:初始 ESP = 0X1000 → pushl $8:ESP = 0X0FFC,[0X0FFC] = 8 → movl %esp,%ebp:EBP = 0X0FFC → pushl %esp:先把 ESP 的当前值 0X0FFC 压栈,ESP = 0X0FF8,[0X0FF8] = 0X0FFC → pushl $8:ESP = 0X0FF4,[0X0FF4] = 8 → addl $4,%esp:ESP = 0X0FF8(跳过最上面那个 8,指针上移一格,数据仍留在内存里)→ popl %esp:先读 [0X0FF8] = 0X0FFC 写入 ESP,再 ESP 加 4,最终 ESP = 0X0FFC + 4 = 0X1000,回到初始位置。
| 指令 | ESP 变化 | 内存结果(设初值 ESP=0X1000) |
|---|---|---|
| pushl $8 | 0X1000 → 0X0FFC | [0X0FFC] = 8 |
| movl %esp, %ebp | 不变 | EBP = 0X0FFC |
| subl $4, %esp | 0X0FFC → 0X0FF8 | 该格内容未定义 |
| movl $8, (%esp) | 不变 | [0X0FF8] = 8 |
易错:① 以为栈向上长,于是把 0X0FFC 写成 0X1004;② 以为addl $4,%esp会清空内存——它只移动指针,数据还在;③ 以为popl %esp只是简单加 4——它是先读栈顶内容再赋给 ESP,等于 ESP 先变成栈里存的值、然后再加 4。
必考
Hook:三行 C 代码,函数互相调用,编译器把它变成了三段几乎一模一样的骨架。看懂这个骨架,你就能反推出任何 C 函数的栈帧。
pushl %ebp + movl %esp,%ebp(+ 可选 subl $N,%esp 分配局部空间),尾声是 leave + ret;参数通过 8(%ebp) 取,返回值放 EAX。Why:C 的函数调用约定必须让「调用者」和「被调用者」各干一份活且不重叠:调用者负责把参数放到栈上、调用完清理;被调用者负责保存旧 EBP、建立自己的栈帧、把返回值放 EAX。理解了这份分工,你看到 leave 就知道它在恢复 ESP 和 EBP,看到 ret 就知道它在弹出返回地址改 EIP——正好接回 1.4 节的 EIP 机制。
What:讲义示例代码:int g(int x){return x+3;} int f(int x){return g(x);} int main(void){return f(8)+1;}。对应的三段汇编骨架:
g:pushl %ebp / movl %esp,%ebp / movl 8(%ebp),%eax / addl $3,%eax / popl %ebp / ret——取参数、加 3、返回,无需局部空间;
f:pushl %ebp / movl %esp,%ebp / subl $4,%esp / movl 8(%ebp),%eax / movl %eax,(%esp) / call g / leave / ret——先分配 4 字节,把参数写到栈顶作为 g 的实参,再调用;
main:pushl %ebp / movl %esp,%ebp / subl $4,%esp / movl $8,(%esp) / call f / addl $1,%eax / leave / ret——传 8 给 f,返回值加 1。
How:按执行顺序走一遍数据流:main 把 8 写到 (%esp) 作为 f 的实参 --> call f 压入返回地址并跳到 f --> f 建立栈帧后从 8(%ebp) 读到 8(因为 EBP+4 是返回地址、EBP+8 才是第一个参数)--> f 把 8 写到自己的 (%esp) 作为 g 的实参 --> call g --> g 从 8(%ebp) 读到 8,加 3 得 11 放 EAX --> ret 回到 f,EAX 一路带回 main --> main 执行 addl $1,%eax 得 12。所以 main 的返回值是 12。注意 f 里没有 addl $4,%esp 清理参数,而是用 leave 一次性把 ESP 恢复到 EBP 位置再 pop 旧 EBP——这是 GCC 常见的省事写法。
易错:把8(%ebp)当成「第二个参数」。EBP 指向的是保存下来的旧 EBP,EBP+0 是旧 EBP、EBP+4 是返回地址、EBP+8 才是第一个参数;leave等价于movl %ebp,%esp再popl %ebp,不是两条独立无关的指令。
必考
Hook:作业要求你生成 .cpp、.s、.o 和 ELF 可执行文件四个中间产物——为什么非要四步?因为每一步都揭示了「程序如何变成机器能跑的东西」的一层。
Why:C 源码和机器码之间隔了三层抽象:预处理去掉宏与 #include、编译把 C 语法翻成汇编、汇编把助记符翻成机器码字节、链接把多个 .o 和库拼成一个可加载的 ELF。分层的好处是每一层都可以单独停下来观察——而本课程要你观察的正是 .s 那一层,因为只有汇编能直接对应 CPU 的寄存器与栈操作。
What:讲义列出的 GCC 用法:
预处理:gcc -E -o *.cpp *.c(生成预处理后的 C++ 源);
编译成汇编:gcc -S -o *.s *.c;对已预处理的文件用 gcc -x cpp-output -S -o *.s *.cpp;
汇编成目标文件:gcc -c *.c -o *.o,或 gcc -x assembler -c *.s -o *.o,也可直接用 as -o *.o *.s;
链接:gcc -o * *.o,一步到位也可 gcc -o * *.c。
How:作业流程照做即可:① 用示例 C 代码,注意把 f(学号) 里的参数换成自己的学号以区别;② 依次生成 .cpp、.s、.o 和 ELF 可执行文件;③ 加载运行,记录输出;④ 对照 .s 逐条说明该汇编在 CPU 上如何执行(取指、寄存器变化、栈变化)。64 位环境下的三个注意点:编译 32 位汇编写 gcc -S -o ccode32.s ccode.c -m32;若链接时报缺少 32 位运行库,执行 sudo apt-get install libc6-dev-i386;最终生成 32 位可执行文件写 gcc -o ccode32 ccode.c -m32。为什么本课程坚持 32 位?因为 32 位下参数全部走栈(8(%ebp) 就能取到),画栈直观;64 位下前六个参数改走寄存器,栈帧会变得不好看。
易错:只写-m32编译却不装 libc6-dev-i386,链接阶段会报找不到 32 位 crt 或库文件;另外-S只到汇编就停,不会生成 .o,别指望一步得到可执行文件。
重点
pushl $8 / movl %esp,%ebp / subl $4,%esp / movl $8,(%esp),设初始 ESP = 0X1000,请写出执行完后 EBP、ESP 的值以及 0X0FFC、0X0FF8 两格的内容。pushl $8:ESP 由 0X1000 减 4 得 0X0FFC,内存 [0X0FFC] = 8;movl %esp,%ebp:EBP = 0X0FFC,指向刚压入的 8;subl $4,%esp:ESP = 0X0FF8,只移动指针,该格内容未定义;movl $8,(%esp):内存 [0X0FF8] = 8。最终 EBP = 0X0FFC、ESP = 0X0FF8,[0X0FFC] = 8、[0X0FF8] = 8。EBP 正好夹在参数与局部变量之间,作为栈帧基准。8(%ebp) 就能取到参数 x?call 先把返回地址压栈,被调用函数再 pushl %ebp 保存旧基址并把 ESP 赋给 EBP,于是 EBP+0 是旧 EBP、EBP+4 是返回地址、EBP+8 才是调用者压入的第一个参数。这也说明为什么函数尾声要用 leave(等价于 movl %ebp,%esp 再 popl %ebp)恢复现场,再 ret 弹出返回地址写入 EIP。共 17 题
答案已下载为 JSON 文件(通常在下载文件夹)。将以下命令发送给 Claude Code EPA skill,AI 会自动批改并生成报告:
将 <路径> 替换为刚下载的 JSON 文件的完整路径。