ExamPass Assistant
github.com/WUBING2023/ExamPass-Assistant

第1讲

第1讲 How the Computer Works 计算机如何工作

1.1 课程信息与考核办法页1页2页3

Hook:一门讲内核与系统安全的课,为什么要先把「分数怎么算」摊在桌面上?因为这门课的分数结构,直接决定了你后面八周该把时间花在实验室还是自习室。

课程分两大块——Linux 内核分析 + Linux 系统安全,各占约 50%;期评成绩 = 考试成绩×60% + 实验成绩×30% + 平时成绩×10%,考试为闭卷。

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 分。

了解

1.2 存储程序计算机与冯·诺依曼原理页4页5页6页4

Hook:计算机凭什么能「自动」算题?它并不知道自己在算什么,它只是在不停地重复一件极笨的事——取下一条指令、执行它。

冯·诺依曼体系结构的两条核心原则:存储器既保存指令又保存数据(Memory holds instructions and data),CPU 是指令的解释器(CPU interpreter of instructions)。

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 指令加一段约定好的栈布局。

必考

1.3 ABI 与汇编指令编码页7页7

Hook:你写的 C 函数能调用别人编译好的库函数,双方从没见过面,凭什么参数就能对上号?靠的是一份「二进制层面的握手协议」。

ABI(Application Binary Interface,应用二进制接口)是程序与 CPU 的接口界面,它规定三件事:指令编码(本课程聚焦汇编指令)、寄存器使用约定(什么指令用什么寄存器)、以及大部分指令可以直接带内存地址。

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 约束的是二进制层面的调用约定与寄存器职责。

必考

1.4 X86 指令执行与 EIP 机制页8页8

Hook:一个程序的执行顺序,其实只由一个寄存器里的数字决定。谁改了这个数字,谁就控制了程序——这正是栈溢出攻击的靶心。

EIP(指令指针)在每条指令执行后被递增;X86 指令长度不等长;EIP 会被 CALL、RET、JMP 以及条件跳转修改,从而改变执行流。

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 照常自增。

必考

1.5 通用寄存器、段寄存器与 EFLAGS页9页10页11页12页9

Hook:CPU 里就那么十几个小格子,却能装下整个程序的运行状态。它们各自的分工,是被约定死的还是天生的?

通用寄存器有 8/16/32 位三种版本(如 AL/AH → AX → EAX),按约定部分寄存器有专门用途;段寄存器 CS/DS/ES/SS 分别指向代码段、数据段、附加段、堆栈段;EFLAGS 记录运算结果状态;64 位寄存器与 32 位在核心机制上差别不大,只是多了一些寄存器。

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 设定后在整个函数内固定不动,作为访问参数和局部变量的基准。

必考

1.6 内存访问指令与 b/w/l/q 操作数尺寸页13

Hook:同一条 mov 指令,搬 1 个字节还是 8 个字节,CPU 怎么知道?答案就藏在指令名后缀那个小写字母里。

内存是更大的工作空间;内存访问指令有 MOV、PUSH、POP 等;大部分指令可以带内存地址;后缀 b/w/l/q 分别代表 8 位、16 位、32 位、64 位;指令格式为 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 字节)。

后缀位宽字节数示例
b8 位1movb
w16 位2movw
l32 位4movl
q64 位8movq

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 风格。做题前先确认语法风格,否则整条指令方向读反。

高频

1.7 堆栈内存与 push/pop 操作画栈页14页15页16页17页18页19页20页21页22页23页24页25页14

Hook:给你四行汇编,让你画出内存里那几格数字——这是本课程最经典的送分题,也是最容易翻车的题。翻车点只有一个:栈到底往哪个方向长。

栈向低地址方向生长(Stack grows down),主要用途是实现过程调用;push 先减 ESP 再写入,pop 先读出再加 ESP;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 $80X1000 → 0X0FFC[0X0FFC] = 8
movl %esp, %ebp不变EBP = 0X0FFC
subl $4, %esp0X0FFC → 0X0FF8该格内容未定义
movl $8, (%esp)不变[0X0FF8] = 8
易错:① 以为栈向上长,于是把 0X0FFC 写成 0X1004;② 以为 addl $4,%esp 会清空内存——它只移动指针,数据还在;③ 以为 popl %esp 只是简单加 4——它是先读栈顶内容再赋给 ESP,等于 ESP 先变成栈里存的值、然后再加 4。

必考

1.8 从 C 到可运行程序的汇编映射页26页27页26

Hook:三行 C 代码,函数互相调用,编译器把它变成了三段几乎一模一样的骨架。看懂这个骨架,你就能反推出任何 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,不是两条独立无关的指令。

必考

1.9 GCC 多阶段编译与 32 位环境实操页28页29页28

Hook:作业要求你生成 .cpp、.s、.o 和 ELF 可执行文件四个中间产物——为什么非要四步?因为每一步都揭示了「程序如何变成机器能跑的东西」的一层。

GCC 把编译拆成预处理(-E)、编译成汇编(-S)、汇编成目标文件(-c)、链接成可执行文件四步;在 64 位系统上生成 32 位程序要加 -m32,并需安装 libc6-dev-i386。

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 正好夹在参数与局部变量之间,作为栈帧基准。
问题二:main 调用 f(8)、f 调用 g(x)、g 返回 x+3、main 返回 f(8)+1,最终返回值是多少?为什么 g 里用 8(%ebp) 就能取到参数 x?
参考答案返回值为 12:g(8) = 8+3 = 11,f 原样返回 11,main 再加 1 得 12,结果放在 EAX 中带回。取参依据是栈帧布局:call 先把返回地址压栈,被调用函数再 pushl %ebp 保存旧基址并把 ESP 赋给 EBP,于是 EBP+0 是旧 EBP、EBP+4 是返回地址、EBP+8 才是调用者压入的第一个参数。这也说明为什么函数尾声要用 leave(等价于 movl %ebp,%esp 再 popl %ebp)恢复现场,再 ret 弹出返回地址写入 EIP。

章节测试

共 17 题

0
总分

📋 AI批改任务已生成

答案已下载为 JSON 文件(通常在下载文件夹)。将以下命令发送给 Claude Code EPA skill,AI 会自动批改并生成报告:

/exampass grade "<路径>"

将 <路径> 替换为刚下载的 JSON 文件的完整路径。