CSAPPLAB-Bomb Lab

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，该函数第一条语句的地址为0x401338。callq指令的执行过程可参考书本 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：在函数调用时先保存相关寄存器值，rbp和rbx就是用来保存两个参数的寄存器
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是否等于rbx。rbx此时保存的是第二个参数，这里也就是比较第二个参数是否等于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_2里read_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：比较eax和rsp + 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的值就可以得到所有答案。他们分别是

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：14与rsp + 8比较，等价于14与第一个参数比较。表示第一个参数必须小于等于 14，否则引爆。
14：edx = 14
15：esi = 0
16：edi = rsp + 8即edi = 第一个参数
17：调用函数fun4，参数分别为edi 0 14
18：测试返回值是否为 0，如果不为 0，引爆
20-22：比较0和rsp + 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

Tips#

缩写注释#

寄存器信息#

GDB#

phase_1#

phase_2#

phase_3#

phase_4#

phase_5#