💣 CSAPP BombLab 实验指南

⚠️ 注意，本文只提供个人的解法与思路，不能代替自己亲手用调试器做实验。如果你希望更好地锻炼自己的能力，仅仅在你尝试过，并且被卡住时候，观看对应章节的内容。或者，在你独立做完实验，可以与本指南中的内容核对。也欢迎各位对本文中的拼写错误、细节遗漏等方面进行补充！

本文受到了更适合北大宝宝体质的 Bomb Lab 踩坑记很大的启发，因此你可能发现一些雷同的内容，这都只是我的拙劣模仿。

实验介绍

本实验是 CSAPP 第三章的实验内容，设计了汇编的许多方面，包括整数运算、字符串比较、循环条件分支、递归调用、栈、指针、链表、结构等等。本文读者应当学习过以上内容，进而更好地理解该实验。

Bomblab 的实验背景相当经典，可以在 bomb.c 中看到。简单来说，你需要根据二进制程序来拆弹💣。

实验准备

实验暴露出来的源码 bomb.c 只涵盖了一小部分，没有涉及每个函数具体是如何实现的。不过，我们可以从中看出大概流程——获取输入，然后执行下面的函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
initialize_bomb();

printf("Welcome to my fiendish little bomb. You have 6 phases with\n");
printf("which to blow yourself up. Have a nice day!\n");

/* Hmm...  Six phases must be more secure than one phase! */
input = read_line();             /* Get input                   */
phase_1(input);                  /* Run the phase               */
phase_defused();                 /* Drat!  They figured it out!
                    * Let me know how they did it. */
printf("Phase 1 defused. How about the next one?\n");

// 更多内容

每次都读取一行作为输入，给 phase_n ，然后运行 phase_defused 函数。

为了调试二进制程序，需要使用 gdb。我已经在之前的文章中，介绍了 GDB Dashboard 以及 pwndbg。为了更好的体验，建议先配置 pwndbg ，但这不是必需的。本文前四个阶段使用 GDB Dashboard，后两个阶段使用 pwndbg。

参考北大Bomblab踩坑记¹，该实验用到的常用调试指令如下：

指令	全称	描述
r	run	开始执行程序，直到下一个断点或程序结束
q	quit	退出 GDB 调试器
ni	nexti	执行下一条汇编指令，但不进入函数内部
si	stepi	执行当前汇编指令，如果是函数调用则进入函数
b	break	在指定位置设置断点
c	cont	从当前位置继续执行程序，直到下一个断点或程序结束
p	print	打印变量的值
x		打印内存中的值

注意 n 或者 q 指令是直接进行一步源代码指令，因此该实验中不会用到。p 是打印变量的值，通常是寄存器，不过在 pwndbg 的存在下没什么必要。x 是打印某个地址对应的值，也可以看做进行一次解引用操作，相当常用。

一些常用指令：

1
2
3
4
5
6
7
8
9
x/2x $rsp  # 以十六进制格式查看栈指针 %rsp 指向的内存位置 M[%rsp] 开始的两个单位。
x/2d $rsp # 以十进制格式查看栈指针 %rsp 指向的内存位置 M[%rsp] 开始的两个单位。
x/2c $rsp # 以字符格式查看栈指针 %rsp 指向的内存位置 M[%rsp] 开始的两个单位。
x/s $rsp # 把栈指针指向的内存位置 M[%rsp] 当作 C 风格字符串来查看。

x/b $rsp # 检查栈指针指向的内存位置 M[%rsp] 开始的 1 字节。
x/h $rsp # 检查栈指针指向的内存位置 M[%rsp] 开始的 2 字节（半字）。
x/w $rsp # 检查栈指针指向的内存位置 M[%rsp] 开始的 4 字节（字）。
x/g $rsp # 检查栈指针指向的内存位置 M[%rsp] 开始的 8 字节（双字）。

注意 / 后面的后缀（如 2x、2d、s、g、20c）指定了查看内存的方式和数量。具体来说：

第一个数字（如 2、20）指定要查看的单位数量。
第二个字母（如 x、d、s、c）指定单位类型和显示格式，其中：
- c / d / x 分别代表以字符 / 十进制 / 十六进制格式显示内存内容。
- s 代表以字符串格式显示内存内容。
第三个字母（如 b / h / w / g）分别代表以 1 / 2 / 4 / 8 字节为单位（unit）显示内存内容。

为了方便每次运行 gdb bomb 都能进入我们想要的部分，可以编辑当前文件夹下的 .gdbinit 文件（注意还需要更改系统的~/.config/gdb/gdbinit，参考GDB Dashboard 教程）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
set args psol.txt

b phase_1
#b phase_2
#b phase_3
#b phase_4
#b phase_5
#b phase_6

#b phase_defused

setupwin /dev/pts/5

这当中 set args 可以指定参数。当前目录下的 psol.txt 文件的每一行，就是对每一个阶段的解答。这样每次完成一个阶段，都可以写入 psol.txt 文件，不用重复输入密码。

断点可以根据当前阶段设置。# 开头的是注释。例如当前完成了前两个阶段，就可以只为第三阶段开启。

最后一行是我为 pwndbg 自定义的函数，为了打印调试信息到指定内容，参考 pwndbg 教程与自定义配置。

同时，因为 GDB 或者 pwndbg 能看到的反汇编代码的范围有限，为了方便查找，可以一次性生成反汇编代码并存储：

1
objdump -d bomb > bomb.asm

这样就可以在 VSCode 中查找。

如果你发现 CSAPP Labs 只有远程桌面，其实你可以简单地把 gitlab 链接复制，在本地或其他指定的地方克隆下来，运行即可。例如我使用的是一个远程 Ubuntu 电脑，本地使用 VSCode SSH，以及直接利用 Tabby SSH 连接。

本文中不区分 eax 与 rax 等 32 位与 64 位寄存器，认为是等价的。本文中十六进制尽量使用 0x 前缀开头，但可能有遗漏。

phase_1

运行程序 gdb bomb，然后输入 run：

1
2
3
4
(gdb) run
Starting program: /home/ywr/dsc/learn/csapp/bomblab/bomb psol.txt
Welcome to my fiendish little bomb. You have 6 phases with
which to blow yourself up. Have a nice day!

此时可以随意输入一些尝试，例如我输入 123456 并回车，就进入了 phase_1 的断点：

1
2
Breakpoint 1, 0x0000000000400e6d in phase_1 ()
(gdb) 

搜索 phase_1，可以看到如下代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
0000000000400e6d <phase_1>:
  400e6d:	48 83 ec 08          	sub    $0x8,%rsp
  400e71:	be d0 23 40 00       	mov    $0x4023d0,%esi
  400e76:	e8 cf 04 00 00       	callq  40134a <strings_not_equal>
  400e7b:	85 c0                	test   %eax,%eax
  400e7d:	75 05                	jne    400e84 <phase_1+0x17>
  400e7f:	48 83 c4 08          	add    $0x8,%rsp
  400e83:	c3                   	retq   
  400e84:	e8 be 05 00 00       	callq  401447 <explode_bomb>
  400e89:	eb f4                	jmp    400e7f <phase_1+0x12>

可以看到，第三步调用了 strings_not_equal 函数。让我们输入两次 ni，到达 0x400e76 处。

1
2
3
4
(gdb) ni
0x0000000000400e71 in phase_1 ()
(gdb) ni
0x0000000000400e76 in phase_1 ()

汇编中第一个与第二个参数分别是 %rdi 与%rsi，让我们尝试打印：

1
2
3
4
(gdb) p/x $rdi
$1 = 0x603780
(gdb) p/x $rsi
$2 = 0x4023d0

我们将这两个看成字符串指针，尝试打印：

1
2
3
4
(gdb) x/s $rdi
0x603780 <input_strings>:       "123456"
(gdb) x/s $rsi
0x4023d0:       "Slave, thou hast slain me. Villain, take my purse."

可以看出，其中 123456 就是我们输入的字符，也是 input_strings。剩下的就应该是第一阶段的密码了。

阅读原先汇编的逻辑，也可以知道在 strings_not_equal 调用后，会利用 test %eax,%eax 来判断返回值是否为 0（test 指令会对两个操作数进行按位与运算），之后根据 jne 进行跳转。如果不为 0，则跳转到 0x400e84，然后调用 explode_bomb 函数，引发爆炸；如果为 0，说明字符串匹配，则恢复栈指针位置，然后返回。

所以第一阶段密码为 Slave, thou hast slain me. Villain, take my purse. 。

phase_2

read_six_numbers 分析

调用 read_six_numbers 后爆炸，对该函数打断点。

rcx 写为 0x00007fffffffdb44，rax 写为 0x00007fffffffdb54，推入栈，然后写为 0x00007fffffffdb50，再推入栈。r9 为0x00007fffffffdb4c，r8 为0x00007fffffffdb48 。

调用前，rdi 为 0x00007fffffffd4d0，rsi 为 0x00000000004025c3。

打印 sscanf 输入参数对应位置：

1
2
3
4
>>> x/s $rdi
0x6037d0 <input_strings+80>:    "123456"
>>> x/s $rsi
0x4025c3:       "%d %d %d %d %d %d"

发现其中第一个参数就是我们输入的字符串，第二个就是指定的格式。参考 sscanf 的使用方法²：

1
int sscanf ( const char * s, const char * format, ...);

函数返回值代表捕捉到的参数个数。第一个参数是输入字符串（如 123456），第二个是指定格式（如 %d %d %d %d %d %d），之后的参数都是指针，指向希望存储数据的位置。

根据定义，第三个参数开始分别是 rdx、rcx、r8、r9，超过六个参数都会压入调用者的栈中。注意，栈顶是从内存大区域往小区域的，并且压入的参数是逆序的，也就是先压入第8个参数，再压入第7个参数。所以地址最大的 %rsi+0x14 是最先压入的，也就是最后的参数。

调用后，返回值 eax 会与 5 比较，如果小于等于 5，则会直接爆炸。这说明我们应该符合格式，输入 6 个整数进行尝试，如 1 2 3 4 5 6。在 0x401486 处停下，打印这些变量，就可以得到此时这些变量。打印的是现在 rsi 指向的地址，也就是0x7fffffffdb40。

1
2
3
>>> x/6dw 0x7fffffffdb40
0x7fffffffdb40: 0       0       4199486 0
0x7fffffffdb50: -9112   32767

目前都为空。经过 sscanf 函数后再次打印：

1
2
3
>>> x/6dw 0x7fffffffdb40
0x7fffffffdb40: 1       2       3       4
0x7fffffffdb50: 5       6

我们发现这就是 sscanf 获得的输入，将我们的输入存到了 6 个 int 类型中，放在栈上，是连续的六个变量。

参数	值/指向的地址	指向的值
rdx	%rsi	1
rcx	%rsi+0x4	2
r8	%rsi+0x8	3
r9	%rsi+0xc	4
第七个参数	%rsi+0x10	5
第八个参数	%rsi+0x14	6

phase_2 本身分析

之后来分析 phase_2 本身。该部分有详细的汇编注释，但之后的汇编中我会减少相关注释。注意下面的 emoji 代表了跳转的位置：

 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
0000000000400e8b <phase_2>:
# ...省略...

400ea3:	e8 c1 05 00 00       	callq  401469 <read_six_numbers> # 获取六个数字
400ea8:	83 3c 24 00          	cmpl   $0x0,(%rsp) # rsp 第一个数字 与 0 比较
400eac:	78 07                	js     400eb5 <phase_2+0x2a> # 有符号比较，当第一个数字为负数的时候跳转到爆炸
400eae:	bb 01 00 00 00       	mov    $0x1,%ebx # 将 ebx 变为1
400eb3:	eb 11                	jmp    400ec6 <phase_2+0x3b> # 无条件跳转到 ec6 一行😭
400eb5:	e8 8d 05 00 00       	callq  401447 <explode_bomb> # 爆炸
400eba:	eb f2                	jmp    400eae <phase_2+0x23>
400ebc:	48 83 c3 01          	add    $0x1,%rbx # 😁：rbx += 1
400ec0:	48 83 fb 06          	cmp    $0x6,%rbx # 将 rbx 与 6 比较
400ec4:	74 12                	je     400ed8 <phase_2+0x4d> # 如果相等，说明循环结束，跳转到🚩
400ec6:	89 d8                	mov    %ebx,%eax  # 😭：eax 变成 ebx
400ec8:	03 44 9c fc          	add    -0x4(%rsp,%rbx,4),%eax # eax += rsp对应数组中rbx偏移量后减去4，也就是rbx为1 2 3分别对应数组索引 0 1 2，也即 rsp[rbx-1]
400ecc:	39 04 9c             	cmp    %eax,(%rsp,%rbx,4) # 将 rsp[rbx] 与 eax 比较
400ecf:	74 eb                	je     400ebc <phase_2+0x31> # 如果相等，跳转到😁
400ed1:	e8 71 05 00 00       	callq  401447 <explode_bomb>
400ed6:	eb e4                	jmp    400ebc <phase_2+0x31>
400ed8:	48 8b 44 24 18       	mov    0x18(%rsp),%rax # 🚩：此时循环结束，将 rax 变成 rsp 地址加上 18
400edd:	64 48 33 04 25 28 00 	xor    %fs:0x28,%rax # 异或比较
400ee4:	00 00 
400ee6:	75 06                	jne    400eee <phase_2+0x63> # 如果不相等，跳转到最后一行
400ee8:	48 83 c4 20          	add    $0x20,%rsp # rsp 增加 20
400eec:	5b                   	pop    %rbx # 推出元素
400eed:	c3                   	retq   @ 返回
400eee:	e8 0d fc ff ff       	callq  400b00 <__stack_chk_fail@plt> # 报错

可以跟着编译器，看出其跳转的逻辑，写成 C 的话类似这样：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
int[] rsp;
int eax;

if (rsp[0] < 0 ) {
    explode();
}

int ebx = 1;

do {
    eax = ebx;
    eax += rsp[ebx-1];

    if (!(eax = rsp[ebx])) {
        explode();
    }

    ebx++;
} while (ebx != 6)

所以，第一个循环 eax 为 1，并且 eax 加上数组第 0 个元素，判断是否等于数组第 1 个元素；之后继续循环。

可以有多种解，就是一个二阶等差数列（二次函数），相邻两个元素的差是 1 2 3 4 5。同时保证第一个数不小于 0 即可：

1
2
3
4
0 1 3 6 10 15
1 2 4 7 11 16
2 3 5 8 12 17
...

phase_3

在 sscanf 调用前，esi 便是第二个输入参数，代表了匹配的格式，打印得出：

1
2
>>> x/s $rsi
0x4025cf:       "%d %d"

这说明第三阶段希望匹配两个整数。前面将函数第三个参数 rdx 设置为 rsp 地址，第四个参数 rcx 设置为 0x4(%rsp) ，说明 rsp 指向了我们输入的两个数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
0000000000400ef3 <phase_3>:
400f0f:	be cf 25 40 00       	mov    $0x4025cf,%esi
400f14:	e8 87 fc ff ff       	callq  400ba0 <__isoc99_sscanf@plt>
400f19:	83 f8 01             	cmp    $0x1,%eax  # 比较 sscanf 返回值与 1
400f1c:	7e 10                	jle    400f2e <phase_3+0x3b> # 如果小于等于1，则爆炸
400f1e:	83 3c 24 07          	cmpl   $0x7,(%rsp) # 比较 rsp 指向的值与 7
400f22:	77 42                	ja     400f66 <phase_3+0x73> # 如果大于7，爆炸
400f24:	8b 04 24             	mov    (%rsp),%eax # 否则将 rsp 指向的值放入 eax
400f27:	ff 24 c5 40 24 40 00 	jmpq   *0x402440(,%rax,8) # 将 rax 作为索引，跳转到指定位置
...

尝试输入 1 2。调试发现 0x400f1e 步 rsp 指向的值为 1，也就是我们输入的第一个数。接下来与 7 进行比较，然后有一大堆跳转。不难想到，这是 switch 的跳转表。可知表的位置在 0x402440 ，尝试打印（打印 8 个单位，以十六进制，每个单位有 8 个字节）。

1
2
3
4
5
>>> x/8xg 0x402440
0x402440:       0x0000000000400f72      0x0000000000400f35
0x402450:       0x0000000000400f3c      0x0000000000400f43
0x402460:       0x0000000000400f4a      0x0000000000400f51
0x402470:       0x0000000000400f58      0x0000000000400f5f

这就是输入数从 0 到 7 的时候，对应的跳转位置。让我们根据下面的代码进行分析，加上注释，将第一个输入称为 x：

 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
400f1e:	83 3c 24 07          	cmpl   $0x7,(%rsp)
400f22:	77 42                	ja     400f66 <phase_3+0x73>
400f24:	8b 04 24             	mov    (%rsp),%eax
400f27:	ff 24 c5 40 24 40 00 	jmpq   *0x402440(,%rax,8)
400f2e:	e8 14 05 00 00       	callq  401447 <explode_bomb>
400f33:	eb e9                	jmp    400f1e <phase_3+0x2b> # 调到rsp的值与7的比较
400f35:	b8 35 02 00 00       	mov    $0x235,%eax   		# x = 1
400f3a:	eb 3b                	jmp    400f77 <phase_3+0x84>
400f3c:	b8 a7 01 00 00       	mov    $0x1a7,%eax   		# x = 2
400f41:	eb 34                	jmp    400f77 <phase_3+0x84>
400f43:	b8 2b 02 00 00       	mov    $0x22b,%eax   		# x = 3
400f48:	eb 2d                	jmp    400f77 <phase_3+0x84>
400f4a:	b8 6c 00 00 00       	mov    $0x6c,%eax   		# x = 4
400f4f:	eb 26                	jmp    400f77 <phase_3+0x84>
400f51:	b8 f1 02 00 00       	mov    $0x2f1,%eax   		# x = 5
400f56:	eb 1f                	jmp    400f77 <phase_3+0x84>
400f58:	b8 3e 00 00 00       	mov    $0x3e,%eax    		# x = 6
400f5d:	eb 18                	jmp    400f77 <phase_3+0x84>
400f5f:	b8 48 02 00 00       	mov    $0x248,%eax   		# x = 7
400f64:	eb 11                	jmp    400f77 <phase_3+0x84> 
400f66:	e8 dc 04 00 00       	callq  401447 <explode_bomb>
400f6b:	b8 00 00 00 00       	mov    $0x0,%eax
400f70:	eb 05                	jmp    400f77 <phase_3+0x84>
400f72:	b8 21 01 00 00       	mov    $0x121,%eax  		 # x = 0
400f77:	39 44 24 04          	cmp    %eax,0x4(%rsp) 		 # 继续运行，比较eax 与第二个输入数字的值
400f7b:	74 05                	je     400f82 <phase_3+0x8f>  # 如果相等，跳转到下方
400f7d:	e8 c5 04 00 00       	callq  401447 <explode_bomb>  # 不然爆炸
400f82:	48 8b 44 24 08       	mov    0x8(%rsp),%rax  # 开始各种栈相关的操作
400f87:	64 48 33 04 25 28 00 	xor    %fs:0x28,%rax
400f8e:	00 00 
400f90:	75 05                	jne    400f97 <phase_3+0xa4>
400f92:	48 83 c4 18          	add    $0x18,%rsp
400f96:	c3                   	retq   
400f97:	e8 64 fb ff ff       	callq  400b00 <__stack_chk_fail@plt>

通过注释，我们不难发现，当 x 从 0 遍历到 7 的时候，都会通过一行 mov 命令设置 eax 的值，然后跳转到 0x400f77，将 eax 与第二个输入进行比较。如果不相等，就爆炸。

因此可以得出多种解法，只要让第二个参数，与对应的 mov 中的硬编码的值一样即可。注意之前 sscanf 的 %d 只能匹配十进制输入，所以需要将十六进制进行转换。

原先十六进制：

转换为十进制：

任意一行都是有效的解。

phase_4

phase_4 本身分析

照样有 sscanf 函数，打印出 rsi，发现还是两个整数：

1
2
>>> x/s $rsi
0x4025cf:       "%d %d"

第三个参数 rdx 设置为 rsp 地址，第四个参数 rcx 设置为 0x4 (%rsp) ，与第三阶段一样，还是将两个输入存放在 rsp 指向的位置。

调用 sscanf 后先检验返回值是否为 2，如果不是，直接爆炸。接着比较 rsp 指向的值，也就是第一个输入与 0xe（14）的关系，如果小于等于 14，正常跳转；否则爆炸。

1
2
3
4
5
6
7
400ff7:	be cf 25 40 00       	mov    $0x4025cf,%esi
400ffc:	e8 9f fb ff ff       	callq  400ba0 <__isoc99_sscanf@plt>
401001:	83 f8 02             	cmp    $0x2,%eax # 检验返回值是否为2
401004:	75 06                	jne    40100c <phase_4+0x31>
401006:	83 3c 24 0e          	cmpl   $0xe,(%rsp)
40100a:	76 05                	jbe    401011 <phase_4+0x36> # 如果rsp指向的值小于等于14，跳转
40100c:	e8 36 04 00 00       	callq  401447 <explode_bomb> # 爆炸

分析接下来的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
401011:	ba 0e 00 00 00       	mov    $0xe,%edx
401016:	be 00 00 00 00       	mov    $0x0,%esi
40101b:	8b 3c 24             	mov    (%rsp),%edi
40101e:	e8 79 ff ff ff       	callq  400f9c <func4>
401023:	83 f8 03             	cmp    $0x3,%eax
401026:	75 07                	jne    40102f <phase_4+0x54>
401028:	83 7c 24 04 03       	cmpl   $0x3,0x4(%rsp) # 将第二个数字与 3 比较
40102d:	74 05                	je     401034 <phase_4+0x59>
40102f:	e8 13 04 00 00       	callq  401447 <explode_bomb>
401034:	48 8b 44 24 08       	mov    0x8(%rsp),%rax # 正常操作
401039:	64 48 33 04 25 28 00 	xor    %fs:0x28,%rax
401040:	00 00 
401042:	75 05                	jne    401049 <phase_4+0x6e>
401044:	48 83 c4 18          	add    $0x18,%rsp
401048:	c3                   	retq   
401049:	e8 b2 fa ff ff       	callq  400b00 <__stack_chk_fail@plt>

设置 edx 为 14，esi 为 0，edi 为第一个数字的值，然后调用 func4 函数。

根据输入参数顺序，可以 func4 第一个参数 rdi 为第一个数字，第二个参数为 rsi 为 0，第三个参数 rdx 为 14 。

调用后将返回值与 3 比较，如果不一样，直接爆炸；否则将第二个输入与 3 比较，如果不相等，直接爆炸。所以这里可以确定第二个输入为 3 。

所以，剩下来就看 func4 是如何处理 eax 的，让 fun4 返回值为 3。

func4 分析

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
0000000000400f9c <func4>:
400f9c:	48 83 ec 08          	sub    $0x8,%rsp
400fa0:	89 d0                	mov    %edx,%eax
400fa2:	29 f0                	sub    %esi,%eax
400fa4:	89 c1                	mov    %eax,%ecx
400fa6:	c1 e9 1f             	shr    $0x1f,%ecx
400fa9:	01 c1                	add    %eax,%ecx
400fab:	d1 f9                	sar    %ecx
400fad:	01 f1                	add    %esi,%ecx
400faf:	39 f9                	cmp    %edi,%ecx
400fb1:	7f 0e                	jg     400fc1 <func4+0x25>
400fb3:	b8 00 00 00 00       	mov    $0x0,%eax
400fb8:	39 f9                	cmp    %edi,%ecx
400fba:	7c 11                	jl     400fcd <func4+0x31>
400fbc:	48 83 c4 08          	add    $0x8,%rsp
400fc0:	c3                   	retq   
400fc1:	8d 51 ff             	lea    -0x1(%rcx),%edx
400fc4:	e8 d3 ff ff ff       	callq  400f9c <func4>
400fc9:	01 c0                	add    %eax,%eax
400fcb:	eb ef                	jmp    400fbc <func4+0x20>
400fcd:	8d 71 01             	lea    0x1(%rcx),%esi
400fd0:	e8 c7 ff ff ff       	callq  400f9c <func4>
400fd5:	8d 44 00 01          	lea    0x1(%rax,%rax,1),%eax
400fd9:	eb e1                	jmp    400fbc <func4+0x20>

首先将栈指针 rsp 减小，edx（14）放入 eax，减去 esi（0），再放到 ecx，向右移位 0x1f，也就是 31 位，ecx 变成 0 。ecx 加上 eax 变成 14。单独的 sar 就是向右算数移位 1 位，ecx 变成 7。加上 esi 不变。将 ecx（7）与 edi（第一个输入）比较，如果大于，跳转。

第一个输入小于 7，跳转到400fc1，将 edx 设置为 rcx 减去 1（6），递归调用自身
第一个输入大于等于 7，没有跳转，eax 变成 0，比较 ecx（7）与 edi，此时一定小于等于
- 小于时跳转400fcd，将 esi 设置为 rcx+1，即 8，递归调用
- 输入等于 7，不跳转，将栈指针增大，返回

为了方便看，将所有变量前面的 e 或者 r 隐藏：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
func4(int dx = 14, int si = 0, int di = 第一个输入) {
    int ax = dx - si;
    int cx = ax >> 31 + ax;
    cx = cx >> 1;
    cx += si;   // cx = (dx-si的符号位 + dx-si) / 2 + si
    if (cx > di) {
        dx = cx - 1;
        func4(dx, si, di); // 这里的 esi 与 edi 与输入的值一样，edx不同
        ax *= 2;
        return;
    } else {
        ax = 0;
        if (cx < di) {
            si = cx + 1;
            func4 (dx, si, di);
            ax = 2 * ax + 1;
            return;
        } else {
            return;
        }
    }
}

我们希望运行这个函数后，ax 的值为 3 。

直接分析很难，尝试倒推。ax 有几个地方会被修改：

进入函数，ax 设置为 dx - si
当修改后的 cx <= di 时，ax 设置为 0
之后如果 cx < di，调用函数后，ax 设置为 2 * ax + 1

也可以发现，函数中 di 仅仅会在判断的时候用到，永远不会被修改。并且判断分为三种可能，也就是 cx 与 di 的大小关系，其中 cx 为 (dx-si -(dx-si) 的符号位 ) / 2 + si，看起来是取 dx 与 si 的平均值。

例如，一开始输入 dx 为 14，si 为 0，则 cx 为 7。ax 在函数开始初始化为两端之差。

若均值大于 di，则 dx 变成 cx-1，也就是大端变成均值-1；然后递归调用，其中会改变 ax，最后返回 ax * 2
若均值小于 di，则 si 变成 cx+1，也就是小端变成均值+1；然后递归调用，其中会改变 ax，最后返回 ax * 2 + 1
如果均值等于 di，则直接返回，ax 为 0

这种形式很像二分法。我们希望最后的 ax 返回值为 3，是奇数，其倒推的过程应该是 0 -> (0 * 2 + 1 = 1) -> (1 * 2 + 1 = 3) 因此均值应该小于 di，也就是 di 大于 7 。

调用函数过程中，ax 应该为 1 。在这个函数中，1 为奇数，因此其均值也应该小于 di，第二层递归。在第二层递归中，应该均值等于 di，直接返回 ax 为 0 。这样就可以构造出结果。

[0, 14] 的均值为 7，di 大于 7 。[8, 14] 的均值为 11，di 应该大于 11。[12, 14] 的均值为 13。所以应该为 13。

总之，第四阶段输入为：

1
13 3

phase_5

开始时的 sscanf 前面还是 0x4025cf，调试发现还是将输入的两个数字，存到 rsp 所指的栈上，若输入个数小于 2 则爆炸。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
40106a:	be cf 25 40 00       	mov    $0x4025cf,%esi
40106f:	e8 2c fb ff ff       	callq  400ba0 <__isoc99_sscanf@plt> 
401074:	83 f8 01             	cmp    $0x1,%eax
401077:	7e 57                	jle    4010d0 <phase_5+0x82> #输入个数小于2，爆炸
401079:	8b 04 24             	mov    (%rsp),%eax # eax变成第一个输入
40107c:	83 e0 0f             	and    $0xf,%eax
40107f:	89 04 24             	mov    %eax,(%rsp)
401082:	83 f8 0f             	cmp    $0xf,%eax
401085:	74 2f                	je     4010b6 <phase_5+0x68> #爆炸
401087:	b9 00 00 00 00       	mov    $0x0,%ecx
40108c:	ba 00 00 00 00       	mov    $0x0,%edx
401091:	83 c2 01             	add    $0x1,%edx
401094:	48 98                	cltq   

接着 eax 变成第一个输入，与 0xf 按位与运算，写入 rsp 第一个输入。如果 eax 等于 0xf，爆炸。然后 ecx 为 0，edx 为 1，并将 eax 拓展为 64 位。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
401091:	83 c2 01             	add    $0x1,%edx # 😎
401094:	48 98                	cltq   
401096:	8b 04 85 80 24 40 00 	mov    0x402480(,%rax,4),%eax
40109d:	01 c1                	add    %eax,%ecx
40109f:	83 f8 0f             	cmp    $0xf,%eax
4010a2:	75 ed                	jne    401091 <phase_5+0x43> # 跳转到 😎，循环计数
4010a4:	c7 04 24 0f 00 00 00 	movl   $0xf,(%rsp)
4010ab:	83 fa 03             	cmp    $0x3,%edx
4010ae:	75 06                	jne    4010b6 <phase_5+0x68>
4010b0:	39 4c 24 04          	cmp    %ecx,0x4(%rsp)
4010b4:	74 05                	je     4010bb <phase_5+0x6d>
4010b6:	e8 8c 03 00 00       	callq  401447 <explode_bomb>
4010bb:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
4010c0:	64 48 33 04 25 28 00 	xor    %fs:0x28,%rax
4010c7:	00 00 
4010c9:	75 0c                	jne    4010d7 <phase_5+0x89>
4010cb:	48 83 c4 18          	add    $0x18,%rsp
4010cf:	c3                   	retq   
4010d0:	e8 72 03 00 00       	callq  401447 <explode_bomb>
4010d5:	eb a2                	jmp    401079 <phase_5+0x2b>
4010d7:	e8 24 fa ff ff       	callq  400b00 <__stack_chk_fail@plt>

接下来会取 0x402480 开始的第 rax 的元素，尝试打印：

1
2
3
4
5
6
pwndbg> x/20dw 0x402480
0x402480 <array.3415>:  10      2       14      7
0x402490 <array.3415+16>:       8       12      15     11
0x4024a0 <array.3415+32>:       0       4       1      13
0x4024b0 <array.3415+48>:       3       9       6      5
0x4024c0:       2032168787      1948284271      1802398056      1970239776

发现这是一个大小为 16 的数组，这也说明了之前为什么要限制 eax 为 0 到 15 之间的数：

其索引与数组元素的对应关系如下：

0	1	2	3	4	5	6	7
10	2	14	7	8	12	15	11

8	9	10	11	12	13	14	15
0	4	1	13	3	9	6	5

取其中第 rax 的元素放入 eax，将 ecx 加上 eax。判断 eax 与 0xf（15）的关系，如果不相等，跳转回 0x401091。期间对 edx 不断加 1，ecx 不断加上 eax。

画出其跳转关系：

0 -> 10 -> 1 -> 2 -> 14 -> 6 -> 15 -> 5 -> 12 -> 3 -> 7 -> 11 -> 13 -> 9 -> 4 -> 8 -> 0，然后循环。可以知道当变成 15 的时候终止，所以可以改变终点：

5 -> 12 -> 3 -> 7 -> 11 -> 13 -> 9 -> 4 -> 8 -> 0 -> 10 -> 1 -> 2 -> 14 -> 6 -> 15

循环结束后，将 15 写入 rsp 指向的元素，也就是第一个输入改为 15 。然后将 edx 与 3 进行比较，如果不为 3，跳转并爆炸。

这说明循环需要进行 3 次。例如，我的尝试中输入为 13 14，在 0x4010a4 打上断点，发现此时 edx 为 0xa(10)，刚好是上面的链条中 13 到最后 15 的距离。

因此，第一个输入应该是 2，或者 2 + 16n，其中 n 为自然数。

之后，将 ecx 与第二个输入比较，如果不相等，爆炸。已知 ecx 是累计的数字的和，可知其为 14 + 6 + 15 = 35。

总之，输入可以是如下的数：

phase_6

首先将多个 caller-saved 的寄存器推入栈：

1
2
3
4
5
6
0000000004010dc <phase_6>:
  4010dc:	41 56                	push   %r14
  4010de:	41 55                	push   %r13
  4010e0:	41 54                	push   %r12
  4010e2:	55                   	push   %rbp
  4010e3:	53                   	push   %rbx

接着是金丝雀数的一些操作（参考¹），此处略。

然后将 eax 清零，rsp 放入第二个参数 rsi，调用 read_six_numbers。

1
2
3
4
5
6
7
4010f6:	31 c0                	xor    %eax,%eax
4010f8:	48 89 e6             	mov    %rsp,%rsi
4010fb:	e8 69 03 00 00       	callq  401469 <read_six_numbers>
401100:	49 89 e4             	mov    %rsp,%r12
401103:	49 89 e5             	mov    %rsp,%r13
401106:	41 be 00 00 00 00    	mov    $0x0,%r14d
40110c:	eb 25                	jmp    401133 <phase_6+0x57>

回顾之前的 read_six_numbers 函数，可知第一个参数 dsi 是我们的输入字符串的地址，例如此处我的输入为 2 3 4 5 6 7，第二个参数 rsi 是当前 rsp 的地址。

调用 read_six_numbers 后，打印当前 rsp 对应的量：

1
2
3
pwndbg> x/6dw $rsp
0x7fffffffd9f0: 2       3       4       5
0x7fffffffda00: 6       7

可知我们输入的六个数都存在了栈上。然后函数更改一些寄存器，跳到 0x401133。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
401133:	4c 89 ed             	mov    %r13,%rbp
401136:	41 8b 45 00          	mov    0x0(%r13),%eax
40113a:	83 e8 01             	sub    $0x1,%eax
40113d:	83 f8 05             	cmp    $0x5,%eax
401140:	77 cc                	ja     40110e <phase_6+0x32> # 爆炸
401142:	41 83 c6 01          	add    $0x1,%r14d
401146:	41 83 fe 06          	cmp    $0x6,%r14d
40114a:	74 05                	je     401151 <phase_6+0x75>
40114c:	44 89 f3             	mov    %r14d,%ebx
40114f:	eb cc                	jmp    40111d <phase_6+0x41>

将第一个输入放入 eax，与 5 比较，如果大于，爆炸。r14 之前初始化为 0 。现在加上 1，与 6 比较，如果相等，跳到 0x401151 结束循环；否则将 r14 移到 ebx 中，跳到 40111d。

1
2
3
4
5
6
7
8
401115:	83 c3 01             	add    $0x1,%ebx
401118:	83 fb 05             	cmp    $0x5,%ebx
40111b:	7f 12                	jg     40112f <phase_6+0x53>
40111d:	48 63 c3             	movslq %ebx,%rax  # 刚刚跳转的位置
401120:	8b 04 84             	mov    (%rsp,%rax,4),%eax
401123:	39 45 00             	cmp    %eax,0x0(%rbp)
401126:	75 ed                	jne    401115 <phase_6+0x39>
401128:	e8 1a 03 00 00       	callq  401447 <explode_bomb>

将 ebx 移入 rax，rsp 中第 rax 个元素放入 eax。第一次来到这里时 ebx 为 1，所以这就是取第二个输入，例如我的是 3。目前 rbp 指向元素就是第一个元素，所以比较第二个元素与第一个是否相等。如果相等，就直接爆炸。否则跳转到 401115，增加 ebx，与 5 比较，如果大于，跳转到 40112f，这会给 rsp 指向的地址加 4，也就是指向下一个元素。

利用调试器，多看几次流程。会发现其本质就是检查输入的 6 个数中第 i 个元素与第 j 个元素是否相等，如果相等就会触发爆炸。然后每次循环后增加 i 索引。同时，也会讲当前第 i 个元素减 1 后与 5 比较，如果大于，也会爆炸。说明当前元素应该小于等于 6 。

因此，我们尝试输入 1 2 3 4 5 6，为 0x401151 打断点，跳转。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
401151:	49 8d 4c 24 18       	lea    0x18(%r12),%rcx
401156:	ba 07 00 00 00       	mov    $0x7,%edx
40115b:	89 d0                	mov    %edx,%eax
40115d:	41 2b 04 24          	sub    (%r12),%eax
401161:	41 89 04 24          	mov    %eax,(%r12)
401165:	49 83 c4 04          	add    $0x4,%r12
401169:	4c 39 e1             	cmp    %r12,%rcx
40116c:	75 ed                	jne    40115b <phase_6+0x7f>
40116e:	be 00 00 00 00       	mov    $0x0,%esi
401173:	eb 1a                	jmp    40118f <phase_6+0xb3>

首先将输入字符串的指针的地址（在栈上）写入 rcx。edx 与 eax 设为 7，将 7 - 第一个输入 写入第一个输入。然后增加 r12 指针指向下一个元素，直到指向尽头（rcx），否则跳转到 0x40115b 重复操作。总之，就是数组每个元素都变成 7-自身，因此现在我的数组变成了 6 5 4 3 2 1。将 esi 变成 0，跳转到 0x40118f 。

1
2
3
4
5
6
40118f:	8b 0c b4             	mov    (%rsp,%rsi,4),%ecx
401192:	b8 01 00 00 00       	mov    $0x1,%eax
401197:	ba d0 32 60 00       	mov    $0x6032d0,%edx
40119c:	83 f9 01             	cmp    $0x1,%ecx
40119f:	7f d4                	jg     401175 <phase_6+0x99>
4011a1:	eb dd                	jmp    401180 <phase_6+0xa4>

将 rsp[rsi] 放入 ecx，eax 写入 1，edx 是一个地址，然后 rsp[rsi] 与 1 比较。如果大于，跳转到 0x401175，否则跳转到 0x401180。尝试打印 edx：

1
2
3
4
pwndbg> x/12xw 0x6032d0
0x6032d0 <node1>:       0x0000027a      0x00000001      0x006032e0       0x00000000
0x6032e0 <node2>:       0x00000353      0x00000002      0x006032f0       0x00000000
0x6032f0 <node3>:       0x00000399      0x00000003      0x00603300       0x00000000

可以看到这是一个类似链表的结构—— node1 中 0x006032e0 指向下一个的地址 0x006032e0，以此类推。我们看看一共有多少：

1
2
3
4
5
6
7
8
pwndbg> x/28xw 0x6032d0
0x6032d0 <node1>:       0x0000027a      0x00000001      0x006032e0       0x00000000
0x6032e0 <node2>:       0x00000353      0x00000002      0x006032f0       0x00000000
0x6032f0 <node3>:       0x00000399      0x00000003      0x00603300       0x00000000
0x603300 <node4>:       0x00000136      0x00000004      0x00603310       0x00000000
0x603310 <node5>:       0x00000249      0x00000005      0x00603320       0x00000000
0x603320 <node6>:       0x0000008a      0x00000006      0x00000000       0x00000000
0x603330 <bomb_id>:     0x000007e6      0x00000000      0x00000000       0x00000000

可以看到刚好有 6 个，并且其中数字部分就是 1 2 3 4 5 6 。尝试更换我们的输入，我们发现这些链表的值与我们的输入是无关的：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Good work!  On to the next...
6 5 4 3 2 1

Breakpoint 1, 0x00000000004010dc in phase_6 ()

pwndbg> c
Continuing.

Breakpoint 2, 0x0000000000401151 in phase_6 ()

pwndbg> c
Continuing.

Breakpoint 3, 0x0000000000401197 in phase_6 ()

pwndbg> x/28xw 0x6032d0
0x6032d0 <node1>:       0x0000027a      0x00000001      0x006032e0       0x00000000
0x6032e0 <node2>:       0x00000353      0x00000002      0x006032f0       0x00000000
0x6032f0 <node3>:       0x00000399      0x00000003      0x00603300       0x00000000
0x603300 <node4>:       0x00000136      0x00000004      0x00603310       0x00000000
0x603310 <node5>:       0x00000249      0x00000005      0x00603320       0x00000000
0x603320 <node6>:       0x0000008a      0x00000006      0x00000000       0x00000000
0x603330 <bomb_id>:     0x000007e6      0x00000000      0x00000000       0x00000000

换回 1 2 3 4 5 6 的输入。我这里 rsp[rsi] 是 5，所以大于，跳转到 0x401175。

1
2
3
4
5
6
7
8
401175:	48 8b 52 08          	mov    0x8(%rdx),%rdx
401179:	83 c0 01             	add    $0x1,%eax
40117c:	39 c8                	cmp    %ecx,%eax
40117e:	75 f5                	jne    401175 <phase_6+0x99>
401180:	48 89 54 f4 20       	mov    %rdx,0x20(%rsp,%rsi,8)
401185:	48 83 c6 01          	add    $0x1,%rsi
401189:	48 83 fe 06          	cmp    $0x6,%rsi
40118d:	74 14                	je     4011a3 <phase_6+0xc7>

这一段不断增加 rdx，也就是寻找下一个链表元素，并且计数到 eax 中。记住 ecx 是 rsp[rsi] ，所以就相当于是取这个链表的第 rsp[rsi] 个元素，rdx 就指向该元素。

然后将链表的第 rsp[rsi] 个元素的地址放入栈中。结束循环，现在的栈如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
00:0000│ rsp         0x7fffffffd9f0 ◂— 0x500000006
01:0008│-00c         0x7fffffffd9f8 ◂— 0x300000004
02:0010│ r13-4 rbp-4 0x7fffffffda00 ◂— 0x100000002
03:0018│ r12         0x7fffffffda08 —▸ 0x603910 (input_strings+400) ◂— '1 2 3 4 5 6'
04:0020│+00c         0x7fffffffda10 —▸ 0x603320 (node6) ◂— 0x60000008a
05:0028│+014         0x7fffffffda18 —▸ 0x603310 (node5) ◂— 0x500000249
06:0030│+01c         0x7fffffffda20 —▸ 0x603300 (node4) ◂— 0x400000136
07:0038│+024         0x7fffffffda28 —▸ 0x6032f0 (node3) ◂— 0x300000399
08:0040│+02c         0x7fffffffda30 —▸ 0x6032e0 (node2) ◂— 0x200000353
09:0048│+034         0x7fffffffda38 —▸ 0x6032d0 (node1) ◂— 0x10000027a
0a:0050│+03c         0x7fffffffda40 ◂— 0

可以看到栈中 00 到 02 存储的是输入数字，已经经过被7减处理了，原本是 1 2 3 4 5 6，现在是 6 5 4 3 2 1。03 存储的是输入字符串的指针。04 到 09 存储的是链表节点的指针，顺序是根据处理后的输入决定的。

例如，输入 2 4 5 3 1 6，处理后变成 5 3 2 4 5 1，内存如下：

1
2
3
4
5
6
04:0020│+00c         0x7fffffffda10 —▸ 0x603310 (node5) ◂— 0x500000249
05:0028│+014         0x7fffffffda18 —▸ 0x6032f0 (node3) ◂— 0x300000399
06:0030│+01c         0x7fffffffda20 —▸ 0x6032e0 (node2) ◂— 0x200000353
07:0038│+024         0x7fffffffda28 —▸ 0x603300 (node4) ◂— 0x400000136
08:0040│+02c         0x7fffffffda30 —▸ 0x603320 (node6) ◂— 0x60000008a
09:0048│+034         0x7fffffffda38 —▸ 0x6032d0 (node1) ◂— 0x10000027a

可以看到这里链表指针的顺序就与我们的输入有关。

接下来又是许多代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
4011a3:	48 8b 5c 24 20       	mov    0x20(%rsp),%rbx
4011a8:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
4011ad:	48 89 43 08          	mov    %rax,0x8(%rbx)
4011b1:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
4011b6:	48 89 50 08          	mov    %rdx,0x8(%rax)
4011ba:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
4011bf:	48 89 42 08          	mov    %rax,0x8(%rdx)
4011c3:	48 8b 54 24 40       	mov    0x40(%rsp),%rdx
4011c8:	48 89 50 08          	mov    %rdx,0x8(%rax)
4011cc:	48 8b 44 24 48       	mov    0x48(%rsp),%rax
4011d1:	48 89 42 08          	mov    %rax,0x8(%rdx)
4011d5:	48 c7 40 08 00 00 00 	movq   $0x0,0x8(%rax)
4011dc:	00 
4011dc:	00 
4011dd:	bd 05 00 00 00       	mov    $0x5,%ebp
4011e2:	eb 09                	jmp    4011ed <phase_6+0x111>

还是先将输入变回 1 2 3 4 5 6，然后会发现这串代码会改变链表的顺序。原始顺序：

1 -> 2 -> 3 -> 4 -> 5 -> 6

在存放顺序是 6 5 4 3 2 1 的情况下，这些操作的结果如下（我省略了其他代码的结果）：

1
2
3
4
5
6
0x4011ad <phase_6+209>    movq   %rax, 8(%rbx)        [node6+8] => 0x603310 (node5) ◂— 0x500000249
0x4011b6 <phase_6+218>    movq   %rdx, 8(%rax)        [node5+8] => 0x603300 (node4) ◂— 0x400000136
0x4011bf <phase_6+227>    movq   %rax, 8(%rdx)        [node4+8] => 0x6032f0 (node3) ◂— 0x300000399
0x4011c8 <phase_6+236>    movq   %rdx, 8(%rax)        [node3+8] => 0x6032e0 (node2) ◂— 0x200000353
0x4011d1 <phase_6+245>    movq   %rax, 8(%rdx)        [node2+8] => 0x6032d0 (node1) ◂— 0x10000027a
0x4011d5 <phase_6+249>    movq   $0, 8(%rax)          [node1+8] => 0

再次打印，发现顺序发生变化：

1
2
3
4
5
6
7
8
pwndbg> x/28xw 0x6032d0
0x6032d0 <node1>:       0x0000027a      0x00000001      0x00000000       0x00000000
0x6032e0 <node2>:       0x00000353      0x00000002      0x006032d0       0x00000000
0x6032f0 <node3>:       0x00000399      0x00000003      0x006032e0       0x00000000
0x603300 <node4>:       0x00000136      0x00000004      0x006032f0       0x00000000
0x603310 <node5>:       0x00000249      0x00000005      0x00603300       0x00000000
0x603320 <node6>:       0x0000008a      0x00000006      0x00603310       0x00000000
0x603330 <bomb_id>:     0x000007e6      0x00000000      0x00000000       0x00000000

6 -> 5 -> 4 -> 3 -> 2 -> 1 -> NaN

所以，该函数的功能就是根据栈中存放的顺序，重新调整链表节点的顺序。例如输入 1 2 3 4 5 6，存放到栈中为 6 5 4 3 2 1 ，于是链表顺序变成 6 5 4 3 2 1。

尝试输入 5 3 1 2 6 4 ，存放到栈中为 2 4 6 5 1 3，链表顺序为 2 4 6 5 1 3。

接着跳转到 0x4011ed，将 rbx 指向的下一个节点地址放入 rax，将该下一个节点的值放入 eax，让 rbx 指向的节点的值与该值比较。如果大于等于，跳转；否则爆炸。

1
2
3
4
5
4011ed:	48 8b 43 08          	mov    0x8(%rbx),%rax
4011f1:	8b 00                	mov    (%rax),%eax
4011f3:	39 03                	cmp    %eax,(%rbx)
4011f5:	7d ed                	jge    4011e4 <phase_6+0x108>
4011f7:	e8 4b 02 00 00       	callq  401447 <explode_bomb>

想要跳出循环，需要在上面满足该条件，也就是 ebp 等于 0。而 ebp 一开始为 5，说明会进行遍历操作。

1
2
3
4011e4:	48 8b 5b 08          	mov    0x8(%rbx),%rbx
4011e8:	83 ed 01             	sub    $0x1,%ebp
4011eb:	74 11                	je     4011fe <phase_6+0x122>

若此处跳转，就可以结束了。所以，我们的目标明确了起来——找到一组 1-6 的顺序，可以调整链表的连接顺序，进而满足最后的每个节点大于另一个节点的条件。

观察原始链表中的大小，可以得到正确的排序：

链表 id	值
3	0x399
2	0x353
1	0x27a
5	0x249
4	0x136
6	0x08a

也就是处理后为 3 2 1 5 4 6，处理前为 4 5 6 2 3 1。第六阶段密码为 4 5 6 2 3 1。

结束了？

翻一下汇编，我们会发现一个神秘的函数 fun7，它会在 secret_phase 中被调用。搜索 secret_phase，发现它隐藏在 phase_defused 中。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
00000000004015d6 <phase_defused>:
4015d6:	48 83 ec 78          	sub    $0x78,%rsp
4015da:	64 48 8b 04 25 28 00 	mov    %fs:0x28,%rax
4015e1:	00 00 
4015e3:	48 89 44 24 68       	mov    %rax,0x68(%rsp)
4015e8:	31 c0                	xor    %eax,%eax
4015ea:	83 3d 7b 21 20 00 06 	cmpl   $0x6,0x20217b(%rip)        # 60376c <num_input_strings>
4015f1:	74 15                	je     401608 <phase_defused+0x32>
4015f3:	48 8b 44 24 68       	mov    0x68(%rsp),%rax
4015f8:	64 48 33 04 25 28 00 	xor    %fs:0x28,%rax
4015ff:	00 00 
401601:	75 67                	jne    40166a <phase_defused+0x94>
401603:	48 83 c4 78          	add    $0x78,%rsp
401607:	c3                   	retq   

发现其中要想进入隐藏阶段，必须满足 cmpl $0x6,0x20217b(%rip)，这就是 num_input_strings 的地址。在 read_line 中，每次读取一行的输入，都会将该变量加一。所以这一行代表着结束第六阶段后才能解锁。

1
2
3
4
5
6
7
8
401608:	4c 8d 44 24 10       	lea    0x10(%rsp),%r8
40160d:	48 8d 4c 24 0c       	lea    0xc(%rsp),%rcx
401612:	48 8d 54 24 08       	lea    0x8(%rsp),%rdx
401617:	be 19 26 40 00       	mov    $0x402619,%esi
40161c:	bf 70 38 60 00       	mov    $0x603870,%edi
401621:	e8 7a f5 ff ff       	callq  400ba0 <__isoc99_sscanf@plt>
401626:	83 f8 03             	cmp    $0x3,%eax
401629:	74 0c                	je     401637 <phase_defused+0x61>

调试可以发现，该 sscanf 的输入是 input_strings+240，也就是第四阶段输入的字符串，例如我的是 13 3。匹配的格式是 %d %d %s，说明需要额外输入一个字符串。

尝试改变第四阶段输入为 13 3 hello，进入 0x401637 ：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
401637:	be 22 26 40 00       	mov    $0x402622,%esi
40163c:	48 8d 7c 24 10       	lea    0x10(%rsp),%rdi
401641:	e8 04 fd ff ff       	callq  40134a <strings_not_equal>
401646:	85 c0                	test   %eax,%eax
401648:	75 e1                	jne    40162b <phase_defused+0x55>
40164a:	bf f8 24 40 00       	mov    $0x4024f8,%edi
40164f:	e8 8c f4 ff ff       	callq  400ae0 <puts@plt>
401654:	bf 20 25 40 00       	mov    $0x402520,%edi
401659:	e8 82 f4 ff ff       	callq  400ae0 <puts@plt>
40165e:	b8 00 00 00 00       	mov    $0x0,%eax
401663:	e8 f7 fb ff ff       	callq  40125f <secret_phase>

发现 esi 为字符串 urxvt，然后调用字符串匹配。因此我们修改输入为 13 3 urxvt，成功进入隐藏阶段。

一开始就要输入，然后调用 strtol 将字符串转换为 long。接着返回值移入 rbx，eax 变成输入的数减一，与 0x3e8 (1000) 比较，如果大于，爆炸。因此我们尝试输入 987。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
00000000040125f <secret_phase>:
40125f:	53                   	push   %rbx
401260:	e8 43 02 00 00       	callq  4014a8 <read_line>
401265:	ba 0a 00 00 00       	mov    $0xa,%edx
40126a:	be 00 00 00 00       	mov    $0x0,%esi
40126f:	48 89 c7             	mov    %rax,%rdi
401272:	e8 09 f9 ff ff       	callq  400b80 <strtol@plt>
401277:	48 89 c3             	mov    %rax,%rbx
40127a:	8d 40 ff             	lea    -0x1(%rax),%eax
40127d:	3d e8 03 00 00       	cmp    $0x3e8,%eax
401282:	77 27                	ja     4012ab <secret_phase+0x4c>
401284:	89 de                	mov    %ebx,%esi
401286:	bf f0 30 60 00       	mov    $0x6030f0,%edi
40128b:	e8 90 ff ff ff       	callq  401220 <fun7>

接下来调用函数 fun7，第一个参数为 0x6030f0，第二个参数为我们输入的数。可以发现我们希望这个函数的返回值是 4，这就是最终目标。

1
2
3
4
5
6
0000000000401220 <fun7>:
401220:	48 85 ff             	test   %rdi,%rdi
401223:	74 34                	je     401259 <fun7+0x39>
...
401259:	b8 ff ff ff ff       	mov    $0xffffffff,%eax
40125e:	c3                   	retq   

首先判断 rdi 不为 0，否则直接返回 -1 。

然后将 rdi 指向的值放入 edx，这里的值是 0x24，判断与我们输入数的关系。

如果输入大于 edx，不跳转，eax 写入 0，跳转到 40124a。将 rdi 后面隔 16 个字节的中数写入 rdi，递归调用
如果输入小于等于 edx，跳转，将 rdi 后面隔 8 个字节中的数写入 rdi，递归调用

打印这些值：

 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
pwndbg> x/64xg $rdi
0x6030f0 <n1>:  0x0000000000000024      0x0000000000603110 <n21>
0x603100 <n1+16>:       0x0000000000603130 <n22>      0x0000000000000000
0x603110 <n21>: 0x0000000000000008      0x0000000000603190 <n31>
0x603120 <n21+16>:      0x0000000000603150 <n32>      0x0000000000000000
0x603130 <n22>: 0x0000000000000032      0x0000000000603170 <n33>
0x603140 <n22+16>:      0x00000000006031b0 <n34>      0x0000000000000000
0x603150 <n32>: 0x0000000000000016      0x0000000000603270 <n43>
0x603160 <n32+16>:      0x0000000000603230 <n44>      0x0000000000000000 
0x603170 <n33>: 0x000000000000002d      0x00000000006031d0 <n45>
0x603180 <n33+16>:      0x0000000000603290 <n46>      0x0000000000000000
0x603190 <n31>: 0x0000000000000006      0x00000000006031f0 <n41>
0x6031a0 <n31+16>:      0x0000000000603250 <n42>      0x0000000000000000
0x6031b0 <n34>: 0x000000000000006b      0x0000000000603210 <n47>
0x6031c0 <n34+16>:      0x00000000006032b0 <n48>     0x0000000000000000
0x6031d0 <n45>: 0x0000000000000028      0x0000000000000000
0x6031e0 <n45+16>:      0x0000000000000000      0x0000000000000000
0x6031f0 <n41>: 0x0000000000000001      0x0000000000000000
0x603200 <n41+16>:      0x0000000000000000      0x0000000000000000
0x603210 <n47>: 0x0000000000000063      0x0000000000000000
0x603220 <n47+16>:      0x0000000000000000      0x0000000000000000
0x603230 <n44>: 0x0000000000000023      0x0000000000000000
0x603240 <n44+16>:      0x0000000000000000      0x0000000000000000
0x603250 <n42>: 0x0000000000000007      0x0000000000000000
0x603260 <n42+16>:      0x0000000000000000      0x0000000000000000
0x603270 <n43>: 0x0000000000000014      0x0000000000000000
0x603280 <n43+16>:      0x0000000000000000      0x0000000000000000
0x603290 <n46>: 0x000000000000002f      0x0000000000000000
0x6032a0 <n46+16>:      0x0000000000000000      0x0000000000000000
0x6032b0 <n48>: 0x00000000000003e9      0x0000000000000000
0x6032c0 <n48+16>:      0x0000000000000000      0x0000000000000000
0x6032d0 <node1>:       0x000000010000027a      0x0000000000603310
0x6032e0 <node2>:       0x0000000200000353      0x00000000006032d0

这些节点的相互引用关系如图：

不断调用，可以发现当 rdi 指向 n48 时，n48 中的值为 3e9 (1001)，必定大于我们的输入。此时结束，跳转到 0x40123d，此时会取 rdi 指向位置的后 8 个字节，放入 rdi（与之前的 16 字节不同！）。不过现在 n48 对应的这个值为 0 。再次递归调用。这时候因为 rdi 参数为 0，所以将 -1 写入 eax，返回。

8 字节情况返回 401246：eax = eax + eax，例如我这里变成了-2
16 字节情况返回 401253：eax = rax + rax + 1，例如我这里有几个状态：
- -2 + -2 + 1 = -3
- -3 + -3 + 1 = -5
- -5 + -5 + 1 = -9
最终在 987 输入的情况下，返回为 -9

于是，当时让我迷惑的事情来了：secret_phase 中希望我们最后得到的返回值是整数 4，这怎么做到呢？

尝试输入 1 调试，发现当输入的数恰好等于叶子结点时，就会停止递归调用。此时会运行 0x40122f ，将 eax 变成 0 。所以，从反向推导，要得到 4 应该是这样的：

0 -> 2 * 0 + 1 = 1 -> 1 * 2 = 2 -> 2 * 2 = 4

反向过程先是一个大于，然后是两个小于等于。正向过程就是先两个小于等于，然后一个大于。

参考图片：

答案为 7 。

总结

这个实验确实量大管饱，我差不多前前后后花了好几天时间才写完。

对于此前没有接触过汇编的我来说，确实有些难度。还好借助了 GDB Dashboard、pwndbg 等强大的调试器，以及部分地方参考了 arthals 的北大 bomblab 博客¹。自然有些细节上还是有差异的，并且该博客没有写 secret phase。

经过这样的折腾，确实感觉自己对汇编的掌握更加深入。也让我想起了很久之前手挫 cs61b 的 gitlet 的快感（）

该指南很多地方都是我做 lab 的时候，边想边写的，所以语句可能不通顺，也不是最适合理解的顺序。该指南只记录了我解题中的一些思考过程。如果能在某个卡点帮到你，有所启发，那么我的目的就达成了。

参考资料

更适合北大宝宝体质的 Bomb Lab 踩坑记. https://arthals.ink/blog/bomb-lab ↩︎ ↩︎ ↩︎
sscanf. cplusplus. https://cplusplus.com/reference/cstdio/sscanf ↩︎