Bomb Lab

介绍

邪恶博士在我们的班级机器上植入了许多“二进制炸弹”。二进制炸弹是一个由一系列阶段组成的程序。每个阶段都要求你在 stdin 上输入入特定的字符串。如果你输入正确的字符串，则该阶段将被消除，炸弹将进入下一个阶段。否则，炸弹通过打印“ BOOM !!!”而爆炸。然后终止。当每个阶段都已消除时，炸弹便已消除。

获取炸弹

进入官网下载 bomb.tar 文件，通过 tar -xvf bomb.tar 解压，会得到 3 个文件。

• README
• bomb：可执行二进制炸弹
• bomb.c：源文件包含炸弹的主要程序以及引导程序

一共有 6 个阶段，前 4 个阶段每个 10 分，后面两个比较难每个 15 分，在拆炸弹的过程中，每次引爆一次会从总分里扣 0.5 分（最多扣 20 分）。

小技巧

有一些小提示需要注意:

• 为了防止引爆炸弹，需要学会设置断点，在“炸弹”之前设置断点，防止爆炸

• 反编译出来的汇编代码很长，并不需要搞懂每行，通过 debugger 观察程序执行变化，根据这些信息去拆除炸弹

工具

• gdb：命令行调试器，可以一行行地追踪程序，设置断点，查看寄存器和内存
• objdump -t：输出炸弹程序的符号表。符号表里包含了所有函数和全局变量的名字
• ojbdump -d ：反编译二进制文件，输出汇编代码

准备

• 汇编知识：汇编入门
• gdb 知识
  • gdb bomb 进入调试状态
  • run 运行
  • break phase_1 打断点
  • next 简写 n 表示下一行代码 C 语言代码
  • nexti 简写 ni 表示下一行汇编代码
  • continue 简写 c 表示下一个断点
  • disas 显示汇编
  • info registers 查看寄存器的值
  • x/s $rax 以字符串形式查看

实验部分

在命令行中反编译可执行文件，输入到 bomb.txt 文件中

objdump -d bomb > bomb.txt

我们先看一下 main 函数，一共 6 个阶段，每个阶段都是一个 phase_x 的函数，在函数正常结束之后运行phase_defused拆除这个阶段，然后进入下一阶段。

400e19:   e8 84 05 00 00          callq  4013a2 <initialize_bomb>
400e1e:   bf 38 23 40 00          mov    $0x402338,%edi
400e23:   e8 e8 fc ff ff          callq  400b10 <puts@plt>
400e28:   bf 78 23 40 00          mov    $0x402378,%edi
400e2d:   e8 de fc ff ff          callq  400b10 <puts@plt>
400e32:   e8 67 06 00 00          callq  40149e <read_line>
400e37:   48 89 c7                mov    %rax,%rdi
400e3a:   e8 a1 00 00 00          callq  400ee0 <phase_1>
400e3f:   e8 80 07 00 00          callq  4015c4 <phase_defused>
400e44:   bf a8 23 40 00          mov    $0x4023a8,%edi
400e49:   e8 c2 fc ff ff          callq  400b10 <puts@plt>
400e4e:   e8 4b 06 00 00          callq  40149e <read_line>
400e53:   48 89 c7                mov    %rax,%rdi
400e56:   e8 a1 00 00 00          callq  400efc <phase_2>
400e5b:   e8 64 07 00 00          callq  4015c4 <phase_defused>
400e60:   bf ed 22 40 00          mov    $0x4022ed,%edi
400e65:   e8 a6 fc ff ff          callq  400b10 <puts@plt>
400e6a:   e8 2f 06 00 00          callq  40149e <read_line>
400e6f:   48 89 c7                mov    %rax,%rdi
400e72:   e8 cc 00 00 00          callq  400f43 <phase_3>
400e77:   e8 48 07 00 00          callq  4015c4 <phase_defused>
400e7c:   bf 0b 23 40 00          mov    $0x40230b,%edi
400e81:   e8 8a fc ff ff          callq  400b10 <puts@plt>
400e86:   e8 13 06 00 00          callq  40149e <read_line>
400e8b:   48 89 c7                mov    %rax,%rdi
400e8e:   e8 79 01 00 00          callq  40100c <phase_4>
400e93:   e8 2c 07 00 00          callq  4015c4 <phase_defused>
400e98:   bf d8 23 40 00          mov    $0x4023d8,%edi
400e9d:   e8 6e fc ff ff          callq  400b10 <puts@plt>
400ea2:   e8 f7 05 00 00          callq  40149e <read_line>
400ea7:   48 89 c7                mov    %rax,%rdi
400eaa:   e8 b3 01 00 00          callq  401062 <phase_5>
400eaf:   e8 10 07 00 00          callq  4015c4 <phase_defused>
400eb4:   bf 1a 23 40 00          mov    $0x40231a,%edi
400eb9:   e8 52 fc ff ff          callq  400b10 <puts@plt>
400ebe:   e8 db 05 00 00          callq  40149e <read_line>
400ec3:   48 89 c7                mov    %rax,%rdi
400ec6:   e8 29 02 00 00          callq  4010f4 <phase_6>
400ecb:   e8 f4 06 00 00          callq  4015c4 <phase_defused>

阶段一

我们从上面我们可以看到调用了 phase_1 函数，找到对应的汇编代码。

  ...
  400e32:   e8 67 06 00 00          callq  40149e <read_line> # 获取stdin输入的值
  400e37:   48 89 c7                mov    %rax,%rdi          # 把输入值保存到 %rdi 寄存器中
  400e3a:   e8 a1 00 00 00          callq  400ee0 <phase_1>
  ... 
0000000000400ee0 <phase_1>:
  400ee0:       48 83 ec 08             sub    $0x8,%rsp # 压栈
  400ee4:       be 00 24 40 00          mov    $0x402400,%esi # 把$0x402400的地址保存%rsi中，%esi就%rsi的低位
  400ee9:       e8 4a 04 00 00          callq  401338 <strings_not_equal> # 比较%rdi和%rsi的值，是否不相同,%rdi是我们输入的。如果不相同返回1，相同返回0
  400eee:       85 c0                   test   %eax,%eax # test a,b => b&a，结果只保存在%rax中
  400ef0:       74 05                   je     400ef7 <phase_1+0x17> # 如果%rax为0则跳转
  400ef2:       e8 43 05 00 00          callq  40143a <explode_bomb>
  400ef7:       48 83 c4 08             add    $0x8,%rsp
  400efb:       c3                      retq

上面分析的很清楚了，我们开始拆吧，在终端输入 gdb bomb 进入调试模式

>(gdb) break phase_1 # 打断点
Breakpoint 1 at 0x400ee0
>(gdb) break explode_bomb # 打断点
Breakpoint 2 at 0x40143a
>(gdb) run # 运行
Starting program: /home/ubuntu/cuzz/csapp/bomb/bomb
Welcome to my fiendish little bomb. You have 6 phases with
which to blow yourself up. Have a nice day!
>hello world!

这个时候使用 info registers 查看寄存器信息。

> (gdb) info registers
rax            0x603780            6305664
rbx            0x402210            4203024
rcx            0xc                 12
rdx            0x1                 1
rsi            0x603780            6305664
rdi            0x603780            6305664
rbp            0x0                 0x0
rsp            0x7fffffffe378      0x7fffffffe378
r8             0x603780            6305664
r9             0x7c                124
r10            0xfffffffffffff28e  -3442
r11            0x7ffff7e06400      140737352066048
r12            0x400c90            4197520
r13            0x7fffffffe470      140737488348272
r14            0x0                 0
r15            0x0                 0
rip            0x400ee0            0x400ee0 <phase_1>
eflags         0x206               [ PF IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0

使用 disas 查看执行到哪一步了，stepi 可以使汇编一步一步执行，具体可以看箭头变化。

>(gdb) disas # 反汇编
Dump of assembler code for function phase_1:
=> 0x0000000000400ee0 <+0>:    sub    $0x8,%rsp # 箭头在这里
   0x0000000000400ee4 <+4>:    mov    $0x402400,%esi
   0x0000000000400ee9 <+9>:    callq  0x401338 <strings_not_equal>
   0x0000000000400eee <+14>:    test   %eax,%eax
   0x0000000000400ef0 <+16>:    je     0x400ef7 <phase_1+23>
   0x0000000000400ef2 <+18>:    callq  0x40143a <explode_bomb>
   0x0000000000400ef7 <+23>:    add    $0x8,%rsp
   0x0000000000400efb <+27>:    retq
End of assembler dump.
Breakpoint 1, 0x0000000000400ee0 in phase_1 ()
>(gdb) stepi # 运行第一次
0x0000000000400ee4 in phase_1 ()
>(gdb) stepi # 运行第二次
0x0000000000400ee9 in phase_1 ()
>(gdb) disas
Dump of assembler code for function phase_1:
   0x0000000000400ee0 <+0>:    sub    $0x8,%rsp
   0x0000000000400ee4 <+4>:    mov    $0x402400,%esi
=> 0x0000000000400ee9 <+9>:    callq  0x401338 <strings_not_equal> # 运行两次，箭头像下移动两行
   0x0000000000400eee <+14>:    test   %eax,%eax
   0x0000000000400ef0 <+16>:    je     0x400ef7 <phase_1+23>
   0x0000000000400ef2 <+18>:    callq  0x40143a <explode_bomb>
   0x0000000000400ef7 <+23>:    add    $0x8,%rsp
   0x0000000000400efb <+27>:    retq
End of assembler dump.

我是用 x/s $rdi 和 x/s $rsi 查看寄存器的值

>(gdb) x/s $rdi
0x603780 <input_strings>:    "hello world!"
>(gdb) x/s $rsi
0x402400:    "Border relations with Canada have never been better."

就是比较这两个值是否相等，所以我们只要把这值记下来就可以拆调第一个炸弹了。

我们重新执行一遍，把 Border relations with Canada have never been better. 这段话输入进去，发现拆除了第一炸弹。

阶段二

同样我们先找到 phase_2 对应的汇编代码，从函数名 read_six_numbers 提示我们输入 6 个数字。

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>
  ...

虽然我们知道 read_six_numbers 这个函数是提示我们输入 6 个数据， 但是我们不知道输入这 6 个数字的格式是怎样的，我们先输入123456 试试看。

我们先看看这个函数，对应的汇编，通过打断点 break read_six_numbers 进入。

>(gdb) disas
Dump of assembler code for function read_six_numbers:
   0x000000000040145c <+0>:    sub    $0x18,%rsp
   0x0000000000401460 <+4>:    mov    %rsi,%rdx   # %rdx存放第一个值
   0x0000000000401463 <+7>:    lea    0x4(%rsi),%rcx # %rcx = %rsi + 0x4 放第二个值
   0x0000000000401467 <+11>:    lea    0x14(%rsi),%rax # 保存在栈中 %rsi + 0x14 放第六个值
   0x000000000040146b <+15>:    mov    %rax,0x8(%rsp)
   0x0000000000401470 <+20>:    lea    0x10(%rsi),%rax # 保存在栈中 %rsi + 0x10 放第五个值
   0x0000000000401474 <+24>:    mov    %rax,(%rsp)
   0x0000000000401478 <+28>:    lea    0xc(%rsi),%r9 # %r9 = %rsi + 0xc 放第四个值
   0x000000000040147c <+32>:    lea    0x8(%rsi),%r8 # %r8 = %rsi + 0x8 放第三个值
   0x0000000000401480 <+36>:    mov    $0x4025c3,%esi
   0x0000000000401485 <+41>:    mov    $0x0,%eax
=> 0x000000000040148a <+46>:    callq  0x400bf0 <__isoc99_sscanf@plt> # 一个获取输入的函数: int sscanf( const char *buffer, const char *format [, argument ] ... );
   0x000000000040148f <+51>:    cmp    $0x5,%eax
   0x0000000000401492 <+54>:    jg     0x401499 <read_six_numbers+61>
   0x0000000000401494 <+56>:    callq  0x40143a <explode_bomb>
   0x0000000000401499 <+61>:    add    $0x18,%rsp
   0x000000000040149d <+65>:    retq
End of assembler dump.   
>(gdb) x/s $rsi
0x4025c3:    "%d %d %d %d %d %d" # 以这种格式获取数据
(gdb) x/s $rdi
>0x6037d0 <input_strings+80>:    "123456" # 我们输入的数据，所以我们这样输入不对的

首先看看第一个数是否为 1，然后循环判断后面一个数是否是前面一个数的倍数。

(gdb) disas
Dump of assembler code for function phase_2:
   0x0000000000400efc <+0>:    push   %rbp # 基指针
   0x0000000000400efd <+1>:    push   %rbx # 基址寄存器
   0x0000000000400efe <+2>:    sub    $0x28,%rsp
   0x0000000000400f02 <+6>:    mov    %rsp,%rsi
   0x0000000000400f05 <+9>:    callq  0x40145c <read_six_numbers>
=> 0x0000000000400f0a <+14>:    cmpl   $0x1,(%rsp)   # 第一个参数必须为1
   0x0000000000400f0e <+18>:    je     0x400f30 <phase_2+52>
   0x0000000000400f10 <+20>:    callq  0x40143a <explode_bomb>
   0x0000000000400f15 <+25>:    jmp    0x400f30 <phase_2+52>  # 跳到52
   0x0000000000400f17 <+27>:    mov    -0x4(%rbx),%eax # %rax = before
   0x0000000000400f1a <+30>:    add    %eax,%eax       # %rax = 2 * before
   0x0000000000400f1c <+32>:    cmp    %eax,(%rbx)     # %rax与(%rbx)比较
   0x0000000000400f1e <+34>:    je     0x400f25 <phase_2+41>
   0x0000000000400f20 <+36>:    callq  0x40143a <explode_bomb>
   0x0000000000400f25 <+41>:    add    $0x4,%rbx
   0x0000000000400f29 <+45>:    cmp    %rbp,%rbx # 循环跳出来
   0x0000000000400f2c <+48>:    jne    0x400f17 <phase_2+27>
   0x0000000000400f2e <+50>:    jmp    0x400f3c <phase_2+64>
   0x0000000000400f30 <+52>:    lea    0x4(%rsp),%rbx  # --> 对应下面 0x04
   0x0000000000400f35 <+57>:    lea    0x18(%rsp),%rbp # --> 对应下面 0x18
   0x0000000000400f3a <+62>:    jmp    0x400f17 <phase_2+27> # 跳回到 27
   0x0000000000400f3c <+64>:    add    $0x28,%rsp
   0x0000000000400f40 <+68>:    pop    %rbx
   0x0000000000400f41 <+69>:    pop    %rbp
   0x0000000000400f42 <+70>:    retq
End of assembler dump.

对应内存中的值

0x7fffffffe368  0x28        -> %rbp  
                0x24
                0x20   
                0x1c
                0x18        -> %rbx
                0x14   32
                0x10   16
                0x0c   8
                0x08   4
                0x04   2
0x7fffffffe340  0x00   1    -> %rsp       

最好我们输入 1 2 4 8 16 32 查看结果，就已经通过了

阶段三

同样我们先找到 phase_3 对应的汇编

Dump of assembler code for function phase_3:
=> 0x0000000000400f43 <+0>:        sub    $0x18,%rsp
   0x0000000000400f47 <+4>:        lea    0xc(%rsp),%rcx
   0x0000000000400f4c <+9>:        lea    0x8(%rsp),%rdx
   0x0000000000400f51 <+14>:    mov    $0x4025cf,%esi
   0x0000000000400f56 <+19>:    mov    $0x0,%eax
   0x0000000000400f5b <+24>:    callq  0x400bf0 <__isoc99_sscanf@plt>
   0x0000000000400f60 <+29>:    cmp    $0x1,%eax
   0x0000000000400f63 <+32>:    jg     0x400f6a <phase_3+39>
   0x0000000000400f65 <+34>:    callq  0x40143a <explode_bomb>
   0x0000000000400f6a <+39>:    cmpl   $0x7,0x8(%rsp) # 不能大于7，也不能小于0，0x8(%rsp)这个地址存放着第一个参数
   0x0000000000400f6f <+44>:    ja     0x400fad <phase_3+106>
   0x0000000000400f71 <+46>:    mov    0x8(%rsp),%eax # 把第一个参数放入%rax中
   0x0000000000400f75 <+50>:    jmpq   *0x402470(,%rax,8) # D(Rb, Ri, S) => Mem[Reg[Rb]+S*Reg[Ri]+D] = %rax * 8 + 0x402470
   0x0000000000400f7c <+57>:    mov    $0xcf,%eax
   0x0000000000400f81 <+62>:    jmp    0x400fbe <phase_3+123>
   0x0000000000400f83 <+64>:    mov    $0x2c3,%eax
   0x0000000000400f88 <+69>:    jmp    0x400fbe <phase_3+123>
   0x0000000000400f8a <+71>:    mov    $0x100,%eax
   0x0000000000400f8f <+76>:    jmp    0x400fbe <phase_3+123>
   0x0000000000400f91 <+78>:    mov    $0x185,%eax
   0x0000000000400f96 <+83>:    jmp    0x400fbe <phase_3+123>
   0x0000000000400f98 <+85>:    mov    $0xce,%eax
   0x0000000000400f9d <+90>:    jmp    0x400fbe <phase_3+123>
   0x0000000000400f9f <+92>:    mov    $0x2aa,%eax
   0x0000000000400fa4 <+97>:    jmp    0x400fbe <phase_3+123>
   0x0000000000400fa6 <+99>:    mov    $0x147,%eax
   0x0000000000400fab <+104>:    jmp    0x400fbe <phase_3+123>
   0x0000000000400fad <+106>:    callq  0x40143a <explode_bomb>
   0x0000000000400fb2 <+111>:    mov    $0x0,%eax
   0x0000000000400fb7 <+116>:    jmp    0x400fbe <phase_3+123>
   0x0000000000400fb9 <+118>:    mov    $0x137,%eax
   0x0000000000400fbe <+123>:    cmp    0xc(%rsp),%eax
   0x0000000000400fc2 <+127>:    je     0x400fc9 <phase_3+134>
   0x0000000000400fc4 <+129>:    callq  0x40143a <explode_bomb>
   0x0000000000400fc9 <+134>:    add    $0x18,%rsp
   0x0000000000400fcd <+138>:    retq
End of assembler dump.
>(gdb) x/s 0x4025cf  # 查看输入格式
0x4025cf:    "%d %d"
>(gdb) x/8a 0x402470 # 对应跳转表的地址
0x402470:    0x400f7c <phase_3+57>    0x400fb9 <phase_3+118>
0x402480:    0x400f83 <phase_3+64>    0x400f8a <phase_3+71>
0x402490:    0x400f91 <phase_3+78>    0x400f98 <phase_3+85>
0x4024a0:    0x400f9f <phase_3+92>    0x400fa6 <phase_3+99>

我们又看到 sscnaf 函数，x/s 0x4025cf 查看输入格式，发现是按 %d %d 输入两个数字。在 <+50> 行中是一个 switch 方法，等下 C 代码如下：

if (x1 > 7 || x1 < 0)
    explode_bomb();
switch(x1) {
    case 0:
        if (x2 != a)
            explode_bomb();
        break;
    case 1:
        if (x2 != b)
            explode_bomb();
        break;
    ...
}

假设我们输入的 x1 为 1，那么对应表的地址为 0x400fb9 <phase_3+118> ，所以我们 x2 的值就是 <+118> 中的 0x137 对应的十进制为 311。

最后我们输入 1 311 试试，已经解除

了。

阶段四

有看到了 sscanf 函数，根据前面的经验，查看一下输入格式。0x8(%rsp) 存放着第一个值，0xc(%rsp) 存放着第二个值。

(gdb) disas
Dump of assembler code for function phase_4:
=> 0x000000000040100c <+0>:    sub    $0x18,%rsp
   0x0000000000401010 <+4>:    lea    0xc(%rsp),%rcx
   0x0000000000401015 <+9>:    lea    0x8(%rsp),%rdx
   0x000000000040101a <+14>:    mov    $0x4025cf,%esi
   0x000000000040101f <+19>:    mov    $0x0,%eax
   0x0000000000401024 <+24>:    callq  0x400bf0 <__isoc99_sscanf@plt>
   0x0000000000401029 <+29>:    cmp    $0x2,%eax # 必须为两个值
   0x000000000040102c <+32>:    jne    0x401035 <phase_4+41>
   0x000000000040102e <+34>:    cmpl   $0xe,0x8(%rsp) # 第一个值必须小于0xe
   0x0000000000401033 <+39>:    jbe    0x40103a <phase_4+46>
   0x0000000000401035 <+41>:    callq  0x40143a <explode_bomb>
   0x000000000040103a <+46>:    mov    $0xe,%edx
   0x000000000040103f <+51>:    mov    $0x0,%esi
   0x0000000000401044 <+56>:    mov    0x8(%rsp),%edi
   0x0000000000401048 <+60>:    callq  0x400fce <func4>
   0x000000000040104d <+65>:    test   %eax,%eax # test a,b => a & b 所以func4返回的值必须为0
   0x000000000040104f <+67>:    jne    0x401058 <phase_4+76>
   0x0000000000401051 <+69>:    cmpl   $0x0,0xc(%rsp) # 第二个值必须为0
   0x0000000000401056 <+74>:    je     0x40105d <phase_4+81>
   0x0000000000401058 <+76>:    callq  0x40143a <explode_bomb>
   0x000000000040105d <+81>:    add    $0x18,%rsp
   0x0000000000401061 <+85>:    retq
End of assembler dump.
(gdb) x/s 0x4025cf
0x4025cf:    "%d %d"

这里是一个递归，发现第一个数为 1 时，能是返回值为 0。

Dump of assembler code for function func4:
=> 0x0000000000400fce <+0>:    sub    $0x8,%rsp # %rdi = A %rsi = B %rdx = C
   0x0000000000400fd2 <+4>:    mov    %edx,%eax #  %eax = C
   0x0000000000400fd4 <+6>:    sub    %esi,%eax #  %eax = C - B
   0x0000000000400fd6 <+8>:    mov    %eax,%ecx # %ecx = C - B
   0x0000000000400fd8 <+10>:    shr    $0x1f,%ecx # 右移31位 %ecx = (C - B) >> 31
   0x0000000000400fdb <+13>:    add    %ecx,%eax # %eax = C - B + (C - B) >> 31 = C - B
   0x0000000000400fdd <+15>:    sar    %eax # 等效于 sar $1,%eax   %eax = (C - B) / 2
   0x0000000000400fdf <+17>:    lea    (%rax,%rsi,1),%ecx  # %ecx = %rax + %rsi * 1 = (C - B) / 2 + B = (B + C) / 2
   0x0000000000400fe2 <+20>:    cmp    %edi,%ecx # 比较 A  和 %exc =（B + C）/ 2
   0x0000000000400fe4 <+22>:    jle    0x400ff2 <func4+36> # (B + C) / 2 小于 A 跳转
   0x0000000000400fe6 <+24>:    lea    -0x1(%rcx),%edx # %edx = （B + C) / 2 - 1 
   0x0000000000400fe9 <+27>:    callq  0x400fce <func4>
   0x0000000000400fee <+32>:    add    %eax,%eax # 返回 2 * %rax
   0x0000000000400ff0 <+34>:    jmp    0x401007 <func4+57>
   0x0000000000400ff2 <+36>:    mov    $0x0,%eax # %eax = 0
   0x0000000000400ff7 <+41>:    cmp    %edi,%ecx # 0 和 （B + C）/ 2 如果相等跳转
   0x0000000000400ff9 <+43>:    jge    0x401007 <func4+57> 
   0x0000000000400ffb <+45>:    lea    0x1(%rcx),%esi # %esi =（B + C）/ 2 + 1
   0x0000000000400ffe <+48>:    callq  0x400fce <func4> # 递归调用
   0x0000000000401003 <+53>:    lea    0x1(%rax,%rax,1),%eax # 返回 2 * %rax  + 1
   0x0000000000401007 <+57>:    add    $0x8,%rsp
   0x000000000040100b <+61>:    retq
End of assembler dump.

根据 x86 汇编语言的约定，%rdi、%rsi、%rdx 分别为第一、二和第三个参数使用的寄存器。%rax 作为返回值所在的寄存器。func4 变换为C语言代码如下：

int func4(int target, int step, int limit) {
    /* edi = target; esi = step; edx = limit */
    int temp = (limit - step) * 0.5;
    int mid = temp + step;
    if (mid > target) {
        limit = mid - 1;
        int ret1 = func4(target, step, limit);
        return 2 * ret1;
    } else {
        if (mid >= target) {
            return 0;
        } else {
            step = mid + 1;
            int ret2 = func4(target, step, limit);
            return (2 * ret2 + 1);
        }
    }
}

最后看看测试结果

阶段五

先看汇编代码

=> 0x0000000000401062 <+0>:    push   %rbx
   0x0000000000401063 <+1>:    sub    $0x20,%rsp
   0x0000000000401067 <+5>:    mov    %rdi,%rbx # %rid保存输入字符串指针,复制到%rbx
   0x000000000040106a <+8>:    mov    %fs:0x28,%rax
   0x0000000000401073 <+17>:    mov    %rax,0x18(%rsp) # 保存%rax
   0x0000000000401078 <+22>:    xor    %eax,%eax # 清零%eax
   0x000000000040107a <+24>:    callq  0x40131b <string_length>
   0x000000000040107f <+29>:    cmp    $0x6,%eax  # 必须为长度为6的字符串
   0x0000000000401082 <+32>:    je     0x4010d2 <phase_5+112>
   0x0000000000401084 <+34>:    callq  0x40143a <explode_bomb>
   0x0000000000401089 <+39>:    jmp    0x4010d2 <phase_5+112>
   0x000000000040108b <+41>:    movzbl (%rbx,%rax,1),%ecx # 复制%rbx中第%rax字符串到%ecx中
   0x000000000040108f <+45>:    mov    %cl,(%rsp) # %cl是%ecx低位，保存单个字符串到（%rsp）中
   0x0000000000401092 <+48>:    mov    (%rsp),%rdx # 把字符串复制到%rdx中
   0x0000000000401096 <+52>:    and    $0xf,%edx # 取低4位
   0x0000000000401099 <+55>:    movzbl 0x4024b0(%rdx),%edx # 将与0x4024b0偏移量为%rdx的一个字节数据复制到%edx
   0x00000000004010a0 <+62>:    mov    %dl,0x10(%rsp,%rax,1) # %dl是%edx的低位，将%edx最低字节复制到与%rsp偏移量为(0x10 + %rax)的栈地址中
   0x00000000004010a4 <+66>:    add    $0x1,%rax # %rax值加1，值向下一个字符串
   0x00000000004010a8 <+70>:    cmp    $0x6,%rax # 判断是否等于6，不等于继续循环
   0x00000000004010ac <+74>:    jne    0x40108b <phase_5+41>
   0x00000000004010ae <+76>:    movb   $0x0,0x16(%rsp)
   0x00000000004010b3 <+81>:    mov    $0x40245e,%esi # %esi指向$0x40245e地址字符串
   0x00000000004010b8 <+86>:    lea    0x10(%rsp),%rdi # 指向前面的字符串
   0x00000000004010bd <+91>:    callq  0x401338 <strings_not_equal> # 判断是否相等
   0x00000000004010c2 <+96>:    test   %eax,%eax
   0x00000000004010c4 <+98>:    je     0x4010d9 <phase_5+119>
   0x00000000004010c6 <+100>:    callq  0x40143a <explode_bomb>
   0x00000000004010cb <+105>:    nopl   0x0(%rax,%rax,1)
   0x00000000004010d0 <+110>:    jmp    0x4010d9 <phase_5+119>
   0x00000000004010d2 <+112>:    mov    $0x0,%eax
   0x00000000004010d7 <+117>:    jmp    0x40108b <phase_5+41>
   0x00000000004010d9 <+119>:    mov    0x18(%rsp),%rax
   0x00000000004010de <+124>:    xor    %fs:0x28,%rax
   0x00000000004010e7 <+133>:    je     0x4010ee <phase_5+140>
   0x00000000004010e9 <+135>:    callq  0x400b30 <__stack_chk_fail@plt>
   0x00000000004010ee <+140>:    add    $0x20,%rsp
   0x00000000004010f2 <+144>:    pop    %rbx
   0x00000000004010f3 <+145>:    retq
(gdb) x/s 0x4024b0
0x4024b0 <array.3449>:    "maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"
(gdb) x/s 0x40245e
0x40245e:    "flyers"

传入一个长度为六的字符串，依次取一个字符，截取它ASCII表上对应二进制的后四位，作为index。在 maduiersnfotvbyl... 这个字符串中以这个 index 为偏移量取字符。按照这样的规则从 maduiersnfotvbyl... 这个字符串中取出六个字符，组成新的字符串，要和 flyers 一样。这个还是很直接的吧，解题就是反过来的顺序。先根据 flyers 找出六个 index。再找个 ASCII 码表，根据 index 找到符合要求的字符。

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
m a d u i e r s n f  o  t  v  b  y  l  

所以 flyers 对应的 index 为 9 15 14 5 6 7，所以输入ionefg 就是其中一个答案。

运行一下

阶段六

先看汇编代码，这个比较长。

(gdb) disas
Dump of assembler code for function phase_6:
=> 0x00000000004010f4 <+0>:    push   %r14
   0x00000000004010f6 <+2>:    push   %r13
   0x00000000004010f8 <+4>:    push   %r12
   0x00000000004010fa <+6>:    push   %rbp
   0x00000000004010fb <+7>:    push   %rbx
   0x00000000004010fc <+8>:    sub    $0x50,%rsp
   0x0000000000401100 <+12>:    mov    %rsp,%r13
   0x0000000000401103 <+15>:    mov    %rsp,%rsi
   0x0000000000401106 <+18>:    callq  0x40145c <read_six_numbers> # 读取6个值，从%rsi地址开始
   0x000000000040110b <+23>:    mov    %rsp,%r14
   0x000000000040110e <+26>:    mov    $0x0,%r12d
   =========================================================== LoopA-start
   0x0000000000401114 <+32>:    mov    %r13,%rbp  # %r12置0,并且%r13 %r14 %rbp 均和 %rsp 指向相同地址
   0x0000000000401117 <+35>:    mov    0x0(%r13),%eax
   0x000000000040111b <+39>:    sub    $0x1,%eax
   0x000000000040111e <+42>:    cmp    $0x5,%eax # 判断输入的数字是否为6个
   0x0000000000401121 <+45>:    jbe    0x401128 <phase_6+52>
   0x0000000000401123 <+47>:    callq  0x40143a <explode_bomb>
   0x0000000000401128 <+52>:    add    $0x1,%r12d # 将%r12加1，相当于index从1到5
   0x000000000040112c <+56>:    cmp    $0x6,%r12d # 判断%r12是否等于6，等于6就跳转
   0x0000000000401130 <+60>:    je     0x401153 <phase_6+95>
   0x0000000000401132 <+62>:    mov    %r12d,%ebx # 将index移到到%ebx
   ----------------------------------------------------------- LoopB-start
   0x0000000000401135 <+65>:    movslq %ebx,%rax # 将%ebx移动到%rax = index
   0x0000000000401138 <+68>:    mov    (%rsp,%rax,4),%eax # 获取输入的6个值
   0x000000000040113b <+71>:    cmp    %eax,0x0(%rbp) # 判端(%rbp)这个值于(%rbp)的第%eax的值是否相等，不相等继续
   0x000000000040113e <+74>:    jne    0x401145 <phase_6+81>
   0x0000000000401140 <+76>:    callq  0x40143a <explode_bomb>
   0x0000000000401145 <+81>:    add    $0x1,%ebx # index加1
   0x0000000000401148 <+84>:    cmp    $0x5,%ebx # index <= 5
   0x000000000040114b <+87>:    jle    0x401135 <phase_6+65> # 跳转到65
   ----------------------------------------------------------- LoopB-end
   0x000000000040114d <+89>:    add    $0x4,%r13 # %r13加4，指向下一个数，判断所有数都不相等
   0x0000000000401151 <+93>:    jmp    0x401114 <phase_6+32> # 跳转到32
   ============================================================ LoopA-end
   0x0000000000401153 <+95>:    lea    0x18(%rsp),%rsi #  将 %rsi 指向栈中跳过读入数据位置作为结束标记,并且 %r14 仍和 %rsp 指向同一个位置
   0x0000000000401158 <+100>:    mov    %r14,%rax # 将%r14复制到%rax
   ============================================================ LoopC-start
   0x000000000040115b <+103>:    mov    $0x7,%ecx # 将0x7复制到%exc
   0x0000000000401160 <+108>:    mov    %ecx,%edx # 将0x7复制到%edx
   0x0000000000401162 <+110>:    sub    (%rax),%edx # 7减去%rax地址的数，也是%rsp的第i个数
   0x0000000000401164 <+112>:    mov    %edx,(%rax) # 在把这个数替换了
   0x0000000000401166 <+114>:    add    $0x4,%rax # 指向下一个数
   0x000000000040116a <+118>:    cmp    %rsi,%rax # 是否全部循环完了
   0x000000000040116d <+121>:    jne    0x401160 <phase_6+108>
   ============================================================ LoopC-end
   0x000000000040116f <+123>:    mov    $0x0,%esi # 将%rsi设置为0
   0x0000000000401174 <+128>:    jmp    0x401197 <phase_6+163> # 获取数据%ecx，和%rdx是一个地址，是一个链表
   0x0000000000401176 <+130>:    mov    0x8(%rdx),%rdx # 将0x8(%rdx)存的内容复制到%rdx，指向下一个
   0x000000000040117a <+134>:    add    $0x1,%eax # %eax加1
   0x000000000040117d <+137>:    cmp    %ecx,%eax # %ecx和%eax 是否相等
   0x000000000040117f <+139>:    jne    0x401176 <phase_6+130> # 不相等，继续遍历
   0x0000000000401181 <+141>:    jmp    0x401188 <phase_6+148> # 相等，跳转到148
   0x0000000000401183 <+143>:    mov    $0x6032d0,%edx # 重置链表首地址
   0x0000000000401188 <+148>:    mov    %rdx,0x20(%rsp,%rsi,2) # 将%rdx的值复制到0x20(%rsp,%rsi,2)
   0x000000000040118d <+153>:    add    $0x4,%rsi # 遍历下一个
   0x0000000000401191 <+157>:    cmp    $0x18,%rsi
   0x0000000000401195 <+161>:    je     0x4011ab <phase_6+183> 
   0x0000000000401197 <+163>:    mov    (%rsp,%rsi,1),%ecx  # 将 (%rsp + %rsi * 1) 数据复制到%ecx，我们前面构造的6个数字
   0x000000000040119a <+166>:    cmp    $0x1,%ecx # 是否小于1
   0x000000000040119d <+169>:    jle    0x401183 <phase_6+143> # 如果小于等于1，%eax指向链表首地址
   0x000000000040119f <+171>:    mov    $0x1,%eax # 将%eax设置为1
   0x00000000004011a4 <+176>:    mov    $0x6032d0,%edx # 将%rdx指向内存 $0x6032d
   0x00000000004011a9 <+181>:    jmp    0x401176 <phase_6+130>
   ---------------------------------------------------------
   0x00000000004011ab <+183>:    mov    0x20(%rsp),%rbx # 将0x20(%rsp)链表信息复制到%rbx
   0x00000000004011b0 <+188>:    lea    0x28(%rsp),%rax # 将%rax指向下一个链表
   0x00000000004011b5 <+193>:    lea    0x50(%rsp),%rsi # 将%rsi指向保存链表地址的末地址
   0x00000000004011ba <+198>:    mov    %rbx,%rcx
   0x00000000004011bd <+201>:    mov    (%rax),%rdx
   0x00000000004011c0 <+204>:    mov    %rdx,0x8(%rcx)
   0x00000000004011c4 <+208>:    add    $0x8,%rax
   0x00000000004011c8 <+212>:    cmp    %rsi,%rax
   0x00000000004011cb <+215>:    je     0x4011d2 <phase_6+222>
   0x00000000004011cd <+217>:    mov    %rdx,%rcx
   0x00000000004011d0 <+220>:    jmp    0x4011bd <phase_6+201>
   ---------------------------------------------------------
   0x00000000004011d2 <+222>:    movq   $0x0,0x8(%rdx)
   0x00000000004011da <+230>:    mov    $0x5,%ebp
   0x00000000004011df <+235>:    mov    0x8(%rbx),%rax # 将%rax指向%rbx下一个节点
   0x00000000004011e3 <+239>:    mov    (%rax),%eax  
   0x00000000004011e5 <+241>:    cmp    %eax,(%rbx) # 比较每个节点是否是递减
   0x00000000004011e7 <+243>:    jge    0x4011ee <phase_6+250>
   0x00000000004011e9 <+245>:    callq  0x40143a <explode_bomb>
   0x00000000004011ee <+250>:    mov    0x8(%rbx),%rbx
   0x00000000004011f2 <+254>:    sub    $0x1,%ebp
   0x00000000004011f5 <+257>:    jne    0x4011df <phase_6+235>
   0x00000000004011f7 <+259>:    add    $0x50,%rsp
   0x00000000004011fb <+263>:    pop    %rbx
   0x00000000004011fc <+264>:    pop    %rbp
   0x00000000004011fd <+265>:    pop    %r12
   0x00000000004011ff <+267>:    pop    %r13
   0x0000000000401201 <+269>:    pop    %r14
   0x0000000000401203 <+271>:    retq
(gdb) x/24xw 0x006032d0
(gdb)  x/24xw 0x006032d0 # 链表为 12 Byte 分别为 int int 指向下一个链表的地址
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

主要过程分为以下几步：

• 获取 6 个数字
• 判断每个数字都大于0且小于7，并且都不相同
• 交换一下位子，arr[i] 与 arr[7-i] 的数交换一下
• 按照获取 arr 的排序的值，把对应的链表进行重新排列
• 重排之后的链表要递减

最后我们看 0x006032d0 地址链表的值，大小顺序为3 4 5 6 1 2 然后我们只要输入4 3 2 1 6 5 就可以。

最后我们看看结果，发现已经全部通过了。

总结

做完这个 lab ，学习到了 gdb 调试方法，对汇编更加深入的了解，总体来说这个实验还是挺有意思的。

参考

• 深入理解计算机系统
• Bomb Lab
• CSAPP 之 Bomb Lab
• CSAPP bomb lab 问题