Bomb Lab!!!

目录

  • Bomb Lab!!!
    • 准备操作
    • phase_1
      • 汇编代码
      • 分析
      • 伪代码
    • phase_2
      • 汇编代码
      • 分析
      • 伪代码
    • phase_3
      • 汇编代码
      • 分析
      • 伪代码
    • phase_4
      • 汇编代码
      • 分析
      • 伪代码
    • phase_5
      • 汇编代码
      • 分析
      • 伪代码
    • phase_6
      • 汇编代码
      • 分析
      • 伪代码

准备操作

  • 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传递给%esi400ee9:  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>//调用函数 如果没有跳转bomb400ef7:  48 83 c4 08             add    $0x8,%rsp400efb: 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   %rbp400efd:   53                      push   %rbx400efe:   48 83 ec 28             sub    $0x28,%rsp400f02:   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      # 将数组前一个数保存到%eax400f1a:   01 c0                   add    %eax,%eax          # 将%eax乘以2400f1c:   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 + 24400f3a:   eb db                   jmp    400f17 <phase_2+0x1b>400f3c:   48 83 c4 28             add    $0x28,%rsp400f40:   5b                      pop    %rbx400f41:   5d                      pop    %rbp400f42:   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;     # 初始化 initrbp = 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,%rsp400f47:   48 8d 4c 24 0c          lea    0xc(%rsp),%rcx     # 第二个整数位于$rsp + 12400f4c:   48 8d 54 24 08          lea    0x8(%rsp),%rdx      # 第一个整数位于%rsp + 8400f51:   be cf 25 40 00          mov    $0x4025cf,%esi       # 查看0x4025cf地址处内存，为"%d %d"，表示接受两个整数作为输入400f56:   b8 00 00 00 00          mov    $0x0,%eax400f5b:   e8 90 fc ff ff          callq  400bf0 <__isoc99_sscanf@plt>400f60:   83 f8 01                cmp    $0x1,%eax         # sscanf返回值需大于1，否则爆炸。说明可变参数个数为2400f63:   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),%eax400f75:   ff 24 c5 70 24 40 00    jmpq   *0x402470(,%rax,8)  # 跳转表结构，对应C语言中的switch语句400f7c:   b8 cf 00 00 00          mov    $0xcf,%eax           # %rax = 0，跳转到400f7c400f81:   eb 3b                   jmp    400fbe <phase_3+0x7b>400f83:   b8 c3 02 00 00          mov    $0x2c3,%eax400f88:   eb 34                   jmp    400fbe <phase_3+0x7b>400f8a:   b8 00 01 00 00          mov    $0x100,%eax400f8f:   eb 2d                   jmp    400fbe <phase_3+0x7b>400f91:   b8 85 01 00 00          mov    $0x185,%eax400f96:   eb 26                   jmp    400fbe <phase_3+0x7b>400f98:   b8 ce 00 00 00          mov    $0xce,%eax400f9d:   eb 1f                   jmp    400fbe <phase_3+0x7b>400f9f:   b8 aa 02 00 00          mov    $0x2aa,%eax400fa4:   eb 18                   jmp    400fbe <phase_3+0x7b>400fa6:   b8 47 01 00 00          mov    $0x147,%eax400fab:   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,%eax400fb7:   eb 05                   jmp    400fbe <phase_3+0x7b>400fb9:   b8 37 01 00 00          mov    $0x137,%eax400fbe:   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,%rsp400fcd:   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,%rsp401010:   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,%eax401024:   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函数的第一个入参，初值为1440103f:   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,%rsp401061:   c3                      retq

逻辑后：

phase_4(rdi)
{# 省略分配栈上空间rcx = rsp + 12;            # sscanf 参数 4rdx = rsp + 8;           # sscanf 参数 3rsi = 0x4025cf;           # sscanf 参数 2rax = 0;callq sscanf;if (rax != 2) {         # sscanf 返回值判断goto 401035;}if (0x8(rsp) <= 14) {    # 第一个数字goto 40103a;}
401035:goto explode_bomb;
40103a:edx = 14;           # func4 参数 3rsi = 0;           # func4 参数 2rdi = 0x8(rsp);        # func4 参数 1goto 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,%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,%eax400fdd: d1 f8                   sar    %eax400fdf:  8d 0c 30                lea    (%rax,%rsi,1),%ecx400fe2:    39 f9                   cmp    %edi,%ecx400fe4: 7e 0c                   jle    400ff2 <func4+0x24>400fe6:    8d 51 ff                lea    -0x1(%rcx),%edx400fe9:   e8 e0 ff ff ff          callq  400fce <func4>400fee:  01 c0                   add    %eax,%eax400ff0: eb 15                   jmp    401007 <func4+0x39>400ff2:    b8 00 00 00 00          mov    $0x0,%eax400ff7: 39 f9                   cmp    %edi,%ecx400ff9: 7d 0c                   jge    401007 <func4+0x39>400ffb:    8d 71 01                lea    0x1(%rcx),%esi400ffe:    e8 cb ff ff ff          callq  400fce <func4>401003:  8d 44 00 01             lea    0x1(%rax,%rax,1),%eax401007: 48 83 c4 08             add    $0x8,%rsp40100b: 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   %rbx401063:   48 83 ec 20             sub    $0x20,%rsp401067:   48 89 fb                mov    %rdi,%rbx          # rbx保存输入字符串40106a:   64 48 8b 04 25 28 00    mov    %fs:0x28,%rax401071:   00 00401073:   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,%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),%ecx40108f:   88 0c 24                mov    %cl,(%rsp)401092:   48 8b 14 24             mov    (%rsp),%rdx401096:   83 e2 0f                and    $0xf,%edx           # 将当前字符与上0xf，结果保存在%edx401099:   0f b6 92 b0 24 40 00    movzbl 0x4024b0(%rdx),%edx  # 将(0x4024b0+%edx)处的字符保存在%rdx4010a0:   88 54 04 10             mov    %dl,0x10(%rsp,%rax,1)4010a4:   48 83 c0 01             add    $0x1,%rax           # 每次循环%rax加14010a8:   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处字符串为flyers4010b8:   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,%eax4010c4:   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初值为04010d7:   eb b2                   jmp    40108b <phase_5+0x29>4010d9:   48 8b 44 24 18          mov    0x18(%rsp),%rax4010de:   64 48 33 04 25 28 00    xor    %fs:0x28,%rax4010e5:   00 004010e7:   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,%rsp4010f2:   5b                      pop    %rbx4010f3:   c3                      retq

可读性分析：

phase_5(rdx)
{rbx = rdi;rax = fs:0x28;             # 金丝雀*(rsp+0x18) = rax;eax = eax ^ eax;          # 清0callq 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;noplgoto 4010d9;
4010d2:eax = 0;                # initgoto 40108b;          # 循环
4010d9:rax = *(rsp + 0x18);rax = rax ^ fs:0x28;if (rax == 0)           # 栈是否被破坏goto 4010ee;elsecallq __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 Gfor (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   %r144010f6:   41 55                   push   %r134010f8:   41 54                   push   %r124010fa:   55                      push   %rbp4010fb:   53                      push   %rbx4010fc:   48 83 ec 50             sub    $0x50,%rsp401100:   49 89 e5                mov    %rsp,%r13401103:   48 89 e6                mov    %rsp,%rsi401106:   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 = 0401114:   4c 89 ed                mov    %r13,%rbp          # 初始$rbp, %r13都指向第一个数401117:   41 8b 45 00             mov    0x0(%r13),%eax    40111b:   83 e8 01                sub    $0x1,%eax40111e:   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循环计数，每次加140112c:   41 83 fc 06             cmp    $0x6,%r12d           # 第一重循环，终止条件是%r12d等于6401130:   74 21                   je     401153 <phase_6+0x5f>401132:   44 89 e3                mov    %r12d,%ebx            # %ebx <- %r12d 401135:   48 63 c3                movslq %ebx,%rax401138:   8b 04 84                mov    (%rsp,%rax,4),%eax    # 将输入的下一个整数保存到%eax40113b:   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,%ebx401148:   83 fb 05                cmp    $0x5,%ebx40114b:   7e e8                   jle    401135 <phase_6+0x41>40114d:   49 83 c5 04             add    $0x4,%r13401151:   eb c1                   jmp    401114 <phase_6+0x20>
# 步骤2：对于每个输入的整数，做这样的转换：用7减去这个整数的值替换原来的数401153:   48 8d 74 24 18          lea    0x18(%rsp),%rsi401158:   4c 89 f0                mov    %r14,%rax          40115b:   b9 07 00 00 00          mov    $0x7,%ecx          # %ecx初值为7401160:   89 ca                   mov    %ecx,%edx401162:   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,%rax40116d:   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设为0401174:   eb 21                   jmp    401197 <phase_6+0xa3>401176:   48 8b 52 08             mov    0x8(%rdx),%rdx        # 访问链表40117a:   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>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,%rsi401191:   48 83 fe 18             cmp    $0x18,%rsi401195:   74 14                   je     4011ab <phase_6+0xb7>401197:   8b 0c 34                mov    (%rsp,%rsi,1),%ecx # ecx初始值为%rsp, 指向第一个数40119a:   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,%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),%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>4011cd:   48 89 d1                mov    %rdx,%rcx4011d0:   eb eb                   jmp    4011bd <phase_6+0xc9>
# 4.判断（%rsp + 32）处的6个整数是否为降序排列，如不满足条件引爆炸弹4011d2:   48 c7 42 08 00 00 00    movq   $0x0,0x8(%rdx)4011d9:   004011da:   bd 05 00 00 00          mov    $0x5,%ebp4011df:   48 8b 43 08             mov    0x8(%rbx),%rax     #将链表下一个节点地址给rax4011e3:   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),%rbx4011f2:   83 ed 01                sub    $0x1,%ebp4011f5:   75 e8                   jne    4011df <phase_6+0xeb>4011f7:   48 83 c4 50             add    $0x50,%rsp4011fb:   5b                      pop    %rbx4011fc:   5d                      pop    %rbp4011fd:   41 5c                   pop    %r124011ff:   41 5d                   pop    %r13401201:   41 5e                   pop    %r14401203:   c3                      retq

汇编代码

分析

不会

伪代码

Bomb Lab!!!相关推荐

  1. [精品]CSAPP Bomb Lab 解题报告(七)——隐藏关卡

    接上篇[精品]CSAPP Bomb Lab 解题报告(六) gdb常用指令 设置Intel代码格式:set disassembly-flavor intel 查看反汇编代码:disas phase_1 ...

  2. [精品]CSAPP Bomb Lab 解题报告(六)

    接上篇[精品]CSAPP Bomb Lab 解题报告(五) gdb常用指令 设置Intel代码格式:set disassembly-flavor intel 查看反汇编代码:disas phase_1 ...

  3. [精品]CSAPP Bomb Lab 解题报告(五)

    接上篇[精品]CSAPP Bomb Lab 解题报告(四) gdb常用指令 设置Intel代码格式:set disassembly-flavor intel 查看反汇编代码:disas phase_1 ...

  4. [精品]CSAPP Bomb Lab 解题报告(四)

    接上篇[精品]CSAPP Bomb Lab 解题报告(三) gdb常用指令 设置Intel代码格式:set disassembly-flavor intel 查看反汇编代码:disas phase_1 ...

  5. [精品]CSAPP Bomb Lab 解题报告(三)

    接上篇[精品]CSAPP Bomb Lab 解题报告(二) gdb常用指令 设置Intel代码格式:set disassembly-flavor intel 查看反汇编代码:disas phase_1 ...

  6. [精品]CSAPP Bomb Lab 解题报告(二)

    接上篇[精品]CSAPP Bomb Lab 解题报告(一) gdb常用指令 设置Intel代码格式:set disassembly-flavor intel 查看反汇编代码:disas phase_1 ...

  7. [精品]CSAPP Bomb Lab 解题报告(一)

    接上篇堆栈图解CSAPP Bomb Lab实验解析 gdb常用指令 设置Intel代码格式:set disassembly-flavor intel 查看反汇编代码:disas phase_1 查看字 ...

  8. 堆栈图解CSAPP Bomb Lab实验解析

    CSAPP Bomb Lab 实验解析 Bomblab是csapp的第二个配套实验,该实验提供了一个bomb二进制文件和一个bomb.c源文件,我们的目标是运行bomb并按照提示一步步输入字符串,直到 ...

  9. CSAPP Bomb Lab记录

    记录关于CSAPP 二进制炸弹实验过程 (CSAPP配套教学网站Bomb Lab自学版本,实验地址:http://csapp.cs.cmu.edu/2e/labs.html) (个人体验:对x86汇编 ...

  10. CSAPP实验二——bomb lab实验

    CSAPP实验二-- bomb lab实验 实验前准备 第一部分(phase_1) 第二部分(phase_2) 第三部分(phase_3) 第四部分(phase_4) 第五部分(phase_5) 第六 ...

最新文章

  1. 什么是动态DNS 动态DNS有什么用
  2. 理解VMware虚拟机下网络连接的三种模式
  3. m2eclipse插件
  4. 浅谈微视推荐系统中的特征工程
  5. 剑指 Offer 07. 重建二叉树【千字分析，三种方法】
  6. druid java直接调用_Spring Boot使用Druid连接池的示例代码
  7. HDU - 5686-Problem B (递推+高精）
  8. PyTorch中Tensor的基本用法与动手学深度学习的预备知识
  9. PC登录Citrix WI时报CPS license acquisition error（500）错误 截图及解决
  10. 清华图书馆机器人小图_机器人“小图”带你逛“国家图书馆110周年公共数字文化展”...
  11. SpringCloud常见面试题（2020最新版）
  12. if条件的默认转换规则：
  13. 支持vxlan的服务器网卡,3台服务器互通vxlan
  14. NSString NSURL
  15. python将word文档转换为txt
  16. 单片机交通灯c语言实验报告,模拟交通灯单片机实验报告.doc
  17. Pixhawk学习9——固定翼位置控制（L1控制+TECS总能量控制）
  18. 初学python数据结构-切片
  19. html汉字间的间距,div字间距-div内文字之间间距设置方法
  20. 图片转cad用什么软件？转换有技巧

热门文章

  1. crmeb多商户总后台目录结构
  2. 模块和包.colorama
  3. 【心理学】具备情感色彩的文学作品(尤其是悲剧作品)，能显著的提高共情能力
  4. 读书笔记：程序员的思维修炼：开发认知潜能的九堂课
  5. python 爬虫 伪装浏览器_python爬虫中怎么伪装浏览器？
  6. Matlab中 linprog函数的用法总结
  7. leetcode 24.两两交换链表的节点
  8. 用react写一个图片上传（或文件上传）
  9. MATLAB 得心应手的成长之路 (一) 数据的筛选
  10. 价值感知：如何评价企业 IT 项目的价值？