Bomb Lab!!!
目录
准备操作
-
starter code link (直接按住ctrl点击打开此超链接)下载后，在压缩包目录下键入 tar vxf bomb.tar 命令来解压，请先按照lab0说明文档后面所附的实验环境配置安装好环境，通过mobaXterm连接WSL，把解压文件夹拖动到WSL中，用VS Code打开项目文件夹。
提供的文件包括：
bomb.c：包括炸弹主要程序的源文件，还有来自邪恶博士的友好问候。
bomb：二进制炸弹可执行文件。
打开项目后我们通过如下命令实现反汇编：
方法一：整体可执行文件的反汇编
objdump -d bomb > bomb.s
//把bomb反汇编至bomb.s
方法二：反汇编部分函数
(gdb) disassemble main
//main可以替换为你想要反汇编的函数名
phase_1
汇编代码
0000000000400ee0 <phase_1>:
400ee0: 48 83 ec 08 sub $0x8,%rsp //栈指针%rsp-0x8 开辟一个0x8大小的空间
400ee4: be 00 24 40 00 mov $0x402400,%esi//把0x402400传递给%esi
400ee9: e8 4a 04 00 00 callq 401338 <strings_not_equal>//调用函数 前面几个参数是为了传参
400eee: 85 c0 test %eax,%eax//函数返回值做与运算
400ef0: 74 05 je 400ef7 <phase_1+0x17>//
400ef2: e8 43 05 00 00 callq 40143a <explode_bomb>//调用函数 如果没有跳转bomb
400ef7: 48 83 c4 08 add $0x8,%rsp
400efb: c3 retq
分析
phase_1执行过程如下：
首先通过callq指令调用strings_not_equal函数。根据过程调用的规则，可以确定这个函数接受2个参数。第一个参数是%rdi, 上面分析过，是我们拆弹时输入的字符串；第二个参数是$esi，值为0x402400。顾名思义，strings_not_equal函数用来判断两个字符串是否相等。
接着用test指令判断函数的返回值是否为0。如果为0进行跳转并返回，调用phase_defused拆除炸弹，否则通过callq指令调用explode_bomb，引爆炸弹。
因此，拆弹的关键在于，确认0x402400地址处的字符串是什么。只需要在0x400ee9处打个gdb断点就可以了。
>(gdb) x /s 0x402400
0x402400: "Border relations with Canada have never been better."
也就是我们输入的字符串要是"Border relations with Canada have never been better."炸弹才不会爆炸。
伪代码
void phase_1(char* output)
{
if( string_not_equal(output, "Border relations with Canada have never been better.") == 0)
explode_bomb();
return;
}
phase_2
汇编代码
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 # %rsi作为read_six_numbers的第二个入参传递, $rsp既是入参也是出参；第一个入参为$rdi, 即用户输入的字符串
400f05: e8 52 05 00 00 callq 40145c <read_six_numbers> # 读六个数字
400f0a: 83 3c 24 01 cmpl $0x1,(%rsp) # %rsp为调用者保存寄存器，过程调用前后值不变，因此保存的是read_six_numbers输出的6个数，(%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># 将6个整数看作一个数组
400f17: 8b 43 fc mov -0x4(%rbx),%eax # 将数组前一个数保存到%eax
400f1a: 01 c0 add %eax,%eax # 将%eax乘以2
400f1c: 39 03 cmp %eax,(%rbx) # 判断当前整数是否为前一个数的两倍， 不等则爆炸，相等跳转到400f25，
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 # 每次循环，将rbx值加4，即指向数组的下一个元素
400f29: 48 39 eb cmp %rbp,%rbx # rbp指向数组结尾，标识循环是否结束
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 # 最初rbx指向第二个数，
400f35: 48 8d 6c 24 18 lea 0x18(%rsp),%rbp # %rbp = $rsp + 24
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
逻辑化一下：
phase_2(rdi)
{
rsi = rsp;
callq read_six_number;
if (*rsp == 1)
goto 400f30;
else
callq explode_bomb;
goto 400f30;
400f17:
eax = *(rbx-4);
eax += eax;
if (eax == *rbx)
goto 400f25;
else
callq explode_bomb;
400f25:
rbx += 4; # 下一个元素
if (rbx != rbp)
goto 400f17; # 循环
else
goto 400f3c;
400f30:
rbx = rsp + 4; # 初始化 init
rbp = rsp + 24; # 数组结束
goto 400f17;
400f3c:
retq
}
分析
phase_2程序先调用read_six_numbers。该函数接受两个参数，第一个参数为$rdi, 即我们输入的字符串；第二个参数为$rsp, $rsp既是入参也是出参，用于保存read_six_numbers函数解析$rdi后得到的6个整数。查看0x400f02, 0x401463 ~ 0x40147c处的代码，我们可以把调用者phase_2中的，$rsp看作一个一维数组的首地址，该数组的长度为6，内容依次为$rsp, $rsp + 4, $rsp + 8, $rsp + 12, $rsp + 16, $rsp + 20，用于 保存sscanf函数执行后生成的6个整数。由0x400f0a: cmpl $0x1,(%rsp)可知，第一个整数一定是1，然后跳转到0x400f30进入循环。将这6个数看作一个数组， 由0x400f30处代码，$rbx可看作这个数组的下标，初始值为1，指向第2个整数；由0x400f35处代码，$rbp标识着数组的结尾，用于判断循环是否退出。由0x400f17 ~ 0x400f1c代码可知，每次循环判断数组当前元素是否为前一个元素的两倍，不等则爆炸。因此答案为1 2 4 8 16 32， 唯一解。
伪代码
phase_2(edi)
void phase_2(char* output)
{
int array[6];
read_six_numbers(output, array);
if (array[0] != 1)
explode_bomb();
for (int i = 1; i < 6; i++) {
int temp=array[i-1];
temp+=temp;
if (array[i] != temp)
explode_bomb();
}
return;
}
phase_3
汇编代码
0000000000400f43 <phase_3>:
400f43: 48 83 ec 18 sub $0x18,%rsp
400f47: 48 8d 4c 24 0c lea 0xc(%rsp),%rcx # 第二个整数位于$rsp + 12
400f4c: 48 8d 54 24 08 lea 0x8(%rsp),%rdx # 第一个整数位于%rsp + 8
400f51: be cf 25 40 00 mov $0x4025cf,%esi # 查看0x4025cf地址处内存，为"%d %d"，表示接受两个整数作为输入
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 # sscanf返回值需大于1，否则爆炸。说明可变参数个数为2
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># 比较结果大于0则跳转
400f71: 8b 44 24 08 mov 0x8(%rsp),%eax
400f75: ff 24 c5 70 24 40 00 jmpq *0x402470(,%rax,8) # 跳转表结构，对应C语言中的switch语句
400f7c: b8 cf 00 00 00 mov $0xcf,%eax # %rax = 0，跳转到400f7c
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值与第二个参数是否相等，不等则爆炸
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
逻辑下：
phase_3(rdi)
{
# 省略分配栈上空间
rcx = rsp + 0xc;
rdx = rsp + 0x8;
esi = 0x4025cf;
eax = 0;
sccanf(rdi, esi, rdx, rcx);
if (eax <= 1)
explode_bomb();
if(*(rsp + 8) > 7) {
explode_bomb();
}
goto *(0x402470+rax*8);
400f7c：
eax = 0xcf;
goto 400fbe;
400f83：
eax = 0x2c3;
goto 400fbe;
400f8a:
eax = 0x100;
goto 400fbe;
400f91:
eax = 0x185;
goto 400fbe;
400f98:
eax = 0xce;
goto 400fbe;
400f9f:
eax = 0x2aa;
goto 400fbe;
400fa6:
eax = 0x147;
goto 400fbe;
eax = 0;
goto 400fbe;
400fb9:
eax = 0x137;
400fbe:
if (eax != *(rsp+0xc))
explode_bomb();
retq;
}
分析
通过gdb发现sscanf的输入是俩个%d，也就是输出了俩个整形
(gdb) x/s 0x4025cf
0x4025cf: "%d %d"
根据0x400f6a处的cmp指令，发现第一个参数不能大于7，0x400f75处jmpq *0x402470(,%rax,8)是一个间接跳转指令, 可以看出这段代码是典型的switch语句，跳转表就存在于0x402470。%rax取值为[0, 7]，代表switch语句中8条不同的case。
(gdb) x/8g 0x402470
0x402470: 0x0000000000400f7c 0x0000000000400fb9
0x402480: 0x0000000000400f83 0x0000000000400f8a
0x402490: 0x0000000000400f91 0x0000000000400f98
0x4024a0: 0x0000000000400f9f 0x0000000000400fa6
举例，第一个整数取0时，会跳转到0x400f7c, 将0xcf赋给%rax，0x400fbe处再判断$rax和第二个整数是否相等。因此0 207为满足条件的一组解。依次类推，一共得到8组解，答案不唯一，任选一种即可：
0 207
1 311
2 707
3 256
4 389
5 206
6 682
7 327
伪代码
void phase_3(char* output)
{
int x, y;
if(sscanf(output, "%d %d", &x, &y) <= 1)
explode_bomb();
if(x > 7)
explode_bomb();
int num;
switch(x) {
case 0:
num = 207;
break;
case 1:
num = 311;
break;
case 2:
num = 707;
break;
case 3:
num = 256;
break;
case 4:
num = 389;
break;
case 5:
num = 206;
break;
case 6:
num = 682;
break;
case 7:
num = 327;
}
if (num != y)
explode_bomb();
return;
}
phase_4
汇编代码
000000000040100c <phase_4>:
40100c: 48 83 ec 18 sub $0x18,%rsp
401010: 48 8d 4c 24 0c lea 0xc(%rsp),%rcx # 第二个整数，用$rcx保存
401015: 48 8d 54 24 08 lea 0x8(%rsp),%rdx # 第一个整数，用%rdx保存
40101a: be cf 25 40 00 mov $0x4025cf,%esi # %rsi处字符串: "%d %d"
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
40102c: 75 07 jne 401035 <phase_4+0x29>
40102e: 83 7c 24 08 0e cmpl $0xe,0x8(%rsp) # 将第一个整数和14比较
401033: 76 05 jbe 40103a <phase_4+0x2e># 如果不大于14跳转，否则引爆炸弹
401035: e8 00 04 00 00 callq 40143a <explode_bomb>
40103a: ba 0e 00 00 00 mov $0xe,%edx # func4函数的第一个入参，初值为14
40103f: be 00 00 00 00 mov $0x0,%esi # func4函数的第二个入参，初值为0
401044: 8b 7c 24 08 mov 0x8(%rsp),%edi # func4函数的第三个入参，初值为输入的第一个整数
401048: e8 81 ff ff ff callq 400fce <func4> # 调用func4, func4为递归函数
40104d: 85 c0 test %eax,%eax # func4函数必须返回0，否则爆炸
40104f: 75 07 jne 401058 <phase_4+0x4c>
401051: 83 7c 24 0c 00 cmpl $0x0,0xc(%rsp) # 第二个整数必须为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
逻辑后：
phase_4(rdi)
{
# 省略分配栈上空间
rcx = rsp + 12; # sscanf 参数 4
rdx = rsp + 8; # sscanf 参数 3
rsi = 0x4025cf; # sscanf 参数 2
rax = 0;
callq sscanf;
if (rax != 2) { # sscanf 返回值判断
goto 401035;
}
if (0x8(rsp) <= 14) { # 第一个数字
goto 40103a;
}
401035:
goto explode_bomb;
40103a:
edx = 14; # func4 参数 3
rsi = 0; # func4 参数 2
rdi = 0x8(rsp); # func4 参数 1
goto func4;
if (rax != 0) { # func4 返回值判断
goto 401058;
}
if (0xc(rsp) == 0) { # # 第二个数字
goto 40105d;
}
401058:
goto exlode_bomb;
40105d:
return;
}
分析
同样的，先确认输入字符串的格式，查看0x4025cf处的格式化字符串
(gdb) x/s 0x4025cf
0x4025cf: "%d %d"
第一个参数位于%rsp + 8， 第二个参数位于%rsp + 12
由
40102e: 83 7c 24 08 0e cmpl $0xe,0x8(%rsp) # 将第一个整数和14比较 401033: 76 05 jbe 40103a <phase_4+0x2e># 如果不大于14跳转，否则引爆炸弹得知第一个整数必须不大于14， 否则引爆炸弹。
在0x401048处调用func4函数，并判断该函数返回值是否为0，不等于0则引爆炸弹。
由
40103a: ba 0e 00 00 00 mov $0xe,%edx # func4函数的第一个入参，初值为14 40103f: be 00 00 00 00 mov $0x0,%esi # func4函数的第二个入参，初值为0 401044: 8b 7c 24 08 mov 0x8(%rsp),%edi # func4函数的第三个入参，初值为输入的第一个整数 401048: e8 81 ff ff ff callq 400fce <func4> # 调用func4, func4为递归函数
得知，调用func4函数并func4函数接受三个入参，且三个参数的初始值从左到右分别为输入的第一个整数,14, 0。
下面展示func4的代码：
0000000000400fce <func4>:
400fce: 48 83 ec 08 sub $0x8,%rsp
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
400fdf: 8d 0c 30 lea (%rax,%rsi,1),%ecx
400fe2: 39 f9 cmp %edi,%ecx
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
400ff7: 39 f9 cmp %edi,%ecx
400ff9: 7d 0c jge 401007 <func4+0x39>
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
401007: 48 83 c4 08 add $0x8,%rsp
40100b: c3 retq
下面是C语言写出的：
void phase_4(char* input)
{
int x, y;
int ret = sscanf(input, "%d %d", &x, &y);
if (ret != 2 || x > 14) {
explode_bomb();
}
else {
int ret = func4(x, 0, 14);
if (ret != 0 || y != 0) {
explode_bomb();
}
}
return;
}
其中c其实是通过 (b-a)/2 + a = b/2 + a/2 = c 得到，其中a和b的初始值是0，14，因此c的初始值是 0/2+14/2 = 7。
所以事实上 c 是求 (b-a)/2，然后通过 c 与 x 进行比较决定不同的递归分支，因此这是递归版的二分法。
因此func4的功能：
二分法找出元素x，目标值在数组的前半部分则返回奇数，后半部分则返回偶数； 找到元素x返回0；
如果目标值在二分查找过程中一直在左半边，则会返回0。
所以答案是：
0 0
1 0
3 0
7 0
伪代码
void phase_4(char* input)
{
int x, y;
int ret = sscanf(input, "%d %d", &x, &y);
if (ret != 2 || x > 14) {
explode_bomb();
}
else {
int ret = func4(x, 0, 14);
if (ret != 0 || y != 0) {
explode_bomb();
}
}
return;
}
phase_5
汇编代码
0000000000401062 <phase_5>:
401062: 53 push %rbx
401063: 48 83 ec 20 sub $0x20,%rsp
401067: 48 89 fb mov %rdi,%rbx # rbx保存输入字符串
40106a: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax
401071: 00 00
401073: 48 89 44 24 18 mov %rax,0x18(%rsp)
401078: 31 c0 xor %eax,%eax
40107a: e8 9c 02 00 00 callq 40131b <string_length>
40107f: 83 f8 06 cmp $0x6,%eax # 输入字符串的长度必须为6,否则爆炸
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 # 将当前字符与上0xf，结果保存在%edx
401099: 0f b6 92 b0 24 40 00 movzbl 0x4024b0(%rdx),%edx # 将(0x4024b0+%edx)处的字符保存在%rdx
4010a0: 88 54 04 10 mov %dl,0x10(%rsp,%rax,1)
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>
4010ae: c6 44 24 16 00 movb $0x0,0x16(%rsp)
4010b3: be 5e 24 40 00 mov $0x40245e,%esi # 0x40245e处字符串为flyers
4010b8: 48 8d 7c 24 10 lea 0x10(%rsp),%rdi # 这里需要构造输入串，使得(%rsp+0x10)处的串等于"flyers"
4010bd: e8 76 02 00 00 callq 401338 <strings_not_equal>
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 # 循环开始，eax初值为0
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
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_5(rdx)
{
rbx = rdi;
rax = fs:0x28; # 金丝雀
*(rsp+0x18) = rax;
eax = eax ^ eax; # 清0
callq string_length; # 计算字符串长度
if (eax == 6) {
goto 4010d2;
}
else callq explode_bomb;
goto 4010d2;
40108b:
ecx = rbx + rax;
*rsp = cl;
rdx = *rsp;
edx = edx & 0xf;
edx = rdx + 0x4024b0;
*(rsp+rax+0x10) = dl; # 数组操作
rax += 1; # 自增
if (rax != 6) # 循环退出条件
goto 40108b;
*(rsp + 0x16) = 0;
esi = 0x40245e;
rdi = rsp + 10;
callq strings_not_equal;
if (eax == 0)
callq explode_bomb;
nopl
goto 4010d9;
4010d2:
eax = 0; # init
goto 40108b; # 循环
4010d9:
rax = *(rsp + 0x18);
rax = rax ^ fs:0x28;
if (rax == 0) # 栈是否被破坏
goto 4010ee;
else
callq __stack_chk_fail@plt;
4010ee:
retq;
}
分析
首先根据 40107f: 83 f8 06 cmp $0x6,%eax # 输入字符串的长度必须为6,否则爆炸得知需要输入一个长度为6的字符串。根据jmp 40108b <phase_5+0x29>，看出这段代码是循环。%eax初始为0， 每次循环将%eax加1，再和6进行比较(0x4010a8)。循环结束后调用strings_not_equal,将0x40245e处的字符串和$rsp + 0x10比较，两个字符串必须相等，否则爆炸。于是我们先去看0x40245e处的字符串
(gdb) x/s 0x40245e
0x40245e: "flyers"
内容为flyers，从0x401067: mov %rdi,%rbx看出， $rsp + 0x10处的字符串是依次将%rbx的每一个字符先与0xf做与运算，然后加上0x4024b0得到新的地址x, 最后取地址x处的字符作为输出；循环结束后，输出一个长度为6的字符串。于是我们再查看0x4024b0处的内容
(gdb) x/16c 0x4024b0
0x4024b0 <array.3449> : 109 'm' 97 'a' 100 'd' 117 'u' 105 'i' 101 'e' 114 'r' 115 's'
0x4024b8 <array.3449+8>: 110 'n' 102 'f' 111 'o' 116 't' 118 'v' 98 'b' 121 'y' 108 'l'
最后可以分析出该代码的功能：
- output长度必须等于6
- 生成一个新的字符串str，由output每个字符&0xf作为maduiersnfotvbyl下标得到
- str必须为flyers
可以发现flyers六个字母对应maduiersnfotvbyl的下标分别为 9 15 14 5 6 7。
查ascii表，可以找到六个&0xf分别为 9 15 14 5 6 7的字符：IONEFG
伪代码
const char g_str[16] = "maduiersnfotvbyl";
void phase_5(char* output)
{
char str[7];
if (string_length(output) != 6) {
explode_bomb();
}
// 9 15 14 5 6 7
// I O N E F G
for (int i = 0; i != 6; i++) {
str[i] = g_str[output[i] & 0xf];
}
str[7] = '\0';
if(string_not_equal(str, "flyers") != 0) {
explode_bomb();
}
}
phase_6
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
401106: e8 51 03 00 00 callq 40145c <read_six_numbers> #读6个数，保存到$rsp
# 步骤1：判断输入的每个数是否不超过6，且任意两个数都不相等
40110b: 49 89 e6 mov %rsp,%r14
40110e: 41 bc 00 00 00 00 mov $0x0,%r12d # %r12d = 0
401114: 4c 89 ed mov %r13,%rbp # 初始$rbp, %r13都指向第一个数
401117: 41 8b 45 00 mov 0x0(%r13),%eax
40111b: 83 e8 01 sub $0x1,%eax
40111e: 83 f8 05 cmp $0x5,%eax # 每个数必须小于等于6，否则爆炸
401121: 76 05 jbe 401128 <phase_6+0x34>
401123: e8 12 03 00 00 callq 40143a <explode_bomb>
401128: 41 83 c4 01 add $0x1,%r12d # %12d循环计数，每次加1
40112c: 41 83 fc 06 cmp $0x6,%r12d # 第一重循环，终止条件是%r12d等于6
401130: 74 21 je 401153 <phase_6+0x5f>
401132: 44 89 e3 mov %r12d,%ebx # %ebx <- %r12d
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) # 第二重循环，当前整数不能和它后面的任意一个数重复，否则爆炸； 两重循环用于确保输入的6个数没有重复数字，否则引爆炸弹
40113e: 75 05 jne 401145 <phase_6+0x51>
401140: e8 f5 02 00 00 callq 40143a <explode_bomb>
401145: 83 c3 01 add $0x1,%ebx
401148: 83 fb 05 cmp $0x5,%ebx
40114b: 7e e8 jle 401135 <phase_6+0x41>
40114d: 49 83 c5 04 add $0x4,%r13
401151: eb c1 jmp 401114 <phase_6+0x20>
# 步骤2：对于每个输入的整数，做这样的转换：用7减去这个整数的值替换原来的数
401153: 48 8d 74 24 18 lea 0x18(%rsp),%rsi
401158: 4c 89 f0 mov %r14,%rax
40115b: b9 07 00 00 00 mov $0x7,%ecx # %ecx初值为7
401160: 89 ca mov %ecx,%edx
401162: 2b 10 sub (%rax),%edx # %edx = 7 - (%rax), %rax指向当前整数
401164: 89 10 mov %edx,(%rax) # (%rax) = %edx
401166: 48 83 c0 04 add $0x4,%rax # 循环每执行一次, %rax指向下一个整数
40116a: 48 39 f0 cmp %rsi,%rax
40116d: 75 f1 jne 401160 <phase_6+0x6c>
# 步骤3：0x6032d0处表示一个包含6个节点的链表， 对于经过步骤2之后转换的每个整数i, 取链表第i个节点的value，依次保存在(%rsp + 32)处
40116f: be 00 00 00 00 mov $0x0,%esi # esi设为0
401174: eb 21 jmp 401197 <phase_6+0xa3>
401176: 48 8b 52 08 mov 0x8(%rdx),%rdx # 访问链表
40117a: 83 c0 01 add $0x1,%eax
40117d: 39 c8 cmp %ecx,%eax
40117f: 75 f5 jne 401176 <phase_6+0x82>
401181: eb 05 jmp 401188 <phase_6+0x94>
401183: ba d0 32 60 00 mov $0x6032d0,%edx # 0x6032d0处为链表，包含6个节点
401188: 48 89 54 74 20 mov %rdx,0x20(%rsp,%rsi,2) #每次取链表中第%ecx个节点的值，保存到$rsp + 0x20 + 2 * $rsi处， %ecx表示每个
40118d: 48 83 c6 04 add $0x4,%rsi
401191: 48 83 fe 18 cmp $0x18,%rsi
401195: 74 14 je 4011ab <phase_6+0xb7>
401197: 8b 0c 34 mov (%rsp,%rsi,1),%ecx # ecx初始值为%rsp, 指向第一个数
40119a: 83 f9 01 cmp $0x1,%ecx
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 # 0x6032d0处为链表，包含6个节点
4011a9: eb cb jmp 401176 <phase_6+0x82>
4011ab: 48 8b 5c 24 20 mov 0x20(%rsp),%rbx # 保存6个节点的值
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
4011c0: 48 89 51 08 mov %rdx,0x8(%rcx)
4011c4: 48 83 c0 08 add $0x8,%rax
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>
# 4.判断（%rsp + 32）处的6个整数是否为降序排列，如不满足条件引爆炸弹
4011d2: 48 c7 42 08 00 00 00 movq $0x0,0x8(%rdx)
4011d9: 00
4011da: bd 05 00 00 00 mov $0x5,%ebp
4011df: 48 8b 43 08 mov 0x8(%rbx),%rax #将链表下一个节点地址给rax
4011e3: 8b 00 mov (%rax),%eax #eax为链表下一个节点的值
4011e5: 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),%rbx
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
汇编代码
分析
不会
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
