-
Bomb Lab!!!
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- 1
- 2
方法二：反汇编部分函数
(gdb) disassemble main //main可以替换为你想要反汇编的函数名- 1
- 2
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- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
分析
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."- 1
- 2
也就是我们输入的字符串要是"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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
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- 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
逻辑化一下：
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 }- 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
分析
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
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- 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
逻辑下：
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; }- 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
分析
通过gdb发现sscanf的输入是俩个%d，也就是输出了俩个整形
(gdb) x/s 0x4025cf 0x4025cf: "%d %d"- 1
- 2
- 3
根据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- 1
- 2
- 3
- 4
- 5
- 6
举例，第一个整数取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- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
伪代码
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; }- 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
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- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
逻辑后：
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; }- 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
分析
同样的，先确认输入字符串的格式，查看0x4025cf处的格式化字符串
(gdb) x/s 0x4025cf 0x4025cf: "%d %d"- 1
- 2
- 3
第一个参数位于%rsp + 8， 第二个参数位于%rsp + 12
由
40102e: 83 7c 24 08 0e cmpl $0xe,0x8(%rsp) # 将第一个整数和14比较 401033: 76 05 jbe 40103a得知第一个整数必须不大于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函数接受三个入参，且三个参数的初始值从左到右分别为输入的第一个整数,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- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
下面是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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
其中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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
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- 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
可读性分析：
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; }- 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
分析
首先根据
40107f: 83 f8 06 cmp $0x6,%eax # 输入字符串的长度必须为6,否则爆炸得知需要输入一个长度为6的字符串。根据jmp 40108b，看出这段代码是循环。%eax初始为0， 每次循环将%eax加1，再和6进行比较(0x4010a8)。循环结束后调用strings_not_equal,将0x40245e处的字符串和$rsp + 0x10比较，两个字符串必须相等，否则爆炸。于是我们先去看0x40245e处的字符串(gdb) x/s 0x40245e 0x40245e: "flyers"- 1
- 2
- 3
内容为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'- 1
- 2
- 3
- 4
最后可以分析出该代码的功能：
- 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(); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
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- 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
- 89
- 90
- 91
- 92
- 93
汇编代码
分析
不会
伪代码
-
-
相关阅读:
鸿蒙开发入门 | 开发第一个鸿蒙应用+页面跳转
不锈钢怎么查看牌号 不锈钢牌号鉴定 材质鉴定
ICLR 2023#Learning to Compose Soft Prompts for Compositional Zero-Shot Learning
CE修改植物大战僵尸-天上无限掉落阳光（小宇特详解）
金仓数据库KingbaseES客户端编程接口指南-DCI（5. 程序示例）
RabbitMQ 学习（四）-- 交换机（发布/订阅、路由、主题模式）
GRU 浅析
MySQL——执行一条select语句期间发生了什么
设计模式：策略模式、工厂模式、模板模式混合使用
腾讯mini项目-【指标监控服务重构】2023-08-26
- 原文地址：https://blog.csdn.net/m0_54015435/article/details/127427470
