CSAPP的Lab学习——BombLab

编程入门行业动态更新时间:2024-10-25 21:31:08

CSAPP的Lab学习——BombLab

文章目录

前言
一、一号炸弹（小试牛刀）
二、二号炸弹（六重循环）
三、三号炸弹（不同输入，不同答案）
四、四号炸弹（判断语句的实现）
五、五号炸弹（跳转，循环与计算）
六、六号炸弹（炸弹？原子弹！）
七、隐藏彩蛋（是不是有什么被忽略了？）
总结

前言

一个本硕双非的小菜鸡，备战24年秋招。刚刚看完CSAPP，真是一本神书啊！遂尝试将它的Lab实现，并记录期间心酸历程。
代码下载

官方网站：CSAPP官方网站

以下是官方文档翻译：
邪恶的博士。邪恶已经在我们的课堂机器上植入了大量的“二元炸弹”。二元炸弹是一个由一系列相位组成的程序。每个阶段都希望您在stdin上键入一个特定的字符串。如果你输入了正确的字符串，那么这个阶段就会被拆除，炸弹就会继续前进到下一个阶段。否则，炸弹就会通过打印“BOOM！！！”
而爆炸然后终止。当每个阶段都被拆除时，炸弹就被拆除。
有太多的炸弹需要我们处理，所以我们给每个学生一枚炸弹来拆除。你的任务，你别无选择，只能接受，是在到期日前拆除你的炸弹。祝你好运，欢迎加入拆弹小组！

注:

/*当使用一个参数<file>运行时，炸弹读取<file>
*直到EOF，然后切换到标准输入。因此，正如你
*拆除每个阶段，你可以将其拆除字符串添加到<和
避免重新输入。 /

/调用炸弹时，命令行参数不能超过一个。 /

/做各种秘密的事情，使炸弹更难拆除。 /

一共六枚炸弹。

一、一号炸弹（小试牛刀）

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");

感谢各位前辈大佬的探索，前人栽树后人乘凉，至少对于我这个四级刚过的菜鸡是真的不友好，看大佬解释和翻译勉勉强强知道到底是啥意思要做啥了，就光看到炸弹爆炸了。。。

简单解释一下就是你要通过反汇编的方式“破解”他的代码，通过输入六串正确的字符串。

第一个炸弹估计就是让你热热身，知道一下这玩意是怎么弄的。
首先使用指令：objdump -d bomb > bomb.asm把可执行文件进行反汇编。
用gdb先把一号炸弹找到，此处是代码

  400e32:	e8 67 06 00 00       	callq  40149e <read_line>400e37:	48 89 c7             	mov    %rax,%rdi400e3a:	e8 a1 00 00 00       	callq  400ee0 <phase_1>400e3f:	e8 80 07 00 00       	callq  4015c4 <phase_defused>

能大概看出来，先调用了read_line读取输入的字符串，然后放到rdi中作为一号参数（此处寄存器规定可以见CSAPP第120页），再调用phase_1函数，让我们继续往下看。

0000000000400ee0 <phase_1>:400ee0:	48 83 ec 08          	sub    $0x8,%rsp400ee4:	be 00 24 40 00       	mov    $0x402400,%esi400ee9:	e8 4a 04 00 00       	callq  401338 <strings_not_equal>400eee:	85 c0                	test   %eax,%eax400ef0:	74 05                	je     400ef7 <phase_1+0x17>400ef2:	e8 43 05 00 00       	callq  40143a <explode_bomb>400ef7:	48 83 c4 08          	add    $0x8,%rsp400efb:	c3                   	retq

这里是phase_1内部，可见它是将0x402400位置的作为二号参数传入并调用strings_not_equal函数，剩下的就是比较了。

那么我们可以大胆推测答案就在0x402400中，此时就看gdb的本事了。
推荐Yannick大佬写的gdb使用方式：Introduction to CSAPP（十九）
有很方便的gdb参数等。
总之：

Border relations with Canada have never been better.就是我们一号炸弹的答案了。

ps:与加拿大的边境关系从未像现在这样好。这是啥彩蛋么？

二、二号炸弹（六重循环）

   /* The second phase is harder.  No one will ever figure out* how to defuse this... */input = read_line();phase_2(input);phase_defused();printf("That's number 2.  Keep going!\n");

简单解释一下就是你要通过反汇编的方式“破解”他的代码，通过输入六串正确的字符串。

  400e4e:	e8 4b 06 00 00       	callq  40149e <read_line>400e53:	48 89 c7             	mov    %rax,%rdi400e56:	e8 a1 00 00 00       	callq  400efc <phase_2>

能大概看出来，先调用了read_line读取输入的字符串，然后放到rdi中作为一号参数（此处寄存器规定可以见CSAPP第120页），再调用phase_2函数，让我们继续往下看。

0000000000400efc <phase_2>:400efc:	55                   	push   %rbp400efd:	53                   	push   %rbx400efe:	48 83 ec 28          	sub    $0x28,%rsp400f02:	48 89 e6             	mov    %rsp,%rsi400f05:	e8 52 05 00 00       	callq  40145c <read_six_numbers>

难度正式开始，首先仍然是经典的申请空间，先把rsp存入rsi中（也就是第二个参数），再调用read_six_numbers函数。

000000000040145c <read_six_numbers>:40145c:	48 83 ec 18          	sub    $0x18,%rsp401460:	48 89 f2             	mov    %rsi,%rdx401463:	48 8d 4e 04          	lea    0x4(%rsi),%rcx401467:	48 8d 46 14          	lea    0x14(%rsi),%rax40146b:	48 89 44 24 08       	mov    %rax,0x8(%rsp)401470:	48 8d 46 10          	lea    0x10(%rsi),%rax401474:	48 89 04 24          	mov    %rax,(%rsp)401478:	4c 8d 4e 0c          	lea    0xc(%rsi),%r940147c:	4c 8d 46 08          	lea    0x8(%rsi),%r8401480:	be c3 25 40 00       	mov    $0x4025c3,%esi401485:	b8 00 00 00 00       	mov    $0x0,%eax40148a:	e8 61 f7 ff ff       	callq  400bf0 <__isoc99_sscanf@plt>40148f:	83 f8 05             	cmp    $0x5,%eax401492:	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,%rsp40149d:	c3                   	retq

先来简单看下这个函数，简单来说就是把上一步中第二个参数的地址保存到rdx（第三个参数中），然后栈加4放入rcx（第四个参数），加20放入rax（返回值也是栈顶，第八个参数），然后调整了一下位置到rsp+8处，继续加10放入rsp中，然后同样的8加c放入r9，加8放入r8。。。说实话这段我研究一晚上也不太解释清楚为啥要这么跳着做，查了很多资料也没有见到解释清楚这块的，倒是不影响之后的输入就是了。

ps:猜测大概与sscanf的返回值有关

总之回头看phase_2函数：

0000000000400efc <phase_2>: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),%eax400f1a:	01 c0                	add    %eax,%eax400f1c:	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,%rbx400f29:	48 39 eb             	cmp    %rbp,%rbx400f2c:	75 e9                	jne    400f17 <phase_2+0x1b>400f2e:	eb 0c                	jmp    400f3c <phase_2+0x40>400f30:	48 8d 5c 24 04       	lea    0x4(%rsp),%rbx400f35:	48 8d 6c 24 18       	lea    0x18(%rsp),%rbp400f3a:	eb db                	jmp    400f17 <phase_2+0x1b>400f3c:	48 83 c4 28          	add    $0x28,%rsp400f40:	5b                   	pop    %rbx400f41:	5d                   	pop    %rbp400f42:	c3                   	retq

通俗易懂，rsp与1比较，行就继续，然后add本身（其实就是*2），循环六次。

那么答案就很明显了：1 2 4 8 16 32

三、三号炸弹（不同输入，不同答案）

    /* I guess this is too easy so far.  Some more complex code will* confuse people. */input = read_line();phase_3(input);phase_defused();printf("Halfway there!\n");

继续冲刺，开始第三炸弹的破解。
先看这些

0000000000400f43 <phase_3>:400f43:	48 83 ec 18          	sub    $0x18,%rsp400f47:	48 8d 4c 24 0c       	lea    0xc(%rsp),%rcx400f4c:	48 8d 54 24 08       	lea    0x8(%rsp),%rdx400f51:	be cf 25 40 00       	mov    $0x4025cf,%esi400f56:	b8 00 00 00 00       	mov    $0x0,%eax400f5b:	e8 90 fc ff ff       	callq  400bf0 <__isoc99_sscanf@plt>400f60:	83 f8 01             	cmp    $0x1,%eax400f63:	7f 05                	jg     400f6a <phase_3+0x27>400f65:	e8 d0 04 00 00       	callq  40143a <explode_bomb>

传入三四参数，然后注意看，cmp $0x1,%eax是输入值的是否大于1的比较，否则爆炸。跳转400f6a，即：

  400f6a:	83 7c 24 08 07       	cmpl   $0x7,0x8(%rsp)400f6f:	77 3c                	ja     400fad <phase_3+0x6a>400fad:	e8 88 04 00 00       	callq  40143a <explode_bomb>

第一个输入值大于8就爆炸。那么来看看这块究竟是个啥（此处参考网上各位大佬攻略）

这就是第一个输入0-7的话对应的第二个值，回到phase_3中看看

  400f7c:	b8 cf 00 00 00       	mov    $0xcf,%eax400fb9:	b8 37 01 00 00       	mov    $0x137,%eax400f83:	b8 c3 02 00 00       	mov    $0x2c3,%eax400f8a:	b8 00 01 00 00       	mov    $0x100,%eax400f91:	b8 85 01 00 00       	mov    $0x185,%eax400f98:	b8 ce 00 00 00       	mov    $0xce,%eax400f9f:	b8 aa 02 00 00       	mov    $0x2aa,%eax400fa6:	b8 47 01 00 00       	mov    $0x147,%eax

转换到十进制：

第一个参数	第二个参数（二进制形式）	第二个参数（十进制形式）
0	0xcf	207
1	0x137	311
2	0x2c3	707
3	0x100	256
4	0x185	389
5	0xce	206
6	0x2aa	682
7	0x147	327

任选一组输入：

四、四号炸弹（判断语句的实现）

    /* Oh yeah?  Well, how good is your math?  Try on this saucy problem! */input = read_line();phase_4(input);phase_defused();printf("So you got that one.  Try this one.\n");

phase_4主力就是func4，这个弄懂了就通了。

000000000040100c <phase_4>:40100c:	48 83 ec 18          	sub    $0x18,%rsp401010:	48 8d 4c 24 0c       	lea    0xc(%rsp),%rcx401015:	48 8d 54 24 08       	lea    0x8(%rsp),%rdx40101a:	be cf 25 40 00       	mov    $0x4025cf,%esi40101f:	b8 00 00 00 00       	mov    $0x0,%eax401024:	e8 c7 fb ff ff       	callq  400bf0 <__isoc99_sscanf@plt>401029:	83 f8 02             	cmp    $0x2,%eax40102c:	75 07                	jne    401035 <phase_4+0x29>40102e:	83 7c 24 08 0e       	cmpl   $0xe,0x8(%rsp)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,%edx40103f:	be 00 00 00 00       	mov    $0x0,%esi401044:	8b 7c 24 08          	mov    0x8(%rsp),%edi401048:	e8 81 ff ff ff       	callq  400fce <func4>40104d:	85 c0                	test   %eax,%eax40104f:	75 07                	jne    401058 <phase_4+0x4c>401051:	83 7c 24 0c 00       	cmpl   $0x0,0xc(%rsp)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,%rsp401061:	c3                   	retq

其实核心就几句话

  401029:	83 f8 02             	cmp    $0x2,%eax40102c:	75 07                	jne    401035 <phase_4+0x29>40102e:	83 7c 24 08 0e       	cmpl   $0xe,0x8(%rsp)401033:	76 05                	jbe    40103a <phase_4+0x2e>401035:	e8 00 04 00 00       	callq  40143a <explode_bomb>

传两个值，第一个与14比较，然后调用func4

func4居然真得整个翻译过来，之前三个其实都没有完整翻译，看起来应该是考验整个的情况了。
看其他大佬们都写了一个伪代码解释，我也仿写解释一下吧

//起步没啥好说的，就正常写就行。
// 一顿操作，开空间什么的，唯一注意一下shr    $0x1f,%ecx进行了逻辑右移31位并加上了四参（ecx）
0000000000400fce <func4>:400fce:	48 83 ec 08          	sub    $0x8,%rsp400fd2:	89 d0                	mov    %edx,%eax400fd4:	29 f0                	sub    %esi,%eax400fd6:	89 c1                	mov    %eax,%ecx400fd8:	c1 e9 1f             	shr    $0x1f,%ecx400fdb:	01 c8                	add    %ecx,%eax//右移，也就是/2，再把rax和rsi加到rcx上400fdd:	d1 f8                	sar    %eax400fdf:	8d 0c 30             	lea    (%rax,%rsi,1),%ecx//if语句开始，判断edi和ecx的大小，<=的话跳转400ff2400fe2:	39 f9                	cmp    %edi,%ecx400fe4:	7e 0c                	jle    400ff2 <func4+0x24>//是的话，先把eax置0，再进行二次if语句判断，判断edi和ecx的大小，>=的话跳转401007 （其实就是==判断）400ff2:	b8 00 00 00 00       	mov    $0x0,%eax400ff7:	39 f9                	cmp    %edi,%ecx400ff9:	7d 0c                	jge    401007 <func4+0x39>//rsp+8，结束（这是第二个if语句肯定的执行，第二个if语句没有else）401007:	48 83 c4 08          	add    $0x8,%rsp40100b:	c3                   	retq  //否则，edx = rcx - 1400fe6:	8d 51 ff             	lea    -0x1(%rcx),%edx

简单来说，我们要让rcx = rdi，之前不有个14嘛，就相当于与 14/2比较。（最简单的情况）

0000000000400ee0 <phase_1>:400ee0:	48 83 ec 08          	sub    $0x8,%rsp400ee4:	be 00 24 40 00       	mov    $0x402400,%esi400ee9:	e8 4a 04 00 00       	callq  401338 <strings_not_equal>400eee:	85 c0                	test   %eax,%eax400ef0:	74 05                	je     400ef7 <phase_1+0x17>400ef2:	e8 43 05 00 00       	callq  40143a <explode_bomb>400ef7:	48 83 c4 08          	add    $0x8,%rsp400efb:	c3                   	retq

其他情况就有-1之分了，没太细嗦。
应该是0，1，3都可以。
可以稍微解释一下，如果输入的是3的话，rcx(rax + rsi) = 14/2 = 7 > 3(rdi，第一个参数)，那么就执行else语句edx = rcx - 1，也就是（7 - 1）/ 2 = 3，这样再次执行func4就可以通过了。依此类推 0 ， 1亦可。
总之：

五、五号炸弹（跳转，循环与计算）

    /* Round and 'round in memory we go, where we stop, the bomb blows! */input = read_line();phase_5(input);phase_defused();printf("Good work!  On to the next...\n");

5号炸弹说难不难说简单也不简单，不难是因为我自己就看了个七七八八，明白了啥意思；不简单是看懂了但没完全看懂，最关键的对应没想明白。。。
看代码，第一步判断跳转开始，不满足字符输入为六的就爆炸。

0000000000401062 <phase_5>:401062:	53                   	push   %rbx401063:	48 83 ec 20          	sub    $0x20,%rsp401067:	48 89 fb             	mov    %rdi,%rbx40106a:	64 48 8b 04 25 28 00 	mov    %fs:0x28,%rax401071:	00 00 401073:	48 89 44 24 18       	mov    %rax,0x18(%rsp)401078:	31 c0                	xor    %eax,%eax40107a:	e8 9c 02 00 00       	callq  40131b <string_length>40107f:	83 f8 06             	cmp    $0x6,%eax401082:	74 4e                	je     4010d2 <phase_5+0x70>401084:	e8 b1 03 00 00       	callq  40143a <explode_bomb>

  4010d2:	b8 00 00 00 00       	mov    $0x0,%eax4010d7:	eb b2                	jmp    40108b <phase_5+0x29>

此处是非常关键的六次循环，edx与0xf做与运算，得到的值加上0x4024b0访问数组。

  40108b:	0f b6 0c 03          	movzbl (%rbx,%rax,1),%ecx40108f:	88 0c 24             	mov    %cl,(%rsp)401092:	48 8b 14 24          	mov    (%rsp),%rdx401096:	83 e2 0f             	and    $0xf,%edx401099:	0f b6 92 b0 24 40 00 	movzbl 0x4024b0(%rdx),%edx4010a0:	88 54 04 10          	mov    %dl,0x10(%rsp,%rax,1)4010a4:	48 83 c0 01          	add    $0x1,%rax4010a8:	48 83 f8 06          	cmp    $0x6,%rax4010ac:	75 dd                	jne    40108b <phase_5+0x29>

下个断点看看0x4024b0是个啥：哦，是对应表

然后就是最终代码，可以看到0x40245e既是第二个参数传入，一样看看这是啥

  4010ae:	c6 44 24 16 00       	movb   $0x0,0x16(%rsp)4010b3:	be 5e 24 40 00       	mov    $0x40245e,%esi4010b8:	48 8d 7c 24 10       	lea    0x10(%rsp),%rdi4010bd:	e8 76 02 00 00       	callq  401338 <strings_not_equal>

这就是比较的答案，但因为0x4024b0经过了操作，所以我们得和他对应才能输出想要的值。
以f为例，那个表是<array.3449+8>的第二个，也就是+9。
其实他这里指的是下标值，即0x09、0x0f，0x0e，0x05，0x06和0x07。
这个查表吧：（随便在百度上搜的）

以此类推，答案有很多种，我选了个数字比较多的：9on567

试试吧：

六、六号炸弹（炸弹？原子弹！）

    /* This phase will never be used, since no one will get past the* earlier ones.  But just in case, make this one extra hard. */input = read_line();phase_6(input);phase_defused();

超级、超级、超级长且恶心的汇编代码。自己吭哧吭哧分析了半个点没整明白，还是参考了几位大佬的分析才勉强弄懂。
这个代码可以分为部分，我们来挨个看看。
首先是第一部分，这个好懂，就是读取六个数，并判断如果少于六个就爆炸。

  401106:	e8 51 03 00 00       	callq  40145c <read_six_numbers>40110b:	49 89 e6             	mov    %rsp,%r1440110e:	41 bc 00 00 00 00    	mov    $0x0,%r12d401114:	4c 89 ed             	mov    %r13,%rbp401117:	41 8b 45 00          	mov    0x0(%r13),%eax40111b:	83 e8 01             	sub    $0x1,%eax40111e:	83 f8 05             	cmp    $0x5,%eax401121:	76 05                	jbe    401128 <phase_6+0x34>401123:	e8 12 03 00 00       	callq  40143a <explode_bomb>

如果多于6个，r12d++并下面的代码循环6次

  401128:	41 83 c4 01          	add    $0x1,%r12d40112c:	41 83 fc 06          	cmp    $0x6,%r12d401130:	74 21                	je     401153 <phase_6+0x5f>

循环六次的代码，将edx置7，然后edx=7(初始edx值)-rax，直至六个数字全部改变

  401153:	48 8d 74 24 18       	lea    0x18(%rsp),%rsi401158:	4c 89 f0             	mov    %r14,%rax40115b:	b9 07 00 00 00       	mov    $0x7,%ecx401160:	89 ca                	mov    %ecx,%edx401162:	2b 10                	sub    (%rax),%edx401164:	89 10                	mov    %edx,(%rax)401166:	48 83 c0 04          	add    $0x4,%rax40116a:	48 39 f0             	cmp    %rsi,%rax40116d:	75 f1                	jne    401160 <phase_6+0x6c>40116f:	be 00 00 00 00       	mov    $0x0,%esi401174:	eb 21                	jmp    401197 <phase_6+0xa3>

把栈地址偏移量rsp[rsi]给ecx，小于等于1去401183，否则回到401176。

  401197:	8b 0c 34             	mov    (%rsp,%rsi,1),%ecx40119a:	83 f9 01             	cmp    $0x1,%ecx40119d:	7e e4                	jle    401183 <phase_6+0x8f>40119f:	b8 01 00 00 00       	mov    $0x1,%eax4011a4:	ba d0 32 60 00       	mov    $0x6032d0,%edx4011a9:	eb cb                	jmp    401176 <phase_6+0x82>/*401176*/401176:	48 8b 52 08          	mov    0x8(%rdx),%rdx40117a:	83 c0 01             	add    $0x1,%eax40117d:	39 c8                	cmp    %ecx,%eax40117f:	75 f5                	jne    401176 <phase_6+0x82>401181:	eb 05                	jmp    401188 <phase_6+0x94>

看下0x6032d0这里，发现了秘密，这是个链表！（第三列数值正好就是下一行的地址）

是332（1），168（2），924（3），691（4），477（5），443（6）

我们继续分析，rdx -> rsp[rsi *2 + 0x20 ] ，然后+4和0x18比较（我也不晓得这段是个啥。。。）

  401188:	48 89 54 74 20       	mov    %rdx,0x20(%rsp,%rsi,2)40118d:	48 83 c6 04          	add    $0x4,%rsi401191:	48 83 fe 18          	cmp    $0x18,%rsi401195:	74 14                	je     4011ab <phase_6+0xb7>

下一段貌似是链表换数组，空间转移，重排节点。每一个变量都放到了next中。

  4011ab:	48 8b 5c 24 20       	mov    0x20(%rsp),%rbx4011b0:	48 8d 44 24 28       	lea    0x28(%rsp),%rax4011b5:	48 8d 74 24 50       	lea    0x50(%rsp),%rsi4011ba:	48 89 d9             	mov    %rbx,%rcx4011bd:	48 8b 10             	mov    (%rax),%rdx4011c0:	48 89 51 08          	mov    %rdx,0x8(%rcx)4011c4:	48 83 c0 08          	add    $0x8,%rax4011c8:	48 39 f0             	cmp    %rsi,%rax4011cb:	74 05                	je     4011d2 <phase_6+0xde>

判断输入索引顺序，降序排列

  4011da:	bd 05 00 00 00       	mov    $0x5,%ebp4011df:	48 8b 43 08          	mov    0x8(%rbx),%rax4011e3:	8b 00                	mov    (%rax),%eax4011e5:	39 03                	cmp    %eax,(%rbx)4011e7:	7d 05                	jge    4011ee <phase_6+0xfa>4011e9:	e8 4c 02 00 00       	callq  40143a <explode_bomb>4011ee:	48 8b 5b 08          	mov    0x8(%rbx),%rbx4011f2:	83 ed 01             	sub    $0x1,%ebp4011f5:	75 e8                	jne    4011df <phase_6+0xeb>

大概就是这样，从头来的话应该是 924（3），691（4），477（5），443（6），332（1），168（2）
别忘了结果是7-的值。
总之：4 3 2 1 6 5

七、隐藏彩蛋（是不是有什么被忽略了？）

    /* Wow, they got it!  But isn't something... missing?  Perhaps* something they overlooked?  Mua ha ha ha ha! */

还真的有彩蛋啊，不过其实不算隐藏太深，毕竟6后面有东西还是很容易发现的。

比起六号炸弹就是个乖宝宝。把输入值和0x6030f0给fun7，如果fun7返回2就成功了。

0000000000401242 <secret_phase>:401242:	53                   	push   %rbx401243:	e8 56 02 00 00       	callq  40149e <read_line>401248:	ba 0a 00 00 00       	mov    $0xa,%edx40124d:	be 00 00 00 00       	mov    $0x0,%esi401252:	48 89 c7             	mov    %rax,%rdi401255:	e8 76 f9 ff ff       	callq  400bd0 <strtol@plt>40125a:	48 89 c3             	mov    %rax,%rbx40125d:	8d 40 ff             	lea    -0x1(%rax),%eax401260:	3d e8 03 00 00       	cmp    $0x3e8,%eax401265:	76 05                	jbe    40126c <secret_phase+0x2a>401267:	e8 ce 01 00 00       	callq  40143a <explode_bomb>40126c:	89 de                	mov    %ebx,%esi40126e:	bf f0 30 60 00       	mov    $0x6030f0,%edi401273:	e8 8c ff ff ff       	callq  401204 <fun7>401278:	83 f8 02             	cmp    $0x2,%eax40127b:	74 05                	je     401282 <secret_phase+0x40>40127d:	e8 b8 01 00 00       	callq  40143a <explode_bomb>401282:	bf 38 24 40 00       	mov    $0x402438,%edi401287:	e8 84 f8 ff ff       	callq  400b10 <puts@plt>40128c:	e8 33 03 00 00       	callq  4015c4 <phase_defused>401291:	5b                   	pop    %rbx401292:	c3                   	retq   401293:	90                   	nop401294:	90                   	nop401295:	90                   	nop401296:	90                   	nop401297:	90                   	nop401298:	90                   	nop401299:	90                   	nop40129a:	90                   	nop40129b:	90                   	nop40129c:	90                   	nop40129d:	90                   	nop40129e:	90                   	nop40129f:	90                   	nop

看看0x6030f0是个啥：

是棵树！

画出来就是这个样子的，还是一棵平衡二叉树。

让我们看看fun7，可以看到必须输入的是树的节点值（否则为负）
由答案2向上推。这棵树的递归是左走2，右走2+1.
到了第一层，为了输出为2，根据上面的规律，必须得向左走。（因为右边不可能出现0.5）
第二层必须输出为1，还是一样的道理，只能右走出现02+1才能出现1（答案22）
其实可以在第三层左走，02还是0嘛。（答案20）
如图所示，更清楚些。

最后一步，看看啥时候用到它。
phase_defused？！内鬼竟在我身边。

  4015f0:	be 19 26 40 00       	mov    $0x402619,%esi4015f5:	bf 70 38 60 00       	mov    $0x603870,%edi4015fa:	e8 f1 f5 ff ff       	callq  400bf0 <__isoc99_sscanf@plt>4015ff:	83 f8 03             	cmp    $0x3,%eax401602:	75 31                	jne    401635 <phase_defused+0x71>401604:	be 22 26 40 00       	mov    $0x402622,%esi401609:	48 8d 7c 24 10       	lea    0x10(%rsp),%rdi40160e:	e8 25 fd ff ff       	callq  401338 <strings_not_equal>401613:	85 c0                	test   %eax,%eax401615:	75 1e                	jne    401635 <phase_defused+0x71>401617:	bf f8 24 40 00       	mov    $0x4024f8,%edi40161c:	e8 ef f4 ff ff       	callq  400b10 <puts@plt>401621:	bf 20 25 40 00       	mov    $0x402520,%edi401626:	e8 e5 f4 ff ff       	callq  400b10 <puts@plt>40162b:	b8 00 00 00 00       	mov    $0x0,%eax401630:	e8 0d fc ff ff       	callq  401242 <secret_phase>

这里是phase_defused内部，可以看到它使用了0x603870这里的字符串，然后输出与0x402622对比，相同调用。
让我们来看看这里是个啥：

这就是进入的口令。4的答案加上DrEvil
总之：

彻底结束！
ps：隐藏炸弹的启动就是4的答案（一共四种）加上DrEvil，并不是很多大佬说的固定7 0 DrEvil。