GDB的全称是：GNU symbolic debugger。在做实验之前，了解常见的GDB命令是必不可少的。常见GDB命令可以访问：https://deconx.top/2022/02/22/gdb/

实验概览

BombLab提供给我们的文件非常简单，只有一个编译不了的C文件bomb.c，和一个目标代码文件bomb。当运行bomb文件时，它会要求输入6个字符串，如果其中的任何一句是错的，炸弹就会“爆炸”。我们必须利用反汇编工具逆向分析这个文件，并找到这6个字符串，从而“拆除”炸弹。

这个实验看起来就非常有趣！

运行一下bomb文件：

提示我们输入内容，先随便输入试试！

BOOM! ，炸弹果然爆炸了！接下来就要进行紧张刺激的拆弹环节了。

实验过程

bomb.c代码分析

每一个phase的结构都是相同的，这里仅以phase_1为例。

前两行将我们的输入传入phase_1函数中，如果函数能成功返回，则接下来调用phase_defused函数，从字面意思理解，此时炸弹就拆除成功了。

那么炸弹什么时候爆炸呢，当然就是函数无法返回的时候了，猜测phase_1会调用一个中断程序，直接退出了程序。

所以我们的任务就是分析每一个phase_x函数，使用正确的输入，使得函数能够成功返回。

phase_1

反汇编 phase_1

使用gdb的disassemble命令反汇编phase_1

Dump of assembler code for function phase_1:
   0x0000000000400ee0 <+0>:     sub    $0x8,%rsp
   0x0000000000400ee4 <+4>:     mov    $0x402400,%esi
   0x0000000000400ee9 <+9>:     callq  0x401338 
   0x0000000000400eee <+14>:    test   %eax,%eax
   0x0000000000400ef0 <+16>:    je     0x400ef7 
   0x0000000000400ef2 <+18>:    callq  0x40143a 
   0x0000000000400ef7 <+23>:    add    $0x8,%rsp
   0x0000000000400efb <+27>:    retq
End of assembler dump.

• 第2行，为函数分配栈帧
• 第3行，设置函数strings_not_equal传入参数
• 第4行，调用函数strings_not_equal，从字面意思理解，猜想如果传入字符串不同，则返回0
• 第5、6行，函数strings_not_equal的返回值储存在%eax中，判断其是否为0，若为0，则跳至第8行，函数返回，炸弹拆除成功；若不为0，则跳至第7行
• 第7行，调用explode_bomb函数，从字面意思理解，炸弹爆炸了。

于是，只需利用x/s指令查看0x402400位置对应内存存的字符串即可：

这句话就是phase_1了

key

Border relations with Canada have never been better.

成功!

phase_2

剩下部分的phase调用与phase_1都十分类似，直接反汇编即可

反汇编phase_2

全部代码暂不放出，后面分析时再贴上，方便查看

先看前几行

   0x0000000000400efc <+0>:     push   %rbp
   0x0000000000400efd <+1>:     push   %rbx
   0x0000000000400efe <+2>:     sub    $0x28,%rsp

• 第1，2行，将被调用者保存寄存器的值入栈
• 第3行，分配栈帧

   0x0000000000400f02 <+6>:     mov    %rsp,%rsi
   0x0000000000400f05 <+9>:     callq  0x40145c 

• 第5，6行，将栈顶指针%rsp传给%rsi，并作为参数调用函数read_six_numbers。从字面意思理解，本题是要我们输入6个数字。这里mov %rsp,%rsi的目的是保存caller中栈顶的位置，方便在read_six_numbers中进行改值。我们不妨反汇编read_six_numbers

此时，栈的情况为：

反汇编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 
   0x0000000000401494 <+56>:    callq  0x40143a 
   0x0000000000401499 <+61>:    add    $0x18,%rsp
   0x000000000040149d <+65>:    retq
End of assembler dump.

截至第10行，寄存器及栈存储内容的指向如图所示：

在这个函数中，要做到传6个参数，用来存储6个输入的数字。很明显，这里传入了6个指针，其中4个存在寄存器上，另外2个存在栈上。由于phase_2函数中的栈指针rsp与这个函数中的rsi相等，所以把所有参数存在rsi之前的位置的目的是在返回phase_2函数后，能够直接利用phase_2函数的栈指针来连续地访问这6个数字。

注意到M[%rsp+0x4]没有用来传参数，这是为什么呢？

因为通过栈传递参数时，所有的数据大小都向8的倍数对齐。

下面的问题就是如何确定这6个数字的先后位置，传递参数的寄存器使用顺序如下：

所以，我们应该输入的6个数字所在的位置就分别是：R[%rsp] R[%rsp+0x8] %rsi %rsi+0x4 %rsi+0x8 %rsi+0xc

返回phase_2函数后，利用栈顶指针调用就是： %rsp %rsp+0x4 %rsp+0x8 %rsp+0xc %rsp+0x10 %rsp+0x14

回到 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 
   0x0000000000400f0a <+14>:    cmpl   $0x1,(%rsp)
   0x0000000000400f0e <+18>:    je     0x400f30 
   0x0000000000400f10 <+20>:    callq  0x40143a 
   0x0000000000400f15 <+25>:    jmp    0x400f30 
   0x0000000000400f17 <+27>:    mov    -0x4(%rbx),%eax
   0x0000000000400f1a <+30>:    add    %eax,%eax
   0x0000000000400f1c <+32>:    cmp    %eax,(%rbx)
   0x0000000000400f1e <+34>:    je     0x400f25 
   0x0000000000400f20 <+36>:    callq  0x40143a 
   0x0000000000400f25 <+41>:    add    $0x4,%rbx
   0x0000000000400f29 <+45>:    cmp    %rbp,%rbx
   0x0000000000400f2c <+48>:    jne    0x400f17 
   0x0000000000400f2e <+50>:    jmp    0x400f3c 
   0x0000000000400f30 <+52>:    lea    0x4(%rsp),%rbx
   0x0000000000400f35 <+57>:    lea    0x18(%rsp),%rbp
   0x0000000000400f3a <+62>:    jmp    0x400f17 
   0x0000000000400f3c <+64>:    add    $0x28,%rsp
   0x0000000000400f40 <+68>:    pop    %rbx
   0x0000000000400f41 <+69>:    pop    %rbp
   0x0000000000400f42 <+70>:    retq
End of assembler dump.

• 第7，8，9行，比较(%rsp)与1是否相等，不相等则引爆。可知第一个数为 1
• 看第20行，第2个数存在0x(%rsp)中，设为num_2，则(%rbx)=num_2。跳到第11行，这一行将第一个数赋值给%eax，12，13行是将其翻倍再进行同样的比较。可知第二个数为2
• 跳到第16行，得到了第三个数的地址，第17行把我迷惑了很久，rbp和rbx肯定是不相等的，不知道这样设置的意义。继续跳到第17行，进入循环。
• 这里循环的规律是，每个数都要与上一个数的2倍相等，从而可以得到剩下的4个数分别为：4，8，16，32

key

1 2 4 8 16 32

成功！

phase_3

反汇编 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 
   0x0000000000400f65 <+34>:    callq  0x40143a 
   0x0000000000400f6a <+39>:    cmpl   $0x7,0x8(%rsp)
   0x0000000000400f6f <+44>:    ja     0x400fad 
   0x0000000000400f71 <+46>:    mov    0x8(%rsp),%eax
   0x0000000000400f75 <+50>:    jmpq   *0x402470(,%rax,8)
   0x0000000000400f7c <+57>:    mov    $0xcf,%eax
   0x0000000000400f81 <+62>:    jmp    0x400fbe 
   0x0000000000400f83 <+64>:    mov    $0x2c3,%eax
   0x0000000000400f88 <+69>:    jmp    0x400fbe 
   0x0000000000400f8a <+71>:    mov    $0x100,%eax
   0x0000000000400f8f <+76>:    jmp    0x400fbe 
   0x0000000000400f91 <+78>:    mov    $0x185,%eax
   0x0000000000400f96 <+83>:    jmp    0x400fbe 
   0x0000000000400f98 <+85>:    mov    $0xce,%eax
   0x0000000000400f9d <+90>:    jmp    0x400fbe 
   0x0000000000400f9f <+92>:    mov    $0x2aa,%eax
   0x0000000000400fa4 <+97>:    jmp    0x400fbe 
   0x0000000000400fa6 <+99>:    mov    $0x147,%eax
   0x0000000000400fab <+104>:   jmp    0x400fbe 
   0x0000000000400fad <+106>:   callq  0x40143a 
   0x0000000000400fb2 <+111>:   mov    $0x0,%eax
   0x0000000000400fb7 <+116>:   jmp    0x400fbe 
   0x0000000000400fb9 <+118>:   mov    $0x137,%eax
   0x0000000000400fbe <+123>:   cmp    0xc(%rsp),%eax
   0x0000000000400fc2 <+127>:   je     0x400fc9 
   0x0000000000400fc4 <+129>:   callq  0x40143a 
   0x0000000000400fc9 <+134>:   add    $0x18,%rsp
   0x0000000000400fcd <+138>:   retq
End of assembler dump.

这道题与上道题非常类似。

• 首先看第5行，查看0x4025cf位置的内容。可以知道，要求传入2个数字

• 由上道题的启法，第2，3，4行就指明了两个数字的位置分别在栈空间%rsp+0x8和%rsp+0xc。
• 第8，9，10行属于程序健壮性的考虑，判断是否输入了两个数字，否则直接引爆
• 第11，12行，说明了第一个数字应该小于等于7
• 第14行，要求跳到内存0x402470(,%rax,8)里面存的位置。rax指向的内存此时存的就是第1个数，我们只知道这个数时小于等于7的，这里随便假设其为 1 试试！那么接下来就要跳到内存0x402478中的地址
• 查看内存0x402478中的内容：

• 所以，下面就跳到0x0000000000400fb9对应代码，也就是第32行，结合第33行知，第二个数字为\(7+3\times 16+1\times 16^2=311\)，于是得到key: 1 311

发现成功了！

• 再试试设第1个数为2，则接下来跳转到0x0000000000400f83，即第17行，则第2个数为707。于是得到key: 2 707, 同样成功了！

key

phase_3的含金量远远不如不如phase_2，可能是为了让我们在拆弹中途轻松一下。

这道题的亮点在于其开放性，第一个数可以取0到7中的任意一个，根据第一个数的情况来确定第二个数，所以最后能够通过的答案有8组，不一一列举了。

phase_4

反汇编 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 
   0x000000000040102e <+34>:    cmpl   $0xe,0x8(%rsp)
   0x0000000000401033 <+39>:    jbe    0x40103a 
   0x0000000000401035 <+41>:    callq  0x40143a 
   0x000000000040103a <+46>:    mov    $0xe,%edx
   0x000000000040103f <+51>:    mov    $0x0,%esi
   0x0000000000401044 <+56>:    mov    0x8(%rsp),%edi
   0x0000000000401048 <+60>:    callq  0x400fce 
   0x000000000040104d <+65>:    test   %eax,%eax
   0x000000000040104f <+67>:    jne    0x401058 
   0x0000000000401051 <+69>:    cmpl   $0x0,0xc(%rsp)
   0x0000000000401056 <+74>:    je     0x40105d 
   0x0000000000401058 <+76>:    callq  0x40143a 
   0x000000000040105d <+81>:    add    $0x18,%rsp
   0x0000000000401061 <+85>:    retq
End of assembler dump.

• 这道题代码风格与前两题也非常相似，查看第5行知，依旧是读入两个数字，设第一个数字为num1，第二个数字为num2。其中num1存在(%rsp+0x8)中，num2存在(%rsp+0xc)中。
• 第10，11行，若\(num1 \leq 14\)，则继续，否则爆炸
• 第13，14，15，16行，分别设置参数(%edx) = 0xe，(%esi) = 0x0，(%edi) = num1之后调用函数func4
• 第17行，要看到调用完func4函数后，func4的返回值存在%eax中，只有(%eax)=0也就是func4的返回值为0，才能拆除炸弹。
• 第19行，只有(%rsp+0xc)=0才能拆除炸弹，因此num2 = 0

反汇编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 
   0x0000000000400fe6 <+24>:    lea    -0x1(%rcx),%edx
   0x0000000000400fe9 <+27>:    callq  0x400fce 
   0x0000000000400fee <+32>:    add    %eax,%eax
   0x0000000000400ff0 <+34>:    jmp    0x401007 
   0x0000000000400ff2 <+36>:    mov    $0x0,%eax
   0x0000000000400ff7 <+41>:    cmp    %edi,%ecx
   0x0000000000400ff9 <+43>:    jge    0x401007 
   0x0000000000400ffb <+45>:    lea    0x1(%rcx),%esi
   0x0000000000400ffe <+48>:    callq  0x400fce 
   0x0000000000401003 <+53>:    lea    0x1(%rax,%rax,1),%eax
   0x0000000000401007 <+57>:    add    $0x8,%rsp
   0x000000000040100b <+61>:    retq
End of assembler dump.

这是一个递归调用的函数，我们写出它的C语言代码：

int func4 ( int edi, int esi, int edx )//初始值:edi=num1,esi=0x0,edx=0xe
{// 返回值为eax
	eax = edx - esi;  //3、4行
    eax = (eax + (eax >> 31)) >> 1;  //5-8行
    ecx = eax + exi;  //9行
	if(edi < ecx) 
		return 	2 * func4(edi, esi, edx - 1); //14行
	else if (edi > ecx)
		return 	2 * func4(edi, esi + 1, edx) + 1; //21行
	else
		return	0;
}

根据3，4，5行，容易求得eax=0x7，要进入返回0的分区，则edi=eax=0x7，所以num1=7

key

7 0

成功！

phase_5

反汇编phase_5

这里不将全部代码放出，我们分块分析

Part 1

   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 
   0x000000000040107f <+29>:    cmp    $0x6,%eax
   0x0000000000401082 <+32>:    je     0x4010d2 
   0x0000000000401084 <+34>:    callq  0x40143a 

• 第3行，%rdi是用来传递参数的第一个寄存器，猜测此时我们输入的字符串就存在(%rdi)中，该行将其值赋给了%rbx
• 第4，5行，把fs段偏移0x28的一个数据储存到%rsp+0x18处，这是为了防止缓存区溢出。
• 第6行，自己与自己异或，清零。
• 第7-10行，比较我们输入的字符串长度是否为6，否则爆炸。说明此题要求输入一个长度为6的字符串。接下来跳到0x4010d2处的代码

   0x00000000004010d2 <+112>:   mov    $0x0,%eax
   0x00000000004010d7 <+117>:   jmp    0x40108b 

• 清空(%eax)后跳至d7处，接下来作为part2部分讲解

Part 2

   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 

这段代码是一个循环

• (%eax)在跳转前已经被清空了，从第7，8两行可以看出，(%rax)是计数变量，在每次循环后+1，直到等于6时跳出循环。
• 先看第一轮循环。第1行，%rbx中存放着我们输入的字符串的地址，此时(%rax)=0x0，因此%ecx就存放着字符串的第一个字符，设六个字符分别为ch[0],ch[1],ch[2],ch[3],ch[4],ch[5]，则每轮循环到这里，(%ecx)=ch[(%rax)]
• 第3-4行，%cl是%ecx的低八位，一直到第4行，与操作的目的就是只取(%ecx)的最低四位
• 第5行，这里给了一个内存地址，我们先查看一下：

得到字符串：

maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?

• 第5行是将%edx的值修改为0x4024b0(%rdx)位置的字符。换句话说，(%rdx)在这里起到了索引的作用，比如(%rdx)=0x1，就是将a字符传给%edx

• 后面是将上一句的得到的字符传入栈中保存，(%rax)同样作为栈的索引，第一个字符就储存在(%rsp+0x10)

我尝试写出这段循环的伪代码：

string s = "maduiersnfotvbyl"
for(int rax = 0; rax < 6; rax++)
{
	ecx = ch[rax];     //取输入字符串的第rax个字符
    edx = ecx & 0xf;   //取第rax个字符ASCII码的最低四位
    edx = s[edx];	   //取给定内存中字符串的第edx个字符
	rsp[16+rax] = edx; //edx -> 栈
}

• 退出循环时，栈上从(%rsp+0x10)开始按顺序存储着6个索引到的字符

• 循环结束后的代码作为Part 3讲解

Part 3

   0x00000000004010ae <+76>:    movb   $0x0,0x16(%rsp)
   0x00000000004010b3 <+81>:    mov    $0x40245e,%esi
   0x00000000004010b8 <+86>:    lea    0x10(%rsp),%rdi
   0x00000000004010bd <+91>:    callq  0x401338 
   0x00000000004010c2 <+96>:    test   %eax,%eax
   0x00000000004010c4 <+98>:    je     0x4010d9 
   0x00000000004010c6 <+100>:   callq  0x40143a 
   0x00000000004010cb <+105>:   nopl   0x0(%rax,%rax,1)
   0x00000000004010d0 <+110>:   jmp    0x4010d9 
   0x00000000004010d2 <+112>:   mov    $0x0,%eax
   0x00000000004010d7 <+117>:   jmp    0x40108b 
   0x00000000004010d9 <+119>:   mov    0x18(%rsp),%rax
   0x00000000004010de <+124>:   xor    %fs:0x28,%rax
   0x00000000004010e7 <+133>:   je     0x4010ee 
   0x00000000004010e9 <+135>:   callq  0x400b30 <__stack_chk_fail@plt>
   0x00000000004010ee <+140>:   add    $0x20,%rsp
   0x00000000004010f2 <+144>:   pop    %rbx
   0x00000000004010f3 <+145>:   retq

• 第2行，查看0x40245e位置内存的内容

• 接下来就是调用strings_not_equal函数，判断栈上的六个字符与这6个字符是否相等。操作与phase_1相同。
• 做到这里，离胜利只差一步之遥。

key

先捋一捋思路：由part3可知，最后返回的字符应该是flyers。而这6个字符是怎么得来的呢？由part2，是通过取我们输入六个字符的ASCII码的低四位作为索引值，查找maduiersnfotvbyl里的字符组成的。

maduiersnfotvbyl中f为第9位，l为第15位，y第14位，e第5位，r第6位，s第7位

也就是说，我们需要输入6个字符，使它们ASCII码低四位分别是：1001, 1111, 1110, 0101, 0110, 0111

由a的ASCII码为01100001，即可定位到6个字符分别为：ionuvw

成功！

由于只限制了ASCII的低4位，所以本题的答案也不止一个，不再一一列举了。

phase_6

反汇编phase_6

phase_6的代码非常长，这里将代码分成6块分别分析

Part 1

   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，有没有很眼熟的感觉？我们在phase_2中已经详细分析并画了图。这个函数调用的结果是调用者的栈上按顺序存储输入的6个数

返回后，栈及指针情况为：

Part 2

   0x000000000040110b <+23>:    mov    %rsp,%r14
   0x000000000040110e <+26>:    mov    $0x0,%r12d
   0x0000000000401114 <+32>:    mov    %r13,%rbp
   0x0000000000401117 <+35>:    mov    0x0(%r13),%eax
   0x000000000040111b <+39>:    sub    $0x1,%eax
   0x000000000040111e <+42>:    cmp    $0x5,%eax
   0x0000000000401121 <+45>:    jbe    0x401128 
   0x0000000000401123 <+47>:    callq  0x40143a 
   0x0000000000401128 <+52>:    add    $0x1,%r12d
   0x000000000040112c <+56>:    cmp    $0x6,%r12d
   0x0000000000401130 <+60>:    je     0x401153 
   0x0000000000401132 <+62>:    mov    %r12d,%ebx
   0x0000000000401135 <+65>:    movslq %ebx,%rax
   0x0000000000401138 <+68>:    mov    (%rsp,%rax,4),%eax
   0x000000000040113b <+71>:    cmp    %eax,0x0(%rbp)
   0x000000000040113e <+74>:    jne    0x401145 
   0x0000000000401140 <+76>:    callq  0x40143a 
   0x0000000000401145 <+81>:    add    $0x1,%ebx
   0x0000000000401148 <+84>:    cmp    $0x5,%ebx
   0x000000000040114b <+87>:    jle    0x401135 
   0x000000000040114d <+89>:    add    $0x4,%r13
   0x0000000000401151 <+93>:    jmp    0x401114 

• 第5，6，7行，(%eax)=num[0]，由\(num[0]-1\le 5\) 知num[0]不大于6
• 先看21，22行，意识到这里有一个大循环，每次将(%r13)加4，之后回到第3行，(%r13)赋给了(%eax)，这时，(%eax)=num[1]；再有后面的判断知，对任意i，都有num[i]不大于6
• 9，10，11，12行给出了退出大循环的条件，就是6个数字全部遍历到
• 注意18，19，20行，这里又有一个循环，是为了判断数组元素是否相等

写出Part 2的C语言代码如下

//为了简化代码，将指针转化为数组索引
r14 = 0;
r13 = 0;
r12d = 0;
while(1){			//第3行
	rbp = r13;
	if(num[r13] - 1 > 5)	//第4,5,6行
		goto bomb;
	r12d++;			
	if(r12d == 6)	//第10行
		break;
	for(ebx = r12d; ebx <= 5; ebx++){	//第14行
		if(num[ebx] == num[rbp])		//第13,14,15行
			goto bomb;
	}
	r13++;
}

• 可见，这部分代码给输入数字提了两个要求：
  • 每个数字不大于6
  • 数字互不相同

Part 3

   0x0000000000401153 <+95>:    lea    0x18(%rsp),%rsi
   0x0000000000401158 <+100>:   mov    %r14,%rax
   0x000000000040115b <+103>:   mov    $0x7,%ecx
   0x0000000000401160 <+108>:   mov    %ecx,%edx
   0x0000000000401162 <+110>:   sub    (%rax),%edx
   0x0000000000401164 <+112>:   mov    %edx,(%rax)
   0x0000000000401166 <+114>:   add    $0x4,%rax
   0x000000000040116a <+118>:   cmp    %rsi,%rax
   0x000000000040116d <+121>:   jne    0x401160 

这又是一段循环，但是比Part 2简单得多。话不多说，直接写出C语言代码

rsi = 7;
for(rax = 0; rax != rsi; rax++)
{
	num[rax] = 7 - num[rax];
}

也就是对输入的数字进行了一波简单变换。为了方便描述，假设变换后的数字为n[i]。易知，n[0]-n[5]是数字1-6的一个组合。

Part 4

   0x000000000040116f <+123>:   mov    $0x0,%esi
   0x0000000000401174 <+128>:   jmp    0x401197 
   0x0000000000401176 <+130>:   mov    0x8(%rdx),%rdx
   0x000000000040117a <+134>:   add    $0x1,%eax
   0x000000000040117d <+137>:   cmp    %ecx,%eax
   0x000000000040117f <+139>:   jne    0x401176 
   0x0000000000401181 <+141>:   jmp    0x401188 
   0x0000000000401183 <+143>:   mov    $0x6032d0,%edx
   0x0000000000401188 <+148>:   mov    %rdx,0x20(%rsp,%rsi,2)
   0x000000000040118d <+153>:   add    $0x4,%rsi
   0x0000000000401191 <+157>:   cmp    $0x18,%rsi
   0x0000000000401195 <+161>:   je     0x4011ab 
   0x0000000000401197 <+163>:   mov    (%rsp,%rsi,1),%ecx
   0x000000000040119a <+166>:   cmp    $0x1,%ecx
   0x000000000040119d <+169>:   jle    0x401183 
   0x000000000040119f <+171>:   mov    $0x1,%eax
   0x00000000004011a4 <+176>:   mov    $0x6032d0,%edx
   0x00000000004011a9 <+181>:   jmp    0x401176 

• 第13行，%ecx=n[0]，接着判断其与1大小关系，由于n[0]不小于1，所以这步判断相当于：若n[0]等于1，跳到第8行
• 第8行这里，给了一个地址，我们查看一下：

这实际上是一个链表，每个结点的结构如下：

struct node{
    int val;
    int number;
    node* next;
}
// node[1]->next = node[2],...以此类推

• 第9行，此时(%rdx)指向的就是第一个节点，把它放到(%rsp+0x20)的位置

• 返回上一步，如果n[0]不等于1，在3-6行有一个循环。我们写出它的C语言代码

//ecx = n[i]
*rdx = node[1];	//17行
for(eax = 1; eax != ecx; eax ++){
    rdx = rdx -> next;	//第3行
}

• 可见这一步的目的是移动指针，找到对应的结点，移动多少位呢？显然是移动n[i]-1位，换句话说，这一步找到node[n[i]]位置的结点

• 第8行，将结点压栈，继续循环，对另外5个数字进行同样操作。到了这里我们就可以理解Part 4的操作了，它是通过我们输入的六个数字分别作为索引对链表进行重排。

该步完成后，栈的情况如下：

Part 5

   0x00000000004011ab <+183>:   mov    0x20(%rsp),%rbx
   0x00000000004011b0 <+188>:   lea    0x28(%rsp),%rax
   0x00000000004011b5 <+193>:   lea    0x50(%rsp),%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 
   0x00000000004011cd <+217>:   mov    %rdx,%rcx
   0x00000000004011d0 <+220>:   jmp    0x4011bd 

这是一个循环，由于指针关系过于繁琐，我在这里重构了一个与它同功能的C语言代码

for(int i = 0, j = 1; j <= 5; i++, j++){
    node[n[i]].next = node[n[j]];
}

这段代码的意图很明显，按栈内链表结点的位置顺序重排单链表

Part 6

胜利已经近在咫尺啦！

   0x00000000004011d2 <+222>:   movq   $0x0,0x8(%rdx)
   0x00000000004011da <+230>:   mov    $0x5,%ebp
   0x00000000004011df <+235>:   mov    0x8(%rbx),%rax
   0x00000000004011e3 <+239>:   mov    (%rax),%eax
   0x00000000004011e5 <+241>:   cmp    %eax,(%rbx)
   0x00000000004011e7 <+243>:   jge    0x4011ee 
   0x00000000004011e9 <+245>:   callq  0x40143a 
   0x00000000004011ee <+250>:   mov    0x8(%rbx),%rbx
   0x00000000004011f2 <+254>:   sub    $0x1,%ebp
   0x00000000004011f5 <+257>:   jne    0x4011df 
   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

• 第4-10行是一个循环，首先(%rbx)指向node[n[0]]，第5行，(%eax)存node[n[1]]，如果node[n[0]]小于node[n[1]]则爆炸，这样遍历一遍。
• 由此可知，node[i]的值在栈中应该是递减的。
• 先将node[i].value排下序：node[3]>node[4]>node[5]>node[6]>node[1]>node[2]
• 因此：n[0]=3,n[1]=4,n[2]=5,n[3]=6,n[4]=1,n[5]=2

key

由于我们输入的是num[i]，而num[i]=7-n[i]，因此输入的六个数字分别是：4 3 2 1 6 5

成功了！

secret_phase

本实验就这样完结了么？事情并没有那么简单~

我是参考他人的解析才发现隐藏关的存在。

在bomb.c的末尾有这样一行注释：

    /* Wow, they got it!  But isn't something... missing?  Perhaps
     * something they overlooked?  Mua ha ha ha ha! */

刚刚完成最后一关成就感满满的我心生疑惑，我忽略了什么？

反汇编phase_defused

   0x00000000004015c4 <+0>:     sub    $0x78,%rsp
   0x00000000004015c8 <+4>:     mov    %fs:0x28,%rax
   0x00000000004015d1 <+13>:    mov    %rax,0x68(%rsp)
   0x00000000004015d6 <+18>:    xor    %eax,%eax
   0x00000000004015d8 <+20>:    cmpl   $0x6,0x202181(%rip)        # 0x603760 
   0x00000000004015df <+27>:    jne    0x40163f 
   0x00000000004015e1 <+29>:    lea    0x10(%rsp),%r8
   0x00000000004015e6 <+34>:    lea    0xc(%rsp),%rcx
   0x00000000004015eb <+39>:    lea    0x8(%rsp),%rdx
   0x00000000004015f0 <+44>:    mov    $0x402619,%esi
   0x00000000004015f5 <+49>:    mov    $0x603870,%edi
   0x00000000004015fa <+54>:    callq  0x400bf0 <__isoc99_sscanf@plt>
   0x00000000004015ff <+59>:    cmp    $0x3,%eax
   0x0000000000401602 <+62>:    jne    0x401635 
   0x0000000000401604 <+64>:    mov    $0x402622,%esi
   0x0000000000401609 <+69>:    lea    0x10(%rsp),%rdi
   0x000000000040160e <+74>:    callq  0x401338 
   0x0000000000401613 <+79>:    test   %eax,%eax
   0x0000000000401615 <+81>:    jne    0x401635 
   0x0000000000401617 <+83>:    mov    $0x4024f8,%edi
   0x000000000040161c <+88>:    callq  0x400b10 
   0x0000000000401621 <+93>:    mov    $0x402520,%edi
   0x0000000000401626 <+98>:    callq  0x400b10 
   0x000000000040162b <+103>:   mov    $0x0,%eax
   0x0000000000401630 <+108>:   callq  0x401242 
   0x0000000000401635 <+113>:   mov    $0x402558,%edi
   0x000000000040163a <+118>:   callq  0x400b10 
   0x000000000040163f <+123>:   mov    0x68(%rsp),%rax
   0x0000000000401644 <+128>:   xor    %fs:0x28,%rax
   0x000000000040164d <+137>:   je     0x401654 
   0x000000000040164f <+139>:   callq  0x400b30 <__stack_chk_fail@plt>
   0x0000000000401654 <+144>:   add    $0x78,%rsp
   0x0000000000401658 <+148>:   retq

• 查看第10行给的内存地址：

• 第11行，很奇怪，这里给的地址对应的内存是空的。
• 第12，13，14行，(%eax)储存着输入字符的数量，将其与3比较。在前几关中，并没有哪一关要输入3个字符。由此判断，这里就是进入隐藏关卡的关键。
• 假设输入了3个字符，则会执行15-25行。15行给了一个内存地址，查看一下：

• 接下来就是常规的判断字符串是否相等，一直到第19行，是说明如果字符串不相等依旧进不了隐藏关。

根据以上判断，进入隐藏关的条件是，在某一个只需要输入两个数字的关卡中后面加上“DrEvil”。但是，phase_3和phase_4的答案均为两个数字，我们无法判断。

• 突破口为第11行位置对应的内存，隐藏关入口的那一关输入的答案一定会存在这个内存中，否则后续无法比较判断。我们打断点看一下：

这不正是phase_4的答案吗！隐藏关我来了！

反汇编secret_phase

Dump of assembler code for function secret_phase:
   0x0000000000401242 <+0>:     push   %rbx
   0x0000000000401243 <+1>:     callq  0x40149e 
   0x0000000000401248 <+6>:     mov    $0xa,%edx
   0x000000000040124d <+11>:    mov    $0x0,%esi
   0x0000000000401252 <+16>:    mov    %rax,%rdi
   0x0000000000401255 <+19>:    callq  0x400bd0 
   0x000000000040125a <+24>:    mov    %rax,%rbx
   0x000000000040125d <+27>:    lea    -0x1(%rax),%eax
   0x0000000000401260 <+30>:    cmp    $0x3e8,%eax
   0x0000000000401265 <+35>:    jbe    0x40126c 
   0x0000000000401267 <+37>:    callq  0x40143a 
   0x000000000040126c <+42>:    mov    %ebx,%esi
   0x000000000040126e <+44>:    mov    $0x6030f0,%edi
   0x0000000000401273 <+49>:    callq  0x401204 
   0x0000000000401278 <+54>:    cmp    $0x2,%eax
   0x000000000040127b <+57>:    je     0x401282 
   0x000000000040127d <+59>:    callq  0x40143a 
   0x0000000000401282 <+64>:    mov    $0x402438,%edi
   0x0000000000401287 <+69>:    callq  0x400b10 
   0x000000000040128c <+74>:    callq  0x4015c4 
   0x0000000000401291 <+79>:    pop    %rbx
   0x0000000000401292 <+80>:    retq
End of assembler dump.

• 关注13，14行，这里要调用函数fun7，输入了两个参数，%esi存的是我们输入的数，%edi存了一个内存地址，等会再看
• 第16行，比较fun7返回值与2的关系，若相等，则成功返回。
• 读到这，就明确了我们的任务：使fun7返回2

反汇编fun7

Dump of assembler code for function fun7:
   0x0000000000401204 <+0>:     sub    $0x8,%rsp
   0x0000000000401208 <+4>:     test   %rdi,%rdi
   0x000000000040120b <+7>:     je     0x401238 
   0x000000000040120d <+9>:     mov    (%rdi),%edx
   0x000000000040120f <+11>:    cmp    %esi,%edx
   0x0000000000401211 <+13>:    jle    0x401220 
   0x0000000000401213 <+15>:    mov    0x8(%rdi),%rdi
   0x0000000000401217 <+19>:    callq  0x401204 
   0x000000000040121c <+24>:    add    %eax,%eax
   0x000000000040121e <+26>:    jmp    0x40123d 
   0x0000000000401220 <+28>:    mov    $0x0,%eax
   0x0000000000401225 <+33>:    cmp    %esi,%edx
   0x0000000000401227 <+35>:    je     0x40123d 
   0x0000000000401229 <+37>:    mov    0x10(%rdi),%rdi
   0x000000000040122d <+41>:    callq  0x401204 
   0x0000000000401232 <+46>:    lea    0x1(%rax,%rax,1),%eax
   0x0000000000401236 <+50>:    jmp    0x40123d 
   0x0000000000401238 <+52>:    mov    $0xffffffff,%eax
   0x000000000040123d <+57>:    add    $0x8,%rsp
   0x0000000000401241 <+61>:    retq
End of assembler dump.

• 第6行，比较我们的数与传入内存地址中存的数，

• 查看该地址存的内容：

这类似树结构，结构定义如下：

struct tree{
    int val;
    struct tree* left;
    struct tree* right;
}

根据节点关系，画出树：

根据其大小关系，猜测是一个二叉排序树。接下来返回原函数查看

• 这是一个递归调用的函数，写出它的C语言代码如下：

int fun7(Tree* rdi, int esi) {
	if (!rdi)	//第3，4行
		return -1;	//19
	if (rdi->val == esi)	//13
		return 0;		//20
	else if (rdi->val < esi)		//7
		return 2 * fun7(rdi -> right, esi) + 1;	//15,16
	else
		return 2 * fun7(rdi -> left, esi);	//8,9
}

• 是一个类查找的过程，最后结果应该返回2
• 我们逆推找到这个数：
• 要想返回2，则上一次返回值一定为1，并且从左子树返回
• 要想返回1，则上一次返回值一定为0，并且从右子树返回
• 返回值为0，则当前结点的值就是输入的值
• 所以我们从36开始，先到左子树8，再到右子树22。最终结果就是22。

key

22

成功！

至此，该实验的全部关卡包括隐藏关卡就都通过啦！

总结

• CMU 的 Bomblab 果然名不虚传，我做完之后顿觉浑身通透，酣畅淋漓。

• phase_1和phase_2都是对基本功的考察，很容易就能做出来；从phase_3开始，代码量一下子就上去了，各种循环，函数嵌套，以及递归调用，令人脑容量爆炸，做这种题必须先将其转化为C语言代码；part_5的逻辑设定最令我惊艳，它通过输入的字符的ASCII来定位原本存在的字符，层层破解，快感十足；phase_6和secret_phase耗时最长，逻辑繁复，但对我的提升也是最大的，它们让我了解到各种数据结构的机器级实现方式，让我面对一大堆狰狞的代码依旧能静下心来慢慢揣摩。

• 本实验耗时4天，约18小时。