Tips

缩写注释

CSAPP:Computer Systems A Programmer’s Perspective(深入理解计算机操作系统)。CSAPP(C:P166,O:P278)表示书本的中文版第 166 页,英文原版第 278 页。

寄存器信息

了解寄存器的基本用途,看到一个汇编代码,可以大概了解这个寄存器是在栈中使用的,还是保存参数的,是调用者保存,还是被调用者保存。Responsive Image

GDB

调试过程用到的 GDB 命令可以先参考GDB 调试入门这篇文章。文中所用例子也是摘自与 BombLab 的源码,更容易理解如何使用。还有一定比较重要的是,如何使用 gdb 带参数调试。为了不用每次运行bomb程序都需要重新输入答案,bomb程序可以读取文本信息,在文本文件中写入答案即可免去手动输入。

phase_1

拆弹专家已上线,开干!!!!!!!!!!!!!


(gdb) b phase_1
(gdb) b explode_bomb
(gdb) disas phase_1
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.
  • 3:将栈指针rsp减去 8 个字节,也就是申请 8 个字节的栈空间
  • 4:将一个立即数存到寄存器esi
  • 5:调用函数strings_not_equal,该函数第一条语句的地址为0x401338callq指令的执行过程可参考书本 CSAPP(C:P166,O:P278)
  • 6:使用test命令(同and命令,不修改目标对象的值)来测试eax中的值是否为0,如果为0则跳过引爆炸弹的函数
  • 7:这一句和上一句是一个整体,如果eax==0,就跳转到0x400ef7,这个地址也就是第 9 行的地址,成功跳过了引爆炸弹函数。意思就是我们输入的某个字符串成功匹配,也就是strings_not_equal函数返回值为 0。
  • 8:调用函数explode_bomb,引爆炸弹
  • 9:将栈指针rsp加上 8 个字节,也就是恢复 8 个字节的栈空间
(gdb) disas strings_not_equal 
Dump of assembler code for function strings_not_equal:
=> 0x0000000000401338 <+0>: push   %r12
   0x000000000040133a <+2>: push   %rbp
   0x000000000040133b <+3>: push   %rbx
   0x000000000040133c <+4>: mov    %rdi,%rbx
   0x000000000040133f <+7>: mov    %rsi,%rbp
   0x0000000000401342 <+10>: callq  0x40131b <string_length>
   0x0000000000401347 <+15>: mov    %eax,%r12d
   0x000000000040134a <+18>: mov    %rbp,%rdi
   0x000000000040134d <+21>: callq  0x40131b <string_length>
   0x0000000000401352 <+26>: mov    $0x1,%edx
   0x0000000000401357 <+31>: cmp    %eax,%r12d
   0x000000000040135a <+34>: jne    0x40139b <strings_not_equal+99>
   0x000000000040135c <+36>: movzbl (%rbx),%eax
   0x000000000040135f <+39>: test   %al,%al
   0x0000000000401361 <+41>: je     0x401388 <strings_not_equal+80>
   0x0000000000401363 <+43>: cmp    0x0(%rbp),%al
   0x0000000000401366 <+46>: je     0x401372 <strings_not_equal+58>
   0x0000000000401368 <+48>: jmp    0x40138f <strings_not_equal+87>
   0x000000000040136a <+50>: cmp    0x0(%rbp),%al
   0x000000000040136d <+53>: nopl   (%rax)
   0x0000000000401370 <+56>: jne    0x401396 <strings_not_equal+94>
   0x0000000000401372 <+58>: add    $0x1,%rbx
   0x0000000000401376 <+62>: add    $0x1,%rbp
   0x000000000040137a <+66>: movzbl (%rbx),%eax
   0x000000000040137d <+69>: test   %al,%al
   0x000000000040137f <+71>: jne    0x40136a <strings_not_equal+50>
   0x0000000000401381 <+73>: mov    $0x0,%edx
   0x0000000000401386 <+78>: jmp    0x40139b <strings_not_equal+99>
   0x0000000000401388 <+80>: mov    $0x0,%edx
   0x000000000040138d <+85>: jmp    0x40139b <strings_not_equal+99>
   0x000000000040138f <+87>: mov    $0x1,%edx
   0x0000000000401394 <+92>: jmp    0x40139b <strings_not_equal+99>
   0x0000000000401396 <+94>: mov    $0x1,%edx
   0x000000000040139b <+99>: mov    %edx,%eax
   0x000000000040139d <+101>: pop    %rbx
   0x000000000040139e <+102>: pop    %rbp
   0x000000000040139f <+103>: pop    %r12
   0x00000000004013a1 <+105>: retq   
End of assembler dump.
       
  • 3-5:在函数调用时先保存相关寄存器值,rbprbx就是用来保存两个参数的寄存器
  • 6:将寄存器rdi的值复制到寄存器rbp
  • 7:将寄存器rsi的值复制到寄存器rbx

其实看到这里就一直能够猜到答案是什么了。我们通过之前的phase_1函数能够大概知道需要输入一个值进行比较,如果比较正确就能解除炸弹。现在我们又进入到了这个比较函数,比较函数有两个参数,分别保存在两个寄存器里。我们正常的思维如果写一个比较函数,肯定一个参数是我们输入的值,一个参数是正确的值。

这里看到了rsi寄存器,我们还记得在phase_1函数中第 4 行的esi寄存器吗?这两个寄存器是同一个寄存器,只不过esi是寄存器的低 32 位,既然esi已经赋值了,那剩下的一个参数保存我们输入的内容。所以esi内存的内容就是我们需要的正确答案。我们只要把寄存器esi中的值打印出来,或者内存地址为0x402400的内容打印出来即可。可以通过以下三条命令查看。

(gdb) p (char*)($esi)
$5 = 0x402400 "Border relations with Canada have never been better."
(gdb) x/s 0x402400
0x402400: "Border relations with Canada have never been better."
(gdb) x/s $esi
0x402400: "Border relations with Canada have never been better."

将答案复制,然后继续运行

The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /home/dominic/learning-linux/bomb/bomb 
Welcome to my fiendish little bomb. You have 6 phases with
which to blow yourself up. Have a nice day!
Border relations with Canada have never been better.

Breakpoint 2, 0x0000000000400ee0 in phase_1 ()
(gdb) s
Single stepping until exit from function phase_1,
which has no line number information.
main (argc=<optimized out>, argv=<optimized out>) at bomb.c:75
75     phase_defused();                 /* Drat!  They figured it out!
(gdb) s
77     printf("Phase 1 defused. How about the next one?\n");

从 13 行phase_defused()可以知道我们已经解除了炸弹,从 15 行printf函数也可以看到,需要进行下一个炸弹的拆除。过来人的建议,在这里就开始分析phase_2,寻找答案,因为继续执行就要开始输入内容了,将无法调试。

phase_2

继续分析第二个炸弹,

(gdb) disas phase_2
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)
   0x0000000000400f0e <+18>: je     0x400f30 <phase_2+52>
   0x0000000000400f10 <+20>: callq  0x40143a <explode_bomb>
   0x0000000000400f15 <+25>: jmp    0x400f30 <phase_2+52>
   0x0000000000400f17 <+27>: mov    -0x4(%rbx),%eax
   0x0000000000400f1a <+30>: add    %eax,%eax
   0x0000000000400f1c <+32>: cmp    %eax,(%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
   0x0000000000400f35 <+57>: lea    0x18(%rsp),%rbp
   0x0000000000400f3a <+62>: jmp    0x400f17 <phase_2+27>
   0x0000000000400f3c <+64>: add    $0x28,%rsp
   0x0000000000400f40 <+68>: pop    %rbx
   0x0000000000400f41 <+69>: pop    %rbp
   0x0000000000400f42 <+70>: retq   
End of assembler dump.
  • 3-6:保存程序入口地址,变量等内容,就不再赘述了
  • 7: 调用read_six_numbers函数,根据函数名我们可以猜测这个函数需要读入六个数字
  • 8-9:比较寄存器rsp存的第一个数字是否等于0x1,如果等于就跳转到phase_2+52处继续执行,如果不等于就执行explode_bomb。栈中保存了六个输入的数字,保存顺序是从右往左,假如输入1,2,3,4,5,6。那么入栈的顺序就是6,5,4,3,2,1,寄存器rsp指向栈顶,也就是数字1的地址。
  • 21:假设第一个数字正确,我们跳转到<+52>位置,也就是第 21 行,将rsp+0x4写入寄存器rbx,栈指针向上移动四个字节,也就是取第二个输入的参数,将它赋给寄存器rbx
  • 22:将rsp+0x18写入寄存器rbp,十六进制0x18=24,4 个字节一个数,刚好 6 个数,就是将输入参数的最后一个位置赋给寄存器rbp
  • 23:跳到phase_2+27继续执行
  • 12:rbx-0x4赋给寄存器eax。第 21 行我们知道,rbx此时已经到第二个参数了,这一句就是说把第一个参数的值写入寄存器eax
  • 13:将eax翻一倍,第 8 行知道第一个参数值为1,所以此时eax值为2
  • 14-15:比较eax是否等于rbxrbx此时保存的是第二个参数,这里也就是比较第二个参数是否等于2。如果等于跳转到phase_2+41位置,如果不等于就调用爆炸函数
  • 17-18:假设第二个参数就是 2,我们跳过了炸弹来到第 17 行,将rbx继续上移,然后比较rbp是否等于rbx,我们知道rbp保存了最后一个参数的地址,所以这里的意思就是看看参数有没有到最后一个参数。
  • 19:如果rbx<rbp,意思就是还没到最后一个参数,就跳转到phase_2+27
  • 12:再次回到第 12 行,这里就是相当于一个循环了,让rbx一直向上移动,分别存入第 2,3,4,5,6 个参数,在移动到下一个参数时先保存当前参数到寄存器eax让其翻一倍,然后rbx再移动到下一个参数,比较eax==rbx。直到rbx越过了rbp。程序跳转到phase_2+64,将栈空间恢复。

以上分析也可以得出答案了,我们只要输入一个以1为初值,公比为2,个数为6的等比数列就是答案,也就是1 2 4 8 16 32

(gdb) c
Continuing.
Phase 1 defused. How about the next one?
1 2 4 8 16 32

Breakpoint 6, 0x00000000004015c4 in phase_defused ()
(gdb) s
Single stepping until exit from function phase_defused,
which has no line number information.
main (argc=<optimized out>, argv=<optimized out>) at bomb.c:84
84     printf("That's number 2.  Keep going!\n");
(gdb) s

这个炸弹的作者应该再心狠手辣一点,把函数名换成read_some_numbers,这样我们就不得不看这个函数的内容了,因为这个函数里还有一个坑,这个坑在函数名字上一句被填了。那就是这个函数会对参数个数做判断,如果小于 5 就爆炸。

(gdb) disas read_six_numbers
Dump of assembler code for function read_six_numbers:
   0x000000000040145c <+0>: sub    $0x18,%rsp
   0x0000000000401460 <+4>: mov    %rsi,%rdx
   0x0000000000401463 <+7>: lea    0x4(%rsi),%rcx
   0x0000000000401467 <+11>: lea    0x14(%rsi),%rax
   0x000000000040146b <+15>: mov    %rax,0x8(%rsp)
   0x0000000000401470 <+20>: lea    0x10(%rsi),%rax
   0x0000000000401474 <+24>: mov    %rax,(%rsp)
   0x0000000000401478 <+28>: lea    0xc(%rsi),%r9
   0x000000000040147c <+32>: lea    0x8(%rsi),%r8
   0x0000000000401480 <+36>: mov    $0x4025c3,%esi
   0x0000000000401485 <+41>: mov    $0x0,%eax
   0x000000000040148a <+46>: callq  0x400bf0 <__isoc99_sscanf@plt>
   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.
  • 3:申请 24 个字节栈空间
  • 4:rdx=rsi,将输入参数的第一个参数放到寄存器rdx中,为啥是第一个参数,因为rsi现在保存的地址是栈顶位置,栈顶目前保存就是第一个参数。
  • 5:rcx = rsi + 4,把第二个参数的地址传给寄存器rcx
  • 6:rax = rsi + 20,把第六个参数的地址传给寄存器rax
  • 7:rsp + 8 = rax第八个参数
  • 8:rax = rsi + 16,把第五个参数传给
  • 9:rsp = rax第七个参数
  • 10:r9 = rsi + 12把第四个参数传给寄存器r9
  • 11:r8 = rsi + 8把第三个参数传给寄存器r8
  • 12:
  • 13:eax = 0
  • 14:调用输入函数sscanf
  • 15-17:函数返回值个数与 5 比较,如果小于 5 就爆炸,否则返回

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)
   0x0000000000400f6f <+44>: ja     0x400fad <phase_3+106>
   0x0000000000400f71 <+46>: mov    0x8(%rsp),%eax
   0x0000000000400f75 <+50>: jmpq   *0x402470(,%rax,8)
   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   
  • 1:开辟 24 字节的栈空间
  • 2:rcx = rsp + 12第二个参数
  • 3:rdx = rsp + 8第一个参数
  • 4-8:和phase_2read_six_numbers函数中的第 13 行开始一样,输入数据,判断一下输入参数的个数,只不过这里是返回值个数大于 1,如果参数个数正确就跳到phase_3+39也就是第 10 行,否则引爆炸弹。
  • 10-11:如果7 < rsp + 8 等价于 7 < rdx 等价于 7 < 第一个参数就跳转到phase_3+106,爆炸。这里确定第一个数必须小于 7
  • 12:eax = rsp + 8 等价于 eax = 第一个参数
  • 13:跳转至0x402470 + 8 * rax处,具体跳转到哪里根据第一个值做判断
  • 14:eax = 207
  • 15:跳转至phase_3+123,即 32 行
  • 16:eax = 707
  • 17:跳转到 32 行
  • 18:eax = 256
  • 19:跳转到 32 行
  • 20:eax = 389
  • 21-27:以此类推
  • 29:eax = 0
  • 30:
  • 31:eax = 311
  • 32-34:比较eaxrsp + 12 等价于 比较 第二个参数和eax。如果相等就返回,如果不等就引爆。

分析至此,我们也就知道了程序的大概流程,输入两个值,第一个值必须小于等于 7,第二个值根据第一个值来确定,具体等于多少,根据跳转表确定,因为第一个值有八个数,也就对应着汇编中八段寄存器eax赋值的过程,我们只要输入第一个合法的数值,然后再打印出寄存器eax的值,即可确定答案。

比如我们先测试一下第一个值为 0 时,对应的第二个值为多少,我们输入0 10,因为只是测试,第二个值任意。

That's number 2.  Keep going! //接上个炸弹后面
88     input = read_line();
(gdb) n
0 10              //输入测试答案
89     phase_3(input);
(gdb) n
Breakpoint 4, 0x0000000000400f43 in phase_3 ()
(gdb) n
Single stepping until exit from function phase_3,
which has no line number information.
Breakpoint 2, 0x000000000040143a in explode_bomb ()
(gdb) p $eax
$14 = 207         //207即是答案

输入真正答案测试,

(gdb) n
0 207                         //输入答案
89     phase_3(input);
(gdb) n
Breakpoint 4, 0x0000000000400f43 in phase_3 ()
(gdb) n
Single stepping until exit from function phase_3,
which has no line number information.
main (argc=<optimized out>, argv=<optimized out>) at bomb.c:90
90     phase_defused();    //炸弹拆除
(gdb) 
91     printf("Halfway there!\n");

我们上面说过,第一个值有八种可能,所以这题答案也有八个,我们只要挨个测试0-7,分别打印出寄存器eax的值就可以得到所有答案。他们分别是

0 207
1 311
2 707
3 256
4 389
5 206
6 682
7 327

phase_4

行百里者半九十,NO

(gdb) disas phase_4
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)
   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
   0x000000000040104f <+67>: jne    0x401058 <phase_4+76>
   0x0000000000401051 <+69>: cmpl   $0x0,0xc(%rsp)
   0x0000000000401056 <+74>: je     0x40105d <phase_4+81>
   0x0000000000401058 <+76>: callq  0x40143a <explode_bomb>
   0x000000000040105d <+81>: add    $0x18,%rsp
   0x0000000000401061 <+85>: retq   
  • 1-8:开辟空间,保存参数信息,调用输入函数,和上面的分析重复,不再赘述。注意的是第 6 行,x/s 0x4025cf可知两个参数是整型数值。
  • 9-10:参数个数必须等于 2,否则引爆
  • 11-12:14rsp + 8比较,等价于14与第一个参数比较。表示第一个参数必须小于等于 14,否则引爆。
  • 14:edx = 14
  • 15:esi = 0
  • 16:edi = rsp + 8edi = 第一个参数
  • 17:调用函数fun4,参数分别为edi 0 14
  • 18:测试返回值是否为 0,如果不为 0,引爆
  • 20-22:比较0rsp + 12,如果不等,引爆,否则返回
(gdb) disas func4
Dump of assembler code for function func4:
   0x0000000000400fce <+0>: sub    $0x8,%rsp
   0x0000000000400fd2 <+4>: mov    %edx,%eax
   0x0000000000400fd4 <+6>: sub    %esi,%eax
   0x0000000000400fd6 <+8>: mov    %eax,%ecx
   0x0000000000400fd8 <+10>: shr    $0x1f,%ecx
   0x0000000000400fdb <+13>: add    %ecx,%eax
   0x0000000000400fdd <+15>: sar    %eax
   0x0000000000400fdf <+17>: lea    (%rax,%rsi,1),%ecx
   0x0000000000400fe2 <+20>: cmp    %edi,%ecx
   0x0000000000400fe4 <+22>: jle    0x400ff2 <func4+36>
   0x0000000000400fe6 <+24>: lea    -0x1(%rcx),%edx
   0x0000000000400fe9 <+27>: callq  0x400fce <func4>
   0x0000000000400fee <+32>: add    %eax,%eax
   0x0000000000400ff0 <+34>: jmp    0x401007 <func4+57>
   0x0000000000400ff2 <+36>: mov    $0x0,%eax
   0x0000000000400ff7 <+41>: cmp    %edi,%ecx
   0x0000000000400ff9 <+43>: jge    0x401007 <func4+57>
   0x0000000000400ffb <+45>: lea    0x1(%rcx),%esi
   0x0000000000400ffe <+48>: callq  0x400fce <func4>
   0x0000000000401003 <+53>: lea    0x1(%rax,%rax,1),%eax
   0x0000000000401007 <+57>: add    $0x8,%rsp
   0x000000000040100b <+61>: retq   
func (edi, esi, edx)
{
   // edi = 第一个参数, esi = 0, edx = 14
   eax = edx            // 4:mov %edx, %eax
   eax = eax -esi       // 5:sub esi, %eax
   eax = edx -esi
   ecx = eax            // 6:mov %eax, %ecx
   ecx = edx - esi
   eсx = ecx >> 31      // 7:shr  $0x1f, %ecx
   ecx = (edx - esi) >> 31
   eax = eax + ecx      // 8:add %ecx, %eax
   eax = (edx - esi) + ((edx - esi) >> 31)//替换eax和ecx
   eax = eax > 1;       // 9:sar %eax
   eax = ((edx - esi) +((edx -esi) >> 31)) / 2
   ecx = eax + esi * 1   // 10:lea (rax,ersi,1), %ecx
   ecx = ((edx - esi) +((edx -esi) >> 31)) / 2 + esi * 1

   ecx = ((14 - 0) + ((14 - 0) >> 31)) / 2 + 0
   ecx = 7

   // 11:cmp %edi, %ecx
   if (ecx <= edi)
   {
      // 12:jle 400ff2
      eax = 0    // mov $0x0,%eax
      // 18:cmp %edi, %ecx
      if(ecx >= edi)
      {
         // 19:jge    0x401007 <func4+57>
         return;
         //由此可以得知道 edx == edi
      }
   }
}

phase_5

   0x0000000000401062 <+0>: push   %rbx
   0x0000000000401063 <+1>: sub    $0x20,%rsp
   0x0000000000401067 <+5>: mov    %rdi,%rbx
   0x000000000040106a <+8>: mov    %fs:0x28,%rax
   0x0000000000401073 <+17>: mov    %rax,0x18(%rsp)
   0x0000000000401078 <+22>: xor    %eax,%eax
   0x000000000040107a <+24>: callq  0x40131b <string_length>
   0x000000000040107f <+29>: cmp    $0x6,%eax
   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
   0x000000000040108f <+45>: mov    %cl,(%rsp)
   0x0000000000401092 <+48>: mov    (%rsp),%rdx
   0x0000000000401096 <+52>: and    $0xf,%edx
   0x0000000000401099 <+55>: movzbl 0x4024b0(%rdx),%edx
   0x00000000004010a0 <+62>: mov    %dl,0x10(%rsp,%rax,1)
   0x00000000004010a4 <+66>: add    $0x1,%rax
   0x00000000004010a8 <+70>: cmp    $0x6,%rax
   0x00000000004010ac <+74>: jne    0x40108b <phase_5+41>
   0x00000000004010ae <+76>: movb   $0x0,0x16(%rsp)
   0x00000000004010b3 <+81>: mov    $0x40245e,%esi
      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