CSAPP: Bomb Lab

Posted on Edited on In

熟悉GDB

Preparation

建议在实验大致看一下lab相关的pdf。使用man手册来查看库函数，callq … <_exit@plt>类型为C的库函数。注意商用的architecture是以字节为单位编址寻址。

参考CS61C所了解到的Tool, 做足了准备工作。安装CGDB, 相比较于GDB的tui在调试lab时显示不会出现乱码的情况。从ubuntu中apt-get下载到的版本较低，一些功能不适用。参考CGDB官网下载最新版本的CGDB, 简单浏览了一下CGDB官方手册, 以及对应CGDB在~/.cgdb/cgdbrc文件中做了如下的配置足以满足调试需求:

1
2
3
:set disasm
:set hls
:set syn=style

另外gdb相关内容再推荐这两本书籍
Debugs Hacks和Debugging with GDB。

需要用chmod命令修改一下bomb二进制文件的可执行权限

接下来可以愉快地开始bomb lab了~

运行cgdb且在对应phase打上断点后可以用一个放入输入信息的文本文件标准输入重定向到传递给主函数的参数中，这样就可以避免卡死在读取输入的systemcall上。更多关于重定向

1
(gdb)run < in

Phase_1

1
2
3
4
5
6
7
8
9
0000000000400ee0 <phase_1>:
  400ee0:	48 83 ec 08          	sub    $0x8,%rsp                   # 开辟栈帧保存返回地址和写在文件中的字符串函数参数edi
  400ee4:	be 00 24 40 00       	mov    $0x402400,%esi
  400ee9:	e8 4a 04 00 00       	callq  401338 <strings_not_equal>  # edi接着传给strings_not_equal
  400eee:	85 c0                	test   %eax,%eax                   # 若字符串相等，即函数返回0，则Defuse炸弹
  400ef0:	74 05                	je     400ef7 <phase_1+0x17>
  400ef2:	e8 43 05 00 00       	callq  40143a <explode_bomb>
  400ef7:	48 83 c4 08          	add    $0x8,%rsp                   # 函数调用结束栈顶指针复原
  400efb:	c3                   	retq

分析一下strings_not_equal，判断两个字符串是否相等。

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
35
36
37
38
39
0000000000401338 <strings_not_equal>:
  401338:	41 54                	push   %r12                             # callee save
  40133a:	55                   	push   %rbp
  40133b:	53                   	push   %rbx
  40133c:	48 89 fb             	mov    %rdi,%rbx                        # 将两个参数放入local中, 防止后续操作被覆盖
  40133f:	48 89 f5             	mov    %rsi,%rbp
  401342:	e8 d4 ff ff ff       	callq  40131b <string_length>           # 第一个参数rdi传递给函数返回第一个字符串长度到eax中
  401347:	41 89 c4             	mov    %eax,%r12d
  40134a:	48 89 ef             	mov    %rbp,%rdi                        # 将当前函数的第二个参数传递给rdi
  40134d:	e8 c9 ff ff ff       	callq  40131b <string_length>           # 返回第二个字符串参数的长度
  401352:	ba 01 00 00 00       	mov    $0x1,%edx
  401357:	41 39 c4             	cmp    %eax,%r12d                       # 两个参数的长度比较
  40135a:	75 3f                	jne    40139b <strings_not_equal+0x63>  # 字符串不相等则到转到restore并返回edx中保存的1
  40135c:	0f b6 03             	movzbl (%rbx),%eax                      # 零拓展避免eax高位出现杂乱数据, 字符为8bit，将其高位清0
  40135f:	84 c0                	test   %al,%al                          # 检测第一个参数是否遍历到terminator, 这种形式让al与0比较
  401361:	74 25                	je     401388 <strings_not_equal+0x50>
  401363:	3a 45 00             	cmp    0x0(%rbp),%al
  401366:	74 0a                	je     401372 <strings_not_equal+0x3a>
  401368:	eb 25                	jmp    40138f <strings_not_equal+0x57>
  40136a:	3a 45 00             	cmp    0x0(%rbp),%al
  40136d:	0f 1f 00             	nopl   (%rax)
  401370:	75 24                	jne    401396 <strings_not_equal+0x5e>
  401372:	48 83 c3 01          	add    $0x1,%rbx                        # 移动读取两个字符串参数中的字符
  401376:	48 83 c5 01          	add    $0x1,%rbp
  40137a:	0f b6 03             	movzbl (%rbx),%eax
  40137d:	84 c0                	test   %al,%al                          # 检测第二个参数是否遍历到terminator
  40137f:	75 e9                	jne    40136a <strings_not_equal+0x32>
  401381:	ba 00 00 00 00       	mov    $0x0,%edx                        # 两参数字符串相等，返回0
  401386:	eb 13                	jmp    40139b <strings_not_equal+0x63>
  401388:	ba 00 00 00 00       	mov    $0x0,%edx
  40138d:	eb 0c                	jmp    40139b <strings_not_equal+0x63>
  40138f:	ba 01 00 00 00       	mov    $0x1,%edx
  401394:	eb 05                	jmp    40139b <strings_not_equal+0x63>
  401396:	ba 01 00 00 00       	mov    $0x1,%edx
  40139b:	89 d0                	mov    %edx,%eax                        # eax作为返回值
  40139d:	5b                   	pop    %rbx                             # restore
  40139e:	5d                   	pop    %rbp
  40139f:	41 5c                	pop    %r12
  4013a1:	c3                   	retq

观察phase_1函数，需要进入函数string_not_equal，并通过该函数的返回结果来决定是否引爆炸弹。进入该函数后，可以发现在函数中比较的是rdi和rsi两个字符串参数。rdi是标准输入中输入的字符串。string_length的返回值保存在寄存器eax中为两字符串的长度。长度不相等即表示字符串肯定不相等，则返回寄存器edx中的1。初步可以判断phase_1要求比较的两个字符串要相等才能defuse。再仔细观察phase_1函数中test %eax, %eax测试寄存器eax非0则跳转到bomb。因此要想不爆炸必须得保证存在于($rdi), ($rsi)中的两个字符串相等，即strings_not_equal的返回值为0。

用x/s查看对应memory中地址单元的的字符串内容, 使标准输入参数rdi等于下述字符串即可defuse。

1
2
(gdb) x/s 0x402400
0x402400:       "Border relations with Canada have never been better."

经分析答案为:

1
Border relations with Canada have never been better.

Phase_2

x86ISA规定，当参数超过6个的时候就会使用栈来保存参数。print (char*) 0x4025c3打印由地址0x4025c3起始的字符串，显示的结果可以发现字符串为"%d %d %d %d %d %d"格式串。

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
0000000000400efc <phase_2>:
  400efc:	55                   	push   %rbp                       # callee save
  400efd:	53                   	push   %rbx
  400efe:	48 83 ec 28          	sub    $0x28,%rsp                 # rdi为标准输入字符串的地址
  400f02:	48 89 e6             	mov    %rsp,%rsi                  # rsp作为函数read_six_numbers的第二个参数, caller save
  400f05:	e8 52 05 00 00       	callq  40145c <read_six_numbers>  # 函数读取六个数字到栈空间上。
  400f0a:	83 3c 24 01          	cmpl   $0x1,(%rsp)                # 取第一个数字
  400f0e:	74 20                	je     400f30 <phase_2+0x34>
  400f10:	e8 25 05 00 00       	callq  40143a <explode_bomb>
  400f15:	eb 19                	jmp    400f30 <phase_2+0x34>
  400f17:	8b 43 fc             	mov    -0x4(%rbx),%eax           # 取接下来的数字
  400f1a:	01 c0                	add    %eax,%eax                 # double
  400f1c:	39 03                	cmp    %eax,(%rbx)
  400f1e:	74 05                	je     400f25 <phase_2+0x29>     # 下一个参数的值需要为上一个参数值的两倍才能确保不发生爆炸
  400f20:	e8 15 05 00 00       	callq  40143a <explode_bomb>
  400f25:	48 83 c3 04          	add    $0x4,%rbx
  400f29:	48 39 eb             	cmp    %rbp,%rbx                 # 若读到第六个数字，则将局部变量所使用的寄存器restore到原来的值, pop栈指针复原到调用前的位置, 否则继续loop
  400f2c:	75 e9                	jne    400f17 <phase_2+0x1b>
  400f2e:	eb 0c                	jmp    400f3c <phase_2+0x40>
  400f30:	48 8d 5c 24 04       	lea    0x4(%rsp),%rbx
  400f35:	48 8d 6c 24 18       	lea    0x18(%rsp),%rbp           # rsp~rsp-0x10这部分为函数的返回地址和局部变量以及所用的栈空间
  400f3a:	eb db                	jmp    400f17 <phase_2+0x1b>
  400f3c:	48 83 c4 28          	add    $0x28,%rsp
  400f40:	5b                   	pop    %rbx
  400f41:	5d                   	pop    %rbp
  400f42:	c3                   	retq

read_six_numbers中会调用C库函数sscanf，man手册中返回值的描述，返回输入数字匹配的个数。

On success, these functions return the number of input items success‐
fully matched and assigned; this can be fewer than provided for, or
even zero, in the event of an early matching failure.

注意x86栈帧由低地址到高地址，先是返回地址，再到局部变量，再到save register。第1个参数在栈帧低地址 立即数为32bit, 按字节变址寻址, 函数参数为caller save。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
000000000040145c <read_six_numbers>:
  40145c:	48 83 ec 18          	sub    $0x18,%rsp                    # 开辟栈帧, rdi为第一个参数
  401460:	48 89 f2             	mov    %rsi,%rdx                     # 第3个参数
  401463:	48 8d 4e 04          	lea    0x4(%rsi),%rcx                # 第4个参数
  401467:	48 8d 46 14          	lea    0x14(%rsi),%rax               # 第8个参数
  40146b:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
  401470:	48 8d 46 10          	lea    0x10(%rsi),%rax               # 第7个参数
  401474:	48 89 04 24          	mov    %rax,(%rsp)
  401478:	4c 8d 4e 0c          	lea    0xc(%rsi),%r9                 # 第6个参数
  40147c:	4c 8d 46 08          	lea    0x8(%rsi),%r8                 # 第5个参数
  401480:	be c3 25 40 00       	mov    $0x4025c3,%esi                # 第2个参数，格式串
  401485:	b8 00 00 00 00       	mov    $0x0,%eax                     # 初始化返回值
  40148a:	e8 61 f7 ff ff       	callq  400bf0 <__isoc99_sscanf@plt>
  40148f:	83 f8 05             	cmp    $0x5,%eax                     # 要求输入数字要大于5个才不会引爆炸弹
  401492:	7f 05                	jg     401499 <read_six_numbers+0x3d>
  401494:	e8 a1 ff ff ff       	callq  40143a <explode_bomb>
  401499:	48 83 c4 18          	add    $0x18,%rsp
  40149d:	c3                   	retq

查看0x4025c3地址单元中的内容为格式串

1
2
(gdb) x/s 0x4025c3
0x4025c3:       "%d %d %d %d %d %d"

经分析答案为:

1
1 2 4 8 16 32

Phase_3

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
35
36
37
0000000000400f43 <phase_3>:
  400f43:	48 83 ec 18          	sub    $0x18,%rsp
  400f47:	48 8d 4c 24 0c       	lea    0xc(%rsp),%rcx
  400f4c:	48 8d 54 24 08       	lea    0x8(%rsp),%rdx
  400f51:	be cf 25 40 00       	mov    $0x4025cf,%esi         # "%d %d"需要两个无符号十进制数, 少于2个会引爆炸弹
  400f56:	b8 00 00 00 00       	mov    $0x0,%eax
  400f5b:	e8 90 fc ff ff       	callq  400bf0 <__isoc99_sscanf@plt>
  400f60:	83 f8 01             	cmp    $0x1,%eax
  400f63:	7f 05                	jg     400f6a <phase_3+0x27>
  400f65:	e8 d0 04 00 00       	callq  40143a <explode_bomb>
  400f6a:	83 7c 24 08 07       	cmpl   $0x7,0x8(%rsp)         # 第一个标准输入中的参数大于7则会跳转发生爆炸
  400f6f:	77 3c                	ja     400fad <phase_3+0x6a>
  400f71:	8b 44 24 08          	mov    0x8(%rsp),%eax
  400f75:	ff 24 c5 70 24 40 00 	jmpq   *0x402470(,%rax,8)     # indirect jump, 跳转到0x402470+rax*8的存储单元中存放的地址即0x400f83
  400f7c:	b8 cf 00 00 00       	mov    $0xcf,%eax
  400f81:	eb 3b                	jmp    400fbe <phase_3+0x7b>
  400f83:	b8 c3 02 00 00       	mov    $0x2c3,%eax
  400f88:	eb 34                	jmp    400fbe <phase_3+0x7b>
  400f8a:	b8 00 01 00 00       	mov    $0x100,%eax
  400f8f:	eb 2d                	jmp    400fbe <phase_3+0x7b>
  400f91:	b8 85 01 00 00       	mov    $0x185,%eax
  400f96:	eb 26                	jmp    400fbe <phase_3+0x7b>
  400f98:	b8 ce 00 00 00       	mov    $0xce,%eax
  400f9d:	eb 1f                	jmp    400fbe <phase_3+0x7b>
  400f9f:	b8 aa 02 00 00       	mov    $0x2aa,%eax
  400fa4:	eb 18                	jmp    400fbe <phase_3+0x7b>
  400fa6:	b8 47 01 00 00       	mov    $0x147,%eax
  400fab:	eb 11                	jmp    400fbe <phase_3+0x7b>
  400fad:	e8 88 04 00 00       	callq  40143a <explode_bomb>
  400fb2:	b8 00 00 00 00       	mov    $0x0,%eax
  400fb7:	eb 05                	jmp    400fbe <phase_3+0x7b>
  400fb9:	b8 37 01 00 00       	mov    $0x137,%eax
  400fbe:	3b 44 24 0c          	cmp    0xc(%rsp),%eax         # 第二个参数和覆写后的eax相等才能跳过bomb
  400fc2:	74 05                	je     400fc9 <phase_3+0x86>
  400fc4:	e8 71 04 00 00       	callq  40143a <explode_bomb>
  400fc9:	48 83 c4 18          	add    $0x18,%rsp
  400fcd:	c3                   	retq

jmp *Operand为Indirect Jump, 跳转的target存放在寄存器中或者内存中。查看内存中存放的target:
Image
再结合上面的汇编代码，可以得出8个答案:

1
2
3
4
5
6
7
8
0 207
1 311
2 707
3 256
4 389
5 206
6 682
7 327

Phase_4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
000000000040100c <phase_4>:
  40100c:	48 83 ec 18          	sub    $0x18,%rsp
  401010:	48 8d 4c 24 0c       	lea    0xc(%rsp),%rcx  # callee save
  401015:	48 8d 54 24 08       	lea    0x8(%rsp),%rdx  # callee save
  40101a:	be cf 25 40 00       	mov    $0x4025cf,%esi  # 格式串, 需要两个十进制数, 因此可以断定标准输入为两个数
  40101f:	b8 00 00 00 00       	mov    $0x0,%eax
  401024:	e8 c7 fb ff ff       	callq  400bf0 <__isoc99_sscanf@plt>
  401029:	83 f8 02             	cmp    $0x2,%eax             # 需要在标准输入中传递两个参数(sscanf系统调用的返回值)，否则会引爆炸弹
  40102c:	75 07                	jne    401035 <phase_4+0x29>
  40102e:	83 7c 24 08 0e       	cmpl   $0xe,0x8(%rsp)        # 第一个参数若大于14，则bomb
  401033:	76 05                	jbe    40103a <phase_4+0x2e>
  401035:	e8 00 04 00 00       	callq  40143a <explode_bomb>
  40103a:	ba 0e 00 00 00       	mov    $0xe,%edx             # 14作为func4的第三个参数
  40103f:	be 00 00 00 00       	mov    $0x0,%esi             # 0作为func4的第二个参数
  401044:	8b 7c 24 08          	mov    0x8(%rsp),%edi        # phase_4的第一个参数作为func4的第一个参数
  401048:	e8 81 ff ff ff       	callq  400fce <func4>
  40104d:	85 c0                	test   %eax,%eax             # 若返回值eax不为0则bomb
  40104f:	75 07                	jne    401058 <phase_4+0x4c>
  401051:	83 7c 24 0c 00       	cmpl   $0x0,0xc(%rsp)        # 若第二个标准输入参数不为0则bomb, 因此可以确定第二个标准输入参数必须为0
  401056:	74 05                	je     40105d <phase_4+0x51>
  401058:	e8 dd 03 00 00       	callq  40143a <explode_bomb>
  40105d:	48 83 c4 18          	add    $0x18,%rsp
  401061:	c3                   	retq   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
0000000000400fce <func4>:
  400fce:	48 83 ec 08          	sub    $0x8,%rsp              # stack frame
  400fd2:	89 d0                	mov    %edx,%eax
  400fd4:	29 f0                	sub    %esi,%eax
  400fd6:	89 c1                	mov    %eax,%ecx
  400fd8:	c1 e9 1f             	shr    $0x1f,%ecx             # 取符号位
  400fdb:	01 c8                	add    %ecx,%eax
  400fdd:	d1 f8                	sar    %eax                   # eax  除以2向下取整, 最后的答案与之相关
  400fdf:	8d 0c 30             	lea    (%rax,%rsi,1),%ecx
  400fe2:	39 f9                	cmp    %edi,%ecx              # 直到ecx小于等于第一个标准输入的参数edi, 则跳转到0x400ff2
  400fe4:	7e 0c                	jle    400ff2 <func4+0x24>
  400fe6:	8d 51 ff             	lea    -0x1(%rcx),%edx
  400fe9:	e8 e0 ff ff ff       	callq  400fce <func4>
  400fee:	01 c0                	add    %eax,%eax
  400ff0:	eb 15                	jmp    401007 <func4+0x39>
  400ff2:	b8 00 00 00 00       	mov    $0x0,%eax              # 此处很关键，要保证不bomb必须返回0
  400ff7:	39 f9                	cmp    %edi,%ecx  
  400ff9:	7d 0c                	jge    401007 <func4+0x39>    # 跳转到此处之后，要想此处跳转，条件必须是ecx==edi
  400ffb:	8d 71 01             	lea    0x1(%rcx),%esi
  400ffe:	e8 cb ff ff ff       	callq  400fce <func4>
  401003:	8d 44 00 01          	lea    0x1(%rax,%rax,1),%eax  # 执行到这一步无论rax的值为什么都不可能为0
  401007:	48 83 c4 08          	add    $0x8,%rsp
  40100b:	c3                   	retq

经过调试分析, 可得出四个答案, 除此之外可能还有其他答案就不另行分析了：

1
2
3
4
7 0
3 0
1 0
0 0

Phase_5

ASCII转化为十六进制时(因为所取数字的下标大于10)需要查看ASCII编码表。关于stack canary的解释可以参考文章和文章使用rax寄存器作为间接传递的原因是因为x86中不存在内存到内存的mov指令。

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
35
36
37
38
39
40
41
0000000000401062 <phase_5>:
  401062:	53                   	push   %rbx                     # callee save
  401063:	48 83 ec 20          	sub    $0x20,%rsp
  401067:	48 89 fb             	mov    %rdi,%rbx                # 标准输入字符串参数
  40106a:	64 48 8b 04 25 28 00 	mov    %fs:0x28,%rax            # stack-canary
  401071:	00 00 
  401073:	48 89 44 24 18       	mov    %rax,0x18(%rsp)
  401078:	31 c0                	xor    %eax,%eax                # 对eax清0
  40107a:	e8 9c 02 00 00       	callq  40131b <string_length>   # rdi作为参数, 返回rdi字符串的长度
  40107f:	83 f8 06             	cmp    $0x6,%eax                # 如果标准输入的字符串不为6个字符，则bomb
  401082:	74 4e                	je     4010d2 <phase_5+0x70>
  401084:	e8 b1 03 00 00       	callq  40143a <explode_bomb>
  401089:	eb 47                	jmp    4010d2 <phase_5+0x70>
  40108b:	0f b6 0c 03          	movzbl (%rbx,%rax,1),%ecx       # 取字符
  40108f:	88 0c 24             	mov    %cl,(%rsp)               # 取最低字节大小的字符
  401092:	48 8b 14 24          	mov    (%rsp),%rdx
  401096:	83 e2 0f             	and    $0xf,%edx                # 将ASCII转化为对应的十六进制数作为索引
  401099:	0f b6 92 b0 24 40 00 	movzbl 0x4024b0(%rdx),%edx      # 0x4024b0中存放了一串字符, 通过分析可以发现rdx作为取字符串字符的索引
  4010a0:	88 54 04 10          	mov    %dl,0x10(%rsp,%rax,1)    # 将取到的字符存入由rsp+0x10处的开始向高地址方向增长
  4010a4:	48 83 c0 01          	add    $0x1,%rax                # 减少迭代次数
  4010a8:	48 83 f8 06          	cmp    $0x6,%rax                # 迭代6次
  4010ac:	75 dd                	jne    40108b <phase_5+0x29>
  4010ae:	c6 44 24 16 00       	movb   $0x0,0x16(%rsp)          # 在字符串后添加termimator, 作为字符串比较结束的标志
  4010b3:	be 5e 24 40 00       	mov    $0x40245e,%esi           # "flyers"
  4010b8:	48 8d 7c 24 10       	lea    0x10(%rsp),%rdi
  4010bd:	e8 76 02 00 00       	callq  401338 <strings_not_equal>    # 比较存放在0x40245e中的字符串和标准输入转化后的字符串
  4010c2:	85 c0                	test   %eax,%eax
  4010c4:	74 13                	je     4010d9 <phase_5+0x77>
  4010c6:	e8 6f 03 00 00       	callq  40143a <explode_bomb>
  4010cb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  4010d0:	eb 07                	jmp    4010d9 <phase_5+0x77>
  4010d2:	b8 00 00 00 00       	mov    $0x0,%eax
  4010d7:	eb b2                	jmp    40108b <phase_5+0x29>
  4010d9:	48 8b 44 24 18       	mov    0x18(%rsp),%rax  
  4010de:	64 48 33 04 25 28 00 	xor    %fs:0x28,%rax                 # 若stack canary未被破坏则跳过__stack_chk_fail
  4010e5:	00 00 
  4010e7:	74 05                	je     4010ee <phase_5+0x8c>
  4010e9:	e8 42 fa ff ff       	callq  400b30 <__stack_chk_fail@plt>
  4010ee:	48 83 c4 20          	add    $0x20,%rsp                    # restore
  4010f2:	5b                   	pop    %rbx
  4010f3:	c3                   	retq 
1
2
(gdb) x/s 0x4024b0
0x4024b0 <array.3449>:  "maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"
1
2
(gdb) x/s 0x40245e
0x40245e:       "flyers"

输入正确结果后内存中存放的内容：

1
2
(gdb) x/s $rsp+0x10
0x7fffffffdfc0: "flyers"

最后的答案为:

1
9?>567

Phase_6

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
00000000004010f4 <phase_6>:
  4010f4:	41 56                	push   %r14                         # callee save
  4010f6:	41 55                	push   %r13
  4010f8:	41 54                	push   %r12
  4010fa:	55                   	push   %rbp
  4010fb:	53                   	push   %rbx
  4010fc:	48 83 ec 50          	sub    $0x50,%rsp                   # stack frame
  401100:	49 89 e5             	mov    %rsp,%r13
  401103:	48 89 e6             	mov    %rsp,%rsi
  401106:	e8 51 03 00 00       	callq  40145c <read_six_numbers>
  40110b:	49 89 e6             	mov    %rsp,%r14
  40110e:	41 bc 00 00 00 00    	mov    $0x0,%r12d                   # 迭代器
  401114:	4c 89 ed             	mov    %r13,%rbp
  401117:	41 8b 45 00          	mov    0x0(%r13),%eax               # r13中存放的数字放入eax中
  40111b:	83 e8 01             	sub    $0x1,%eax                    # eax大于5则bomb, 一轮loop之后观察可以推出六个数字的范围是1到6, 且相邻数字不能相同
  40111e:	83 f8 05             	cmp    $0x5,%eax
  401121:	76 05                	jbe    401128 <phase_6+0x34>        # be无符号比较, 若参数数减去1小于0则会bomb，进而可以推出参数不能小于1
  401123:	e8 12 03 00 00       	callq  40143a <explode_bomb>
  401128:	41 83 c4 01          	add    $0x1,%r12d 
  40112c:	41 83 fc 06          	cmp    $0x6,%r12d
  401130:	74 21                	je     401153 <phase_6+0x5f>        # 外循环迭代次数到6次则终止loop
  401132:	44 89 e3             	mov    %r12d,%ebx
  401135:	48 63 c3             	movslq %ebx,%rax
  401138:	8b 04 84             	mov    (%rsp,%rax,4),%eax           # 取下一个数字放入eax
  40113b:	39 45 00             	cmp    %eax,0x0(%rbp)               # 若当前数字与下一个数字相等，则bomb
  40113e:	75 05                	jne    401145 <phase_6+0x51>
  401140:	e8 f5 02 00 00       	callq  40143a <explode_bomb>        # 六个数字出现连续相同的数字则发生bomb
  401145:	83 c3 01             	add    $0x1,%ebx
  401148:	83 fb 05             	cmp    $0x5,%ebx                    # 若没遍历完六个数字中剩余的数字则loop
  40114b:	7e e8                	jle    401135 <phase_6+0x41>
  40114d:	49 83 c5 04          	add    $0x4,%r13                    # 取下一个数字
  401151:	eb c1                	jmp    401114 <phase_6+0x20>
  401153:	48 8d 74 24 18       	lea    0x18(%rsp),%rsi              # null terminator, 第六个参数后面的字
  401158:	4c 89 f0             	mov    %r14,%rax
  40115b:	b9 07 00 00 00       	mov    $0x7,%ecx
  401160:	89 ca                	mov    %ecx,%edx
  401162:	2b 10                	sub    (%rax),%edx                  # 将7减去当前位置的参数数字的结果放回到当前位置, 即将六个数字结果都改为7-当前数字
  401164:	89 10                	mov    %edx,(%rax)
  401166:	48 83 c0 04          	add    $0x4,%rax                    # 往下移动一个数字的位置
  40116a:	48 39 f0             	cmp    %rsi,%rax                    # 若未移动到最后一个数字结束则继续loop
  40116d:	75 f1                	jne    401160 <phase_6+0x6c>
  40116f:	be 00 00 00 00       	mov    $0x0,%esi
  401174:	eb 21                	jmp    401197 <phase_6+0xa3>        
  401176:	48 8b 52 08          	mov    0x8(%rdx),%rdx               # 将当前rdx中存放地址的下一个8字节中存放地址的内容存放到rdx中, 即遍历链表，取到对应的节点
  40117a:	83 c0 01             	add    $0x1,%eax
  40117d:	39 c8                	cmp    %ecx,%eax                    
  40117f:	75 f5                	jne    401176 <phase_6+0x82>        # 若eax与做出变更的数字不相等则继续loop, 实际上变更的数字为node号
  401181:	eb 05                	jmp    401188 <phase_6+0x94>
  401183:	ba d0 32 60 00       	mov    $0x6032d0,%edx               # 0x6032d0为node1
  401188:	48 89 54 74 20       	mov    %rdx,0x20(%rsp,%rsi,2)       # 将当前node的地址存放到$rsp+0x20开始，以8字节为间隔的连续地址
  40118d:	48 83 c6 04          	add    $0x4,%rsi                    # 移动到下一个变更后的参数
  401191:	48 83 fe 18          	cmp    $0x18,%rsi                   
  401195:	74 14                	je     4011ab <phase_6+0xb7>        # 遍历完六个参数则跳转到target, 即取对应参数变更后的node号的地址放入内存中
  401197:	8b 0c 34             	mov    (%rsp,%rsi,1),%ecx           # 按顺序取做出变更后的参数
  40119a:	83 f9 01             	cmp    $0x1,%ecx                    # 若当前数字小于等于1则，直接存放当前节点不需要遍历链表
  40119d:	7e e4                	jle    401183 <phase_6+0x8f>
  40119f:	b8 01 00 00 00       	mov    $0x1,%eax
  4011a4:	ba d0 32 60 00       	mov    $0x6032d0,%edx               # 传递的是地址, gdb调试可以发现存在一个链表, 比如0x6032d8存储单元中存放着的是0x6032e0
  4011a9:	eb cb                	jmp    401176 <phase_6+0x82>
  4011ab:	48 8b 5c 24 20       	mov    0x20(%rsp),%rbx              # node6的地址
  4011b0:	48 8d 44 24 28       	lea    0x28(%rsp),%rax               
  4011b5:	48 8d 74 24 50       	lea    0x50(%rsp),%rsi               
  4011ba:	48 89 d9             	mov    %rbx,%rcx                    
  4011bd:	48 8b 10             	mov    (%rax),%rdx                  # node5的地址, 即指针
  4011c0:	48 89 51 08          	mov    %rdx,0x8(%rcx)               # 将node5的指针作为node6的next
  4011c4:	48 83 c0 08          	add    $0x8,%rax                    # node4指针的地址
  4011c8:	48 39 f0             	cmp    %rsi,%rax                    # 看一下是否遍历结束
  4011cb:	74 05                	je     4011d2 <phase_6+0xde>        
  4011cd:	48 89 d1             	mov    %rdx,%rcx
  4011d0:	eb eb                	jmp    4011bd <phase_6+0xc9>        # loop
  4011d2:	48 c7 42 08 00 00 00 	movq   $0x0,0x8(%rdx)               # 将尾节点node1的next指向空
  4011d9:	00                                                        # 应该是涉及pipeline优化的bubble 
  4011da:	bd 05 00 00 00       	mov    $0x5,%ebp                    # 迭代器
  4011df:	48 8b 43 08          	mov    0x8(%rbx),%rax               # 将下一个node的地址赋给rax
  4011e3:	8b 00                	mov    (%rax),%eax                  # 取下一个node的值(即低32bit)赋给eax
  4011e5:	39 03                	cmp    %eax,(%rbx)                  # 当前node的值若小于(<)下一个node的值，则bomb，到这里可以猜测要将链表要按node值来构造递减序列
  4011e7:	7d 05                	jge    4011ee <phase_6+0xfa>        # 初步可以判断需要用7-当前参数值来取node号
  4011e9:	e8 4c 02 00 00       	callq  40143a <explode_bomb>
  4011ee:	48 8b 5b 08          	mov    0x8(%rbx),%rbx               # 将当前node的next赋给rbx, 即移动指针遍历到下一个node
  4011f2:	83 ed 01             	sub    $0x1,%ebp                    # 减少迭代次数
  4011f5:	75 e8                	jne    4011df <phase_6+0xeb>
  4011f7:	48 83 c4 50          	add    $0x50,%rsp
  4011fb:	5b                   	pop    %rbx
  4011fc:	5d                   	pop    %rbp
  4011fd:	41 5c                	pop    %r12
  4011ff:	41 5d                	pop    %r13
  401201:	41 5e                	pop    %r14
  401203:	c3                   	retq

查看0x6032d0处地址内容(gdb中的字默认为4字节， 而x86的字默认为2字节), 可以猜测出第一个8字节中高4字节为node号，低4字节为值域，第二个8字节为next指针域，下述示例传递的参数为1 2 3 4 5 6:

1
2
3
4
5
6
7
(gdb) x/12xg 0x6032d0
0x6032d0 <node1>:       0x000000010000014c      0x0000000000000000
0x6032e0 <node2>:       0x00000002000000a8      0x00000000006032d0
0x6032f0 <node3>:       0x000000030000039c      0x00000000006032e0
0x603300 <node4>:       0x00000004000002b3      0x00000000006032f0
0x603310 <node5>:       0x00000005000001dd      0x0000000000603300
0x603320 <node6>:       0x00000006000001bb      0x0000000000603310

6个node的值, 再将其由大到小排序：

1
2
3
4
5
6
7
node1: 0x14c
node2: 0x0a8
node3: 0x39c
node4: 0x2b3
node5: 0x1dd
node6: 0x1bb
node3 > node4 > node5 > node6 > node1 > node2

由7-nodeNumber得到答案为:

1
4 3 2 1 6 5

Defused