CSAPP Lab2
人要没了。
计算机也太令人头秃了
不过好好做一整天也就弄完了（雾）
博客园的标题链接也太蠢了，同样标题名称就只能通过目录跳转到第一个标题位置，这样的实现也不难吧
https://www.zybuluo.com/SovietPower/note/1786675
参考：
https://zhuanlan.zhihu.com/p/339461318
https://zhuanlan.zhihu.com/p/339575162
结果
phase_3的其它一种答案：
phase_4的其它两种答案：
phase_5的其它两种答案：
Hints
（其实也没什么用）
- 运行前先可在
phase_1...等函数处设断点：break phase_1，以便查看值。也可以break explode_bomb以便在bomb前kill掉。 - layout asm 调出汇编代码窗口；layout reg 调出寄存器窗口。
- 对于一些函数，可根据函数名猜测作用，而不需看它的具体实现（如果想彻底弄懂要看）。
Phase 1
汇编中调用了strings_not_equal函数，可猜出它比较两个字符串是否相等，相等则返回(0)。
从test和je可知，strings_not_equal返回(0)时不会explode_bomb，也就是输入的字符串和要比较的字符串相等时可行。
而要比较的字符串即参数(\%rsi)中的串，也就是(0x402400)位置的串。
通过(gdb) x/s 0x402400或(gdb) print (char*) 0x402400查看该串，然后(gdb) run输入即可。
答案
Border relations with Canada have never been better.
汇编
0000000000400ee0 <phase_1>:
400ee0: 48 83 ec 08 sub $0x8,%rsp ;为调用函数的参数分配8的空间
400ee4: be 00 24 40 00 mov $0x402400,%esi ;%esi=0x402400
400ee9: e8 4a 04 00 00 callq 401338 <strings_not_equal> ;判断%esi处的字符串是否与读入串相等
400eee: 85 c0 test %eax,%eax
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
Phase 2
先看调用的read_six_numbers函数，可以发现主要部分调用了sscanf，并且判断返回值(\%rax)，即读入的数据是个数否(gt 5)，不足(5)则bomb；然后sscanf的第二个参数%esi为地址0x4025c3处的值，x/s 0x4025c3可知sscanf的参数为"%d %d %d %d %d %d"，所以是输入恰好(6)个int。
sscanf是库函数，可知读入的(6)个int分别存在sscanf的第(3sim 8)个参数中，且这些参数分别是通过%rdx,%rcx,%r8,%r9和栈帧传递也就是保存。and它是直接修改地址处的值而不是寄存器的值（废话？）。
而%rdx,%rcx,%r8,%r9观察read_six_numbers中的赋值可知（注意调用read_six_numbers前有%rsi=%rsp），分别表示地址%rsp,%rsp+4,%rsp+8,%rsp+12（这里的%rsp是调用前的栈顶），而第(7,8)个参数在%rsp,%rsp+8处（这里的%rsp是现在的栈顶）也就是%rsp+16,%rsp+20处（之前的栈顶即%rsi）。
所以可知，读入的(6)个数存在了phase_2中从栈顶向下的(6)个地址中。
如下面代码中的注释所示，栈中自顶向下分别为读入的（六个）元素，读入的第一个元素需为(1)，其余的元素需要分别是上一个元素的两倍。
答案
1 2 4 8 16 32。
汇编
0000000000400efc <phase_2>:
400efc: 55 push %rbp
400efd: 53 push %rbx
400efe: 48 83 ec 28 sub $0x28,%rsp
400f02: 48 89 e6 mov %rsp,%rsi
400f05: e8 52 05 00 00 callq 40145c <read_six_numbers>
400f0a: 83 3c 24 01 cmpl $0x1,(%rsp) ;cmp (%rsp):1
400f0e: 74 20 je 400f30 <phase_2+0x34> ;to L2 if((%rsp)==1)->cond. 栈顶元素需为1
400f10: e8 25 05 00 00 callq 40143a <explode_bomb>
400f15: eb 19 jmp 400f30 <phase_2+0x34> ;to L2
400f17: 8b 43 fc mov -0x4(%rbx),%eax ;.L0: %eax=(%rbx-4) %eax为%rbx上面4的位置的值
400f1a: 01 c0 add %eax,%eax ;%eax*=2 %eax数值乘2
400f1c: 39 03 cmp %eax,(%rbx) ;cmp (%rbx):%eax
400f1e: 74 05 je 400f25 <phase_2+0x29> ;to L1 if((%rsp+4)==%eax)->cond. 需满足(%rbx)=2(%rbx-4)
400f20: e8 15 05 00 00 callq 40143a <explode_bomb>
400f25: 48 83 c3 04 add $0x4,%rbx ;.L1: %rbx+=4 %rbx向下4
400f29: 48 39 eb cmp %rbp,%rbx ;cmp %rbx:%rbq 若%rbx没到达%rbp则继续L0
400f2c: 75 e9 jne 400f17 <phase_2+0x1b> ;to L0 if(%rbx!=%rbp)
400f2e: eb 0c jmp 400f3c <phase_2+0x40> ;to L3 ->OK
400f30: 48 8d 5c 24 04 lea 0x4(%rsp),%rbx ;.L2: %rbx=%rsp+4 %rbx为栈顶以下4的位置
400f35: 48 8d 6c 24 18 lea 0x18(%rsp),%rbp ;%rbp=%rsp+24 %rbp为栈顶以下24的位置
400f3a: eb db jmp 400f17 <phase_2+0x1b> ;to L0
400f3c: 48 83 c4 28 add $0x28,%rsp ;.L3:
400f40: 5b pop %rbx
400f41: 5d pop %rbp
400f42: c3 retq
Phase 3
x/s 0x4025cf查看sscanf的格式为"%d %d"，即输入两个整数。然后判断了读入个数是否为(2)不是则bomb。
注意sscanf的参数为：sscanf(%rdi,%rsi,%rdx,%rcx)，前两个为输入的字符串及格式，后两个为字符串转为的读入的数。由phase_3中%rdx=%rsp+8,%rcx=%rsp+12可得读入的两个数的位置。
然后是ja，可知读入的第一个数为非负且小于等于(7)。
然后jmp到了M[8(%rsp+8)+0x402470]位置。（这是一个switch的跳转表）
用x/8xg 0x402470查看从0x402470开始的(8)个(8)字节地址：
0x402470: 0x0000000000400f7c 0x0000000000400fb9
0x402480: 0x0000000000400f83 0x0000000000400f8a
0x402490: 0x0000000000400f91 0x0000000000400f98
0x4024a0: 0x0000000000400f9f 0x0000000000400fa6
可知，若读入的第一个数为(0)，则jmp到400f7c处，判断读入的第二个数是否为0xcf；若读入的第一个数为(1)，则jmp到400fb9处，判断读入的第二个数是否为0x137...
答案
所以答案有(8)种，前两种为0 207、1 311。
（(gdb) print 0xcf可查看0xcf的十进制表示，(gdb) print x 207可查看207的十六进制表示）
汇编
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
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> ;%rax>1 ->cond.
400f65: e8 d0 04 00 00 callq 40143a <explode_bomb>
400f6a: 83 7c 24 08 07 cmpl $0x7,0x8(%rsp) ;(%rsp+8):7
400f6f: 77 3c ja 400fad <phase_3+0x6a> ;(%rsp+8)>7 (unsigned) (%rsp+8)<=7 ->cond.
400f71: 8b 44 24 08 mov 0x8(%rsp),%eax ;%rax=(%rsp+8)
400f75: ff 24 c5 70 24 40 00 jmpq *0x402470(,%rax,8) ;jmp (8%rax+0x402470)
400f7c: b8 cf 00 00 00 mov $0xcf,%eax ;%rax=0xcf
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 ;0xcf:(%rsp+12)
400fc2: 74 05 je 400fc9 <phase_3+0x86> ;0xcf==(%rsp+12) ->cond.
400fc4: e8 71 04 00 00 callq 40143a <explode_bomb>
400fc9: 48 83 c4 18 add $0x18,%rsp
400fcd: c3 retq
Phase 4
同上查看sscanf的格式即0x4025cf处的字符串，为"%d %d"，所以读入两个int，存在了%rsp+8,%rsp+12位置。
首先第一个数要(leq 14)。因为是jbe与(14)比较可知读入的数应非负。
然后进入func4，三个参数为%rdi=(%rsp+8) %rsi=0 %rdx=14。
先看phase_4的后面，要满足func4的返回值为(0)且读入的第二个数为(0)。
再看func4，大体写一下注释可得原始C代码：
int func4(int x,int y,int z)//(input_1,0,14)
{
int t=(z-y)/2+y;
if(t<=x)
{
if(t>=x) return 0;//t==x
return func4(x,t+1,z);
}
else
return func4(x,y,t-1)*2;
}
答案
模拟一下可知，要使返回值为0，合法的输入，即答案有四种：7 0、3 0、1 0、0 0，分别对应t的四种可能取值。
汇编
对func4的注释：
0000000000400fce <func4>:
400fce: 48 83 ec 08 sub $0x8,%rsp ;Augment:(%rdi,%rsi,%rdx) (input_1,0,14)(at the beginning)
400fd2: 89 d0 mov %edx,%eax
400fd4: 29 f0 sub %esi,%eax ;%rax=%rdx-%rsi =14(at the beginning)
400fd6: 89 c1 mov %eax,%ecx
400fd8: c1 e9 1f shr $0x1f,%ecx
400fdb: 01 c8 add %ecx,%eax ;%rax+=%rax>>31(逻辑右移) -> %rax+=0
400fdd: d1 f8 sar %eax ;%rax>>=1 =7(at the beginning)
400fdf: 8d 0c 30 lea (%rax,%rsi,1),%ecx ;%rcx=%rax+%rsi =7(at the beginning)
400fe2: 39 f9 cmp %edi,%ecx ;%rcx:%rdi 7:input_1(at the beginning)
400fe4: 7e 0c jle 400ff2 <func4+0x24> ;if(%rcx<=%rdi) to L0
400fe6: 8d 51 ff lea -0x1(%rcx),%edx ;%rdx=%rcx-1 =6(at the beginning)
400fe9: e8 e0 ff ff ff callq 400fce <func4>
400fee: 01 c0 add %eax,%eax ;%rax*=2
400ff0: eb 15 jmp 401007 <func4+0x39> ;return
400ff2: b8 00 00 00 00 mov $0x0,%eax ;.L0: %rax=0
400ff7: 39 f9 cmp %edi,%ecx ;%rcx:%rdi
400ff9: 7d 0c jge 401007 <func4+0x39> ;if(%rcx>=%rdi) return
400ffb: 8d 71 01 lea 0x1(%rcx),%esi ;%rsi=%rcx+1
400ffe: e8 cb ff ff ff callq 400fce <func4>
401003: 8d 44 00 01 lea 0x1(%rax,%rax,1),%eax ;%rax=2%rax+1
401007: 48 83 c4 08 add $0x8,%rsp
40100b: c3 retq
phase_4：
000000000040100c <phase_4>:
40100c: 48 83 ec 18 sub $0x18,%rsp
401010: 48 8d 4c 24 0c lea 0xc(%rsp),%rcx
401015: 48 8d 54 24 08 lea 0x8(%rsp),%rdx
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> ;sscanf(%rdi,%rsi,%rdx,%rcx)
401029: 83 f8 02 cmp $0x2,%eax
40102c: 75 07 jne 401035 <phase_4+0x29>
40102e: 83 7c 24 08 0e cmpl $0xe,0x8(%rsp) ;cmp (%rsp+8):0xe
401033: 76 05 jbe 40103a <phase_4+0x2e> ;(%rsp+8)<=0xe ->cond.
401035: e8 00 04 00 00 callq 40143a <explode_bomb>
40103a: ba 0e 00 00 00 mov $0xe,%edx
40103f: be 00 00 00 00 mov $0x0,%esi
401044: 8b 7c 24 08 mov 0x8(%rsp),%edi ;%rdi=(%rsp+8) %rsi=0 %rdx=0xe
401048: e8 81 ff ff ff callq 400fce <func4>
40104d: 85 c0 test %eax,%eax ;cmp %eax:0
40104f: 75 07 jne 401058 <phase_4+0x4c> ;%eax!=0 -> %eax=0 ->cond.
401051: 83 7c 24 0c 00 cmpl $0x0,0xc(%rsp) ;(%rsp+12):0
401056: 74 05 je 40105d <phase_4+0x51> ;(%rsp+12)=0 ->cond.
401058: e8 dd 03 00 00 callq 40143a <explode_bomb>
40105d: 48 83 c4 18 add $0x18,%rsp
401061: c3 retq
Phase 5
首先有一个fs[0x28]，这是金丝雀数，这里用M[%rsp+18]来保存，避免phase_5中出现溢出。
金丝雀：
现代操作系统有了防止缓冲区溢出的一系列保护措施，包括 不可执行的栈 和 栈内金丝雀(stack canary)。
金丝雀是通过汇编来实现的。例如，由于GCC的栈保护器选项的原因，金丝雀能被用于任何可能有漏洞的函数上。在初始化一个栈帧时，在栈底设置一个随机的canary值，并确保这个值完好无损。栈帧销毁前测试该值是否“死掉”，即是否被改变。如果这个值被改变，则说明发生了缓冲区溢出（或者bug），程序通过__stack_chk_fail被终止运行，以免漏洞利用成功。由于金丝雀处于栈的关键位置上，它使得栈缓冲区溢出的漏洞挖掘变得非常困难。
有三种基本的绕过canary方法：
- 泄露canary
- 多进程程序的canary爆破
- SSP Leak（利用
__stack_chk_fail函数泄露信息）。
首先调用了string_length，可知输入的字符串长度需为(6)。
然后可以看出40108b到4010ac为一个do while循环，%rax从(0)循环到(5)（设为(i)）。
循环中的%rbx即第一个参数%rbi也就是读入的串(s)，每次取出%rbx+i也就是(s[0],...,s[5])放到%rdx中，然后在%rsp+i+10中存入。
要分析一下这段：
40108b: 0f b6 0c 03 movzbl (%rbx,%rax,1),%ecx ;.L1: %rcx=(%rbx+%rax)
40108f: 88 0c 24 mov %cl,(%rsp) ;(%rsp)=%rcx
401092: 48 8b 14 24 mov (%rsp),%rdx ;%rdx=%rcx
401096: 83 e2 0f and $0xf,%edx ;%rdx&=0xf (取低4位)
401099: 0f b6 92 b0 24 40 00 movzbl 0x4024b0(%rdx),%edx ;%rdx=(%rdx+0x4024b0)
4010a0: 88 54 04 10 mov %dl,0x10(%rsp,%rax,1) ;(%rsp+%rax+10)=%rdx
4010a4: 48 83 c0 01 add $0x1,%rax ;%rax+=1
4010a8: 48 83 f8 06 cmp $0x6,%rax ;%rax:6
4010ac: 75 dd jne 40108b <phase_5+0x29> ;if(%rax!=6) to L1
拿C写一下会更清楚：
{
long rcx=(long)s[i];
char cl=rcx; //只取低8位，高位截断
cl&=0xf; //只取低4位，也就是0~16
long edx=(long)M[cl+0x4024b0];
M[%rsp+i+10]=edx&0xff; //只取低8位
if(++i==6) break;
}
中间做了将s[i]扩充又截断的无用操作，在%rsp+i+10中存入M[(s[i]&0xf)+0x4024b0]。
然后下面将%rsi=0x40245e处的字符串和%rsp+10处的字符串进行比较，需满足两个串相同。
所以我们看一下0x40245e和0x4024b0的两个串是什么：
(gdb) x/s 0x40245e
0x40245e: "flyers"
(gdb) x/s 0x4024b0
0x4024b0 <array.3449>: "maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"
可知(s[i])的取值应为：(9,15,14,5,6,7)。但是ASCII码在(31)以内的为非打印字符不太好输入（不过还是可以^I^O^N^E^F^G，注意^i确实是可见的，就是打一个tab）。注意到只取了低(4)位，所以可以加上一个(2^5=32)，变成(41,47,46,37,38,39)即)/.%&'；或者加上一个2^6=64，变成(73,79,78,69,70,77)即IONEFG。同理还可以加(96)等。当然最初的(9,15,14,5,6,7)也不是唯一解。
答案
其中三种答案为：^I^O^N^E^F^G、)/.%&'、IONEFG。
汇编
000000000401062 <phase_5>:
401062: 53 push %rbx
401063: 48 83 ec 20 sub $0x20,%rsp
401067: 48 89 fb mov %rdi,%rbx ;%rbx=%rdi
40106a: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax ;%rax=fs[0x28]
401071: 00 00
401073: 48 89 44 24 18 mov %rax,0x18(%rsp) ;(%rsp+18)=fs[0x28]
401078: 31 c0 xor %eax,%eax ;%rax=0
40107a: e8 9c 02 00 00 callq 40131b <string_length>
40107f: 83 f8 06 cmp $0x6,%eax ;%rax:6
401082: 74 4e je 4010d2 <phase_5+0x70> ;if(%rax==6) to L2 ->cond.
401084: e8 b1 03 00 00 callq 40143a <explode_bomb>
401089: eb 47 jmp 4010d2 <phase_5+0x70> ;to L2
40108b: 0f b6 0c 03 movzbl (%rbx,%rax,1),%ecx ;.L1: %rcx=(%rbx+%rax)
40108f: 88 0c 24 mov %cl,(%rsp) ;(%rsp)=%rcx
401092: 48 8b 14 24 mov (%rsp),%rdx ;%rdx=%rcx
401096: 83 e2 0f and $0xf,%edx ;%rdx&=0xf (取低4位)
401099: 0f b6 92 b0 24 40 00 movzbl 0x4024b0(%rdx),%edx ;%rdx=(%rdx+0x4024b0)
4010a0: 88 54 04 10 mov %dl,0x10(%rsp,%rax,1) ;(%rsp+%rax+10)=%rdx
4010a4: 48 83 c0 01 add $0x1,%rax ;%rax+=1
4010a8: 48 83 f8 06 cmp $0x6,%rax ;%rax:6
4010ac: 75 dd jne 40108b <phase_5+0x29> ;if(%rax!=6) to L1
4010ae: c6 44 24 16 00 movb $0x0,0x16(%rsp) ;(%rsp+16)=0
4010b3: be 5e 24 40 00 mov $0x40245e,%esi ;%rsi=0x40245e
4010b8: 48 8d 7c 24 10 lea 0x10(%rsp),%rdi ;%rdi=%rsp+10
4010bd: e8 76 02 00 00 callq 401338 <strings_not_equal>
4010c2: 85 c0 test %eax,%eax ;%rax:0
4010c4: 74 13 je 4010d9 <phase_5+0x77> ;if(%rax==0) to L3 ->cond.(strings equal)
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> ;to L3
4010d2: b8 00 00 00 00 mov $0x0,%eax ;.L2: %rax=0
4010d7: eb b2 jmp 40108b <phase_5+0x29>
4010d9: 48 8b 44 24 18 mov 0x18(%rsp),%rax ;.L3: (return)
4010de: 64 48 33 04 25 28 00 xor %fs:0x28,%rax
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
4010f2: 5b pop %rbx
4010f3: c3 retq
Phase 6
由phase_2中对read_six_numbers的分析可知，读入的(6)个数存在了phase_6中从栈顶向下的(6)个地址中，且%rsi,%r13都是栈顶。注意M[rsp+4i]即A[i]。
对汇编写一下注释，然后转化为C代码。
下面C代码中Part 1,2要求读入的(6)个数非负且不大于(6)，且互不相等。
Part 3简单，就是(A[i]=7-A[i])。
Part 4比较复杂，但如果C代码写对并且精简成循环，可以看出，对于每个(A[i])（被(7)减过后），若(A[i]leq 1)，则(A[2i+8]=0x6032d0)；否则rdx=0x6032d0,rdx=*(rdx)会执行(A[i]-1)次，然后(A[2i+8]=rdx)（若下标超过(6)则表示后面的栈帧空间，因为有(\%rsp=A)）。
这个形式我们可以猜到是链表，0x6032d0为表头。然后汇编中直接出现的*(0x6032d0)可以查看一下，以及**(0x6032d0)也看一下：
(gdb) x 0x6032d0
0x6032d0 <node1>: 0x0000014c
(gdb) x 0x6032d8
0x6032d8 <node1+8>: 0x006032e0
(gdb) x 0x6032e0
0x6032e0 <node2>: 0x000000a8
<node1>和<node1+8>我们可以猜到是一个链表结构体的初始地址和next，<node2>则到了链表的下一个节点。它们存储是连续的，可知一个结构体大小为0x6032e0-0x6032d0=16。可以x/24xw 0x6032d0查看下面的(6)个节点（并且可知node6为链表尾部）。其中第三列为next。
(gdb) x/24xw 0x6032d0
0x6032d0 <node1>: 0x0000014c 0x00000001 0x006032e0 0x00000000
0x6032e0 <node2>: 0x000000a8 0x00000002 0x006032f0 0x00000000
0x6032f0 <node3>: 0x0000039c 0x00000003 0x00603300 0x00000000
0x603300 <node4>: 0x000002b3 0x00000004 0x00603310 0x00000000
0x603310 <node5>: 0x000001dd 0x00000005 0x00603320 0x00000000
0x603320 <node6>: 0x000001bb 0x00000006 0x00000000 0x00000000
所以，对每个(A[i])，rdx=0x6032d0，会有(A[i]-1)次rdx=rdx->next，然后(%rsp+8i+32)=A[2i+8]=rdx。因为(A[i])互不相同，所以(%rsp+8i+32)会分别得到(6)个节点的初始地址，分别是node[A[i]]的初始地址（若(A[i]=0)则就是node1）。
Part 5，可看出是在从(%rsp+32)开始重新调整链表的next，且就是按照在(%rsp+8i+32)中的顺序，即(*(%rsp+8i+32))->next=*(%rsp+8(i+1)+32)。所以新的链表顺序为：node[A[0]],node[A[1]],...,node[A[5]]。
Part 6容易些，对链表中的每个节点x，应有x->val >= x->next->val，而链表中的顺序是新的，也就是说重排序后的链表是按val（第一个元素）递减的。
而由链表中的值可知，node大小顺序为：3 4 5 6 1 2，被(7)减后的(A[i])为：3 4 5 6 1/0 2，所以原始的(A[i])为：4 3 2 1 6 5（因为不能为(7)所以少了一种答案）。
等效的C++代码：
void phase_6(input)
{
for(int i=0; i<6; ++i) read(A[i]);
int rsp=*stack;//=*A
//以下A也可以看作栈帧
int r12=0;
int *rsi=A,*r13=A,r14=A,*rbp=A;
int rax=A[0],rcx,rdx;
//Part 1: Check every A[i]<=6
while(1)
{
rbp=r13, rax=*r13;
--rax;
if(!(rax<=5)) bomb();//->cond.
++r12;
if(r12==6) goto L3;
rbx=r12;//i
//Part 2: Check every A[i]!=A[j] (j>i)
do
{
rax=A[rbx];
if(*rbp!=rax) ;//->cond.
else bomb();
rbx++;
}
while(rbx<=5);
r13+=4;
}
//Part 3: A[i]=7-A[i]
L3:
rsi=A[6];
rax=A;
rcx=7;
do
{
rdx=7-*rax;
*rax=rdx;
rax+=4;
}
while(rax!=rsi);
//Part 4:
rsi=0;
while(1)
{
//L8
if(A[rsi/4]<=1) rdx=0x6032d0;
else
{
rax=1;
rdx=0x6032d0;
//L5
do
{
rdx=*(rdx+8);//*0x6032d8
++rax;
}while(rax!=A[rsi/4]);
}
//L7
for(; A[rsi/4]<=1; rdx=0x6032d0/*L6*/)
{
A[rsi/2+8]=rdx;//rsi/2+8=8,10,12,14,16,18
rsi+=4;
if(rsi==24) goto L9;
}
}
//Part 5
L9:
rbx=*(rsp+32);
rax=rsp+40;
rsi=rsp+80;
rcx=rbx;
while(1)
{
rdx=*rax;
*(rcx+8)=rdx;
rax+=8;
if(rax==rsi) break;
rcx=rdx;
}
*(rdx+8)=0;//end->next=0
//Part 6
rbp=5;
do
{
rax=*(rbx+8);
rax=*rax;//rax=rbx->next->val
if(*(rbx)>=rax) ;//->cond.
else bomb();
rbx=*(rbx+8);
rbp--;
}while(rbp!=0);
//return
rsp+=80;
}
答案
4 3 2 1 6 5。
汇编
00000000004010f4 <phase_6>:
4010f4: 41 56 push %r14
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
401100: 49 89 e5 mov %rsp,%r13
401103: 48 89 e6 mov %rsp,%rsi ;%rsi=%r13=%rsp
401106: e8 51 03 00 00 callq 40145c <read_six_numbers>
40110b: 49 89 e6 mov %rsp,%r14 ;%r14=%rsp
40110e: 41 bc 00 00 00 00 mov $0x0,%r12d ;%r12=0
401114: 4c 89 ed mov %r13,%rbp ;.L0: %rbp=%r13
401117: 41 8b 45 00 mov 0x0(%r13),%eax ;%rax=(%r13)
40111b: 83 e8 01 sub $0x1,%eax ;%rax-=1
40111e: 83 f8 05 cmp $0x5,%eax ;cmp %rax:5
401121: 76 05 jbe 401128 <phase_6+0x34> ;if(%rax<=5) to L1 ->cond. (unsigned)
401123: e8 12 03 00 00 callq 40143a <explode_bomb>
401128: 41 83 c4 01 add $0x1,%r12d ;.L1: %r12+=1
40112c: 41 83 fc 06 cmp $0x6,%r12d ;cmp %r12:6
401130: 74 21 je 401153 <phase_6+0x5f> ;if(%r12==6) to L3
401132: 44 89 e3 mov %r12d,%ebx ;%rbx=%r12
401135: 48 63 c3 movslq %ebx,%rax ;.Lp: %rax=(long)%ebx (signed extend)
401138: 8b 04 84 mov (%rsp,%rax,4),%eax ;%rax=(%rsp+4%rax)
40113b: 39 45 00 cmp %eax,0x0(%rbp) ;cmp (%rbp):%rax
40113e: 75 05 jne 401145 <phase_6+0x51> ;if((%rbp)!=%rax) to L2 ->cond.
401140: e8 f5 02 00 00 callq 40143a <explode_bomb>
401145: 83 c3 01 add $0x1,%ebx ;.L2: %rbx+=1
401148: 83 fb 05 cmp $0x5,%ebx ;cmp %rbx:5
40114b: 7e e8 jle 401135 <phase_6+0x41> ;if(%rbx<=5) to Lp
40114d: 49 83 c5 04 add $0x4,%r13 ;%r13+=4
401151: eb c1 jmp 401114 <phase_6+0x20> ;to L0
401153: 48 8d 74 24 18 lea 0x18(%rsp),%rsi ;.L3: %rsi=%rsp+24
401158: 4c 89 f0 mov %r14,%rax ;%rax=%r14
40115b: b9 07 00 00 00 mov $0x7,%ecx ;%rcx=7
401160: 89 ca mov %ecx,%edx ;.L4: %rdx=7
401162: 2b 10 sub (%rax),%edx ;%rdx-=(%rax)
401164: 89 10 mov %edx,(%rax) ;(%rax)=%rdx
401166: 48 83 c0 04 add $0x4,%rax ;%rax+=4
40116a: 48 39 f0 cmp %rsi,%rax ;cmp %rax:%rsi
40116d: 75 f1 jne 401160 <phase_6+0x6c> ;if(%rax!=%rsi) to L4
40116f: be 00 00 00 00 mov $0x0,%esi ;%rsi=0
401174: eb 21 jmp 401197 <phase_6+0xa3> ;to L8
401176: 48 8b 52 08 mov 0x8(%rdx),%rdx ;.L5: rdx=*(rdx+8);
40117a: 83 c0 01 add $0x1,%eax ;%rax+=1
40117d: 39 c8 cmp %ecx,%eax ;cmp %rax:%rcx
40117f: 75 f5 jne 401176 <phase_6+0x82> ;if(%rax!=%rcx) to L5
401181: eb 05 jmp 401188 <phase_6+0x94> ;to L7
401183: ba d0 32 60 00 mov $0x6032d0,%edx ;.L6: %rdx=0x6032d0
401188: 48 89 54 74 20 mov %rdx,0x20(%rsp,%rsi,2) ;.L7: (%rsp+2%rsi+32)=%rdx
40118d: 48 83 c6 04 add $0x4,%rsi ;%rsi+=4
401191: 48 83 fe 18 cmp $0x18,%rsi ;cmp %rsi:24
401195: 74 14 je 4011ab <phase_6+0xb7> ;if(%rsi==24) to L9
401197: 8b 0c 34 mov (%rsp,%rsi,1),%ecx ;.L8: %rcx=(%rsp+%rsi)
40119a: 83 f9 01 cmp $0x1,%ecx ;cmp %rcx:1
40119d: 7e e4 jle 401183 <phase_6+0x8f> ;if(%rcx<=1) to L6
40119f: b8 01 00 00 00 mov $0x1,%eax ;%rax=1
4011a4: ba d0 32 60 00 mov $0x6032d0,%edx ;%rdx=0x6032d0
4011a9: eb cb jmp 401176 <phase_6+0x82> ;to L5
4011ab: 48 8b 5c 24 20 mov 0x20(%rsp),%rbx ;.L9: %rbx=(%rsp+32)
4011b0: 48 8d 44 24 28 lea 0x28(%rsp),%rax ;%rax=%rsp+40
4011b5: 48 8d 74 24 50 lea 0x50(%rsp),%rsi ;%rsi=%rsp+80
4011ba: 48 89 d9 mov %rbx,%rcx ;%rcx=%rbx
4011bd: 48 8b 10 mov (%rax),%rdx ;.L10: %rdx=(%rax)
4011c0: 48 89 51 08 mov %rdx,0x8(%rcx) ;(%rcx+8)=%rdx
4011c4: 48 83 c0 08 add $0x8,%rax ;%rax+=8
4011c8: 48 39 f0 cmp %rsi,%rax ;cmp %rax:%rsi
4011cb: 74 05 je 4011d2 <phase_6+0xde> ;if(%rax==%rsi) to L11
4011cd: 48 89 d1 mov %rdx,%rcx ;%rcx=%rdx
4011d0: eb eb jmp 4011bd <phase_6+0xc9> ;to L10
4011d2: 48 c7 42 08 00 00 00 movq $0x0,0x8(%rdx) ;.L11: (%rdx+8)=0
4011d9: 00
4011da: bd 05 00 00 00 mov $0x5,%ebp ;%rbp=5
4011df: 48 8b 43 08 mov 0x8(%rbx),%rax ;.L12: %rax=(%rbx+8)
4011e3: 8b 00 mov (%rax),%eax ;%rax=(%rax)
4011e5: 39 03 cmp %eax,(%rbx) ;cmp (%rbx):%rax
4011e7: 7d 05 jge 4011ee <phase_6+0xfa> ;if((%rbx)>=%rax) to L13 ->cond.
4011e9: e8 4c 02 00 00 callq 40143a <explode_bomb>
4011ee: 48 8b 5b 08 mov 0x8(%rbx),%rbx ;.L13: %rbx=(%rbx+8)
4011f2: 83 ed 01 sub $0x1,%ebp ;%rbp-=1
4011f5: 75 e8 jne 4011df <phase_6+0xeb> ;if(%rbp!=0) to L12
4011f7: 48 83 c4 50 add $0x50,%rsp ;%rsp+=80
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
Secret Phase
可以看到phase_6下面还有一个secret_phase。
开始先read_line，应该为读入一行字符串，然后调用库函数int strtol(const char *nptr,char **endptr,int base)。由参数的初始化可知，将读入的串转为了10进制数，存到%rax,%rbx中。
然后有，(\%rax-1leq 0x3e8=1000)，即转成的的应数小于等于(1001)。
然后调用fun7(0x6030f0,x)。由下可知，fun7的返回值需为(2)，才不会bomb并输出0x402438处的字符串Wow! You've defused the secret stage!。
再看fun7，写一下汇编的注释可得等效C代码：
int fun7(int *x,int y)//(rdi,rsi)=(0x6030f0,x)
{
if(!x) return -1;
if(*x<=y)
{
if(*x==y) return 0;
return 2*fun7(*(x+10),y)+1;//*x<y
}
else return 2*fun7(*(x+8),y);//*x>y
}
因为(*x==y)时返回(0)，(*xlt y)若返回一个奇数，可知若要返回值为(2)，则第一次调用fun7有(*xgt y)，第二次调用fun7有(*xlt y)，第三次调用fun7有(*x==y)并结束递归。
重新记(x=0x6030f0)，记(y)为输入的数，有：(*xgt y 且 *(*(x+8))lt y 且 *(*(x+8)+16)==y)。
查看一下这个地方的值：
(gdb) x/160 0x6030f0
0x6030f0 <n1>: 0x00000024 0x00000000 0x00603110 0x00000000
0x603100 <n1+16>: 0x00603130 0x00000000 0x00000000 0x00000000
0x603110 <n21>: 0x00000008 0x00000000 0x00603190 0x00000000
0x603120 <n21+16>: 0x00603150 0x00000000 0x00000000 0x00000000
0x603130 <n22>: 0x00000032 0x00000000 0x00603170 0x00000000
0x603140 <n22+16>: 0x006031b0 0x00000000 0x00000000 0x00000000
0x603150 <n32>: 0x00000016 0x00000000 0x00603270 0x00000000
0x603160 <n32+16>: 0x00603230 0x00000000 0x00000000 0x00000000
0x603170 <n33>: 0x0000002d 0x00000000 0x006031d0 0x00000000
0x603180 <n33+16>: 0x00603290 0x00000000 0x00000000 0x00000000
0x603190 <n31>: 0x00000006 0x00000000 0x006031f0 0x00000000
0x6031a0 <n31+16>: 0x00603250 0x00000000 0x00000000 0x00000000
0x6031b0 <n34>: 0x0000006b 0x00000000 0x00603210 0x00000000
0x6031c0 <n34+16>: 0x006032b0 0x00000000 0x00000000 0x00000000
0x6031d0 <n45>: 0x00000028 0x00000000 0x00000000 0x00000000
0x6031e0 <n45+16>: 0x00000000 0x00000000 0x00000000 0x00000000
0x6031f0 <n41>: 0x00000001 0x00000000 0x00000000 0x00000000
0x603200 <n41+16>: 0x00000000 0x00000000 0x00000000 0x00000000
0x603210 <n47>: 0x00000063 0x00000000 0x00000000 0x00000000
0x603220 <n47+16>: 0x00000000 0x00000000 0x00000000 0x00000000
0x603230 <n44>: 0x00000023 0x00000000 0x00000000 0x00000000
0x603240 <n44+16>: 0x00000000 0x00000000 0x00000000 0x00000000
0x603250 <n42>: 0x00000007 0x00000000 0x00000000 0x00000000
0x603260 <n42+16>: 0x00000000 0x00000000 0x00000000 0x00000000
0x603270 <n43>: 0x00000014 0x00000000 0x00000000 0x00000000
0x603280 <n43+16>: 0x00000000 0x00000000 0x00000000 0x00000000
0x603290 <n46>: 0x0000002f 0x00000000 0x00000000 0x00000000
0x6032a0 <n46+16>: 0x00000000 0x00000000 0x00000000 0x00000000
0x6032b0 <n48>: 0x000003e9 0x00000000 0x00000000 0x00000000
0x6032c0 <n48+16>: 0x00000000 0x00000000 0x00000000 0x00000000
0x6032d0 <node1>: 0x0000014c 0x00000001 0x006032e0 0x00000000
0x6032e0 <node2>: 0x000000a8 0x00000002 0x006032f0 0x00000000
0x6032f0 <node3>: 0x0000039c 0x00000003 0x00603300 0x00000000
0x603300 <node4>: 0x000002b3 0x00000004 0x00603310 0x00000000
0x603310 <node5>: 0x000001dd 0x00000005 0x00603320 0x00000000
0x603320 <node6>: 0x000001bb 0x00000006 0x00000000 0x00000000
0x603330: 0x00000000 0x00000000 0x00000000 0x00000000
0x603340 <host_table>: 0x00402629 0x00000000 0x00402643 0x00000000
0x603350 <host_table+16>: 0x0040265d 0x00000000 0x00000000 0x00000000
0x603360 <host_table+32>: 0x00000000 0x00000000 0x00000000 0x00000000
可知这个位置存的就是(2sim 31)行的(15)个node，每个node有(8)个值，并且第(3)、第(5)个值指向其它节点的地址。不难猜出是一棵二叉树，(3,5)的值分别为左右儿子。我们可以画出这棵树，如果标上节点的值（第一个）就能看出还是一棵二叉搜索树（值就不标了）：
(*x)为(x)存的值，(*(x+8))即(x)的左儿子，(*(x+16))即(x)的右儿子。
所以由(*xgt y 且 *(*(x+8))lt y 且 *(*(x+8)+16)==y)，得(x.valgt y 且 lson[x].vallt y 且 rson[lson[x]].val==y)。所以(y)为n32的值(0x16=22)。
所以要输入的字符串为(22)。
还有一个问题是，如何进入secret_phase/输入这个答案。
搜索调用secret_phase的函数，可以发现在phase_defused中调用了这个函数。
break secret_phase，在输入phase_1的答案后调试这个函数。
分析phase_defused怎样进入secret_phase。对于sscanf依旧查看一下两个参数：
(gdb) x/s 0x603870
0x603870 <input_strings+240>: ""
(gdb) x/s 0x402619
0x402619: "%d %d %s"
后面判断了返回值为(3)，所以要输入两个int和一个字符串（且分别存在rsp+8,rsp+12,rsp+16位置）。
然后是strings_not_equal，要满足rsp+16位置的串，也就是输入串，和0x402622位置的串，也就是DrEvil相等。然后就可以puts Curses, you've found the secret phase!和But finding it and solving it are quite different...，并进入secret_phase了。
（再之前还有个if(*(rip+0x202181)!=6) goto ...，即程序执行到某个位置才可能向下，先不管）
那么什么时候输入呢？前边sscanf的第一个参数是固定输入源，而此时是空字符串，所以肯定是之后改过。而汇编中并没有出现过0x603870的位置。
可以直接在0x4015fa处调用sscanf这里break，然后再看0x603870的值（这样还能解决什么时候有*(rip+0x202181)==6的判断）。
(gdb) break *0x4015fa
Breakpoint 4 at 0x4015fa
(gdb) info break
Num Type Disp Enb Address What
4 breakpoint keep y 0x00000000004015fa <phase_defused+54>
(gdb) r
Starting program: /home/gxb/桌面/Lab2/bomb/bomb
Welcome to my fiendish little bomb. You have 6 phases with
which to blow yourself up. Have a nice day!
Border relations with Canada have never been better.
Phase 1 defused. How about the next one?
1 2 4 8 16 32
That's number 2. Keep going!
1 311
Halfway there!
0 0
So you got that one. Try this one.
IONEFG
Good work! On to the next...
4 3 2 1 6 5
Breakpoint 4, 0x00000000004015fa in phase_defused ()
(gdb) x/s 0x603870
0x603870 <input_strings+240>: "0 0"
这样我们可以看到，0x603870的串即输入源，就算phase_4中输入的答案（可以输入phase_4的其它答案确认）。
因为都是用sscanf格式化读入，所以输入phase_4的答案时，输入0 0 DrEvil（或7 0 DrEvil...）不影响答案，且在phase_6结束时可进入secret_phase。
进入后输入上面的答案就好了。
答案
phase_4中输入phase_4的答案加字符串DrEvil，可在最后进入secret_phase。
secret_phase的答案为(22)。
secret_phase汇编
0000000000401242 <secret_phase>:
401242: 53 push %rbx
401243: e8 56 02 00 00 callq 40149e <read_line>
401248: ba 0a 00 00 00 mov $0xa,%edx ;rdx=10
40124d: be 00 00 00 00 mov $0x0,%esi ;rsi=0
401252: 48 89 c7 mov %rax,%rdi ;rdi=rax
401255: e8 76 f9 ff ff callq 400bd0 <strtol@plt>
40125a: 48 89 c3 mov %rax,%rbx ;rbx=rax
40125d: 8d 40 ff lea -0x1(%rax),%eax ;rax--
401260: 3d e8 03 00 00 cmp $0x3e8,%eax ;cmp rax:0x3e8(1000)
401265: 76 05 jbe 40126c <secret_phase+0x2a> ;if(rax<=0x3e8) to L1 ->cond.
401267: e8 ce 01 00 00 callq 40143a <explode_bomb>
40126c: 89 de mov %ebx,%esi ;.L1: rsi=rbx
40126e: bf f0 30 60 00 mov $0x6030f0,%edi ;rdi=0x6030f0
401273: e8 8c ff ff ff callq 401204 <fun7>
401278: 83 f8 02 cmp $0x2,%eax ;cmp rax:2
40127b: 74 05 je 401282 <secret_phase+0x40> ;if(rax==2) to L2 ->cond.
40127d: e8 b8 01 00 00 callq 40143a <explode_bomb>
401282: bf 38 24 40 00 mov $0x402438,%edi ;.L2: rdi=0x402438
401287: e8 84 f8 ff ff callq 400b10 <puts@plt>
40128c: e8 33 03 00 00 callq 4015c4 <phase_defused>
401291: 5b pop %rbx
401292: c3 retq
401293: 90 nop
401294: 90 nop
401295: 90 nop
401296: 90 nop
401297: 90 nop
401298: 90 nop
401299: 90 nop
40129a: 90 nop
40129b: 90 nop
40129c: 90 nop
40129d: 90 nop
40129e: 90 nop
40129f: 90 nop
fun7汇编
0000000000401204 <fun7>:
401204: 48 83 ec 08 sub $0x8,%rsp ;rsp-=8
401208: 48 85 ff test %rdi,%rdi ;cmp rdi:0
40120b: 74 2b je 401238 <fun7+0x34> ;if(rdi==0) to L2
40120d: 8b 17 mov (%rdi),%edx ;rdx=(rdi)
40120f: 39 f2 cmp %esi,%edx ;cmp rdx:rsi
401211: 7e 0d jle 401220 <fun7+0x1c> ;if(rdx<=rsi) to L1
401213: 48 8b 7f 08 mov 0x8(%rdi),%rdi ;rdi=(rdi+8)
401217: e8 e8 ff ff ff callq 401204 <fun7> ;fun7(rdi,rsi)
40121c: 01 c0 add %eax,%eax ;rax*=2
40121e: eb 1d jmp 40123d <fun7+0x39> ;to L3
401220: b8 00 00 00 00 mov $0x0,%eax ;.L1: rax=0
401225: 39 f2 cmp %esi,%edx ;cmp rdx:rsi
401227: 74 14 je 40123d <fun7+0x39> ;if(rdx==rsi) to L3
401229: 48 8b 7f 10 mov 0x10(%rdi),%rdi ;rdi=(rdi+16)
40122d: e8 d2 ff ff ff callq 401204 <fun7> ;fun7(rdi,rsi)
401232: 8d 44 00 01 lea 0x1(%rax,%rax,1),%eax ;rax=2*rax+1
401236: eb 05 jmp 40123d <fun7+0x39> ;to L3
401238: b8 ff ff ff ff mov $0xffffffff,%eax ;.L2: rax=-1
40123d: 48 83 c4 08 add $0x8,%rsp ;.L3: rsp+=8
401241: c3 retq
phase_defused汇编
00000000004015c4 <phase_defused>:
4015c4: 48 83 ec 78 sub $0x78,%rsp
4015c8: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax
4015cf: 00 00
4015d1: 48 89 44 24 68 mov %rax,0x68(%rsp)
4015d6: 31 c0 xor %eax,%eax
4015d8: 83 3d 81 21 20 00 06 cmpl $0x6,0x202181(%rip) # 603760 <num_input_strings>
4015df: 75 5e jne 40163f <phase_defused+0x7b> ;if((rip+0x202181)!=6) to L2
4015e1: 4c 8d 44 24 10 lea 0x10(%rsp),%r8 ;r8=rsp+16
4015e6: 48 8d 4c 24 0c lea 0xc(%rsp),%rcx ;rcx=rsp+12
4015eb: 48 8d 54 24 08 lea 0x8(%rsp),%rdx ;rdx=rsp+8
4015f0: be 19 26 40 00 mov $0x402619,%esi ;rsi=0x402619
4015f5: bf 70 38 60 00 mov $0x603870,%edi ;rdi=0x603870
4015fa: e8 f1 f5 ff ff callq 400bf0 <__isoc99_sscanf@plt> ;sscanf(rdi,rsi,rdx,rcx,r8,...)
4015ff: 83 f8 03 cmp $0x3,%eax ;cmp rax:3
401602: 75 31 jne 401635 <phase_defused+0x71> ;if(rax!=3) to L1 rax==3->cond.
401604: be 22 26 40 00 mov $0x402622,%esi ;rsi=0x402622
401609: 48 8d 7c 24 10 lea 0x10(%rsp),%rdi ;rdi=rsp+16
40160e: e8 25 fd ff ff callq 401338 <strings_not_equal>
401613: 85 c0 test %eax,%eax ;cmp rax:0
401615: 75 1e jne 401635 <phase_defused+0x71> ;if(rax!=0) to L1 rax==0(strings equal)->cond.
401617: bf f8 24 40 00 mov $0x4024f8,%edi
40161c: e8 ef f4 ff ff callq 400b10 <puts@plt>
401621: bf 20 25 40 00 mov $0x402520,%edi
401626: e8 e5 f4 ff ff callq 400b10 <puts@plt>
40162b: b8 00 00 00 00 mov $0x0,%eax
401630: e8 0d fc ff ff callq 401242 <secret_phase>
401635: bf 58 25 40 00 mov $0x402558,%edi ;.L1:
40163a: e8 d1 f4 ff ff callq 400b10 <puts@plt>
40163f: 48 8b 44 24 68 mov 0x68(%rsp),%rax ;.L2:
401644: 64 48 33 04 25 28 00 xor %fs:0x28,%rax
40164b: 00 00
40164d: 74 05 je 401654 <phase_defused+0x90>
40164f: e8 dc f4 ff ff callq 400b30 <__stack_chk_fail@plt>
401654: 48 83 c4 78 add $0x78,%rsp
401658: c3 retq
401659: 90 nop
40165a: 90 nop
40165b: 90 nop
40165c: 90 nop
40165d: 90 nop
40165e: 90 nop
40165f: 90 nop
总结
刚开始做phase_2的时候感觉特别难（主要是read_six_numbers中的参数问题和gdb），但花了两个多小时看懂之后，再整理一下gdb命令（主要是(gdb) x/<n/f/u> <address>），后面感觉就简单了，就是很绕/花时间。
基本做法就，先对每条汇编简单写一下表达式，再一步步转成goto的C代码，再转成for/while/do while循环或是递归，再理解意思。
这样做phase_3,phase_4,phase_5都比较简单。
phase_6的汇编很长要注意别写错寄存器名以及是不是指针，C代码要写对。
phase_6和secret_phase要用(gdb) x查看对应位置的若干个值，并判断出相应结构（链表或树...）。知道结构后再模拟C代码就ok。
做完(7)个phase才算真会了教材第三章。