目录

  • 实验概览
  • 实验过程
    • `bomb.c`代码分析
    • phase_1
      • 反汇编 phase_1
      • key
    • phase_2
      • 反汇编phase_2
        • 反汇编read_six_numbers
        • 回到 phase_2
      • key
    • phase_3
      • 反汇编 phase_3
      • key
    • phase_4
      • 反汇编 phase_4
        • 反汇编func4
      • key
    • phase_5
      • 反汇编phase_5
        • Part 1
        • Part 2
        • Part 3
      • key
    • phase_6
      • 反汇编phase_6
        • Part 1
        • Part 2
        • Part 3
        • Part 4
        • Part 5
        • Part 6
      • key
    • secret_phase
      • 反汇编`phase_defused`
      • 反汇编`secret_phase`
        • 反汇编`fun7`
      • key
  • 总结

实验概览

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,%rsp0x0000000000400ee4 <+4>:     mov    $0x402400,%esi0x0000000000400ee9 <+9>:     callq  0x401338 <strings_not_equal>0x0000000000400eee <+14>:    test   %eax,%eax0x0000000000400ef0 <+16>:    je     0x400ef7 <phase_1+23>0x0000000000400ef2 <+18>:    callq  0x40143a <explode_bomb>0x0000000000400ef7 <+23>:    add    $0x8,%rsp0x0000000000400efb <+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   %rbp0x0000000000400efd <+1>:     push   %rbx0x0000000000400efe <+2>:     sub    $0x28,%rsp
  • 第1，2行，将被调用者保存寄存器的值入栈
  • 第3行，分配栈帧
   0x0000000000400f02 <+6>:     mov    %rsp,%rsi0x0000000000400f05 <+9>:     callq  0x40145c <read_six_numbers>
  • 第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,%rsp0x0000000000401460 <+4>:     mov    %rsi,%rdx0x0000000000401463 <+7>:     lea    0x4(%rsi),%rcx0x0000000000401467 <+11>:    lea    0x14(%rsi),%rax0x000000000040146b <+15>:    mov    %rax,0x8(%rsp)0x0000000000401470 <+20>:    lea    0x10(%rsi),%rax0x0000000000401474 <+24>:    mov    %rax,(%rsp)0x0000000000401478 <+28>:    lea    0xc(%rsi),%r90x000000000040147c <+32>:    lea    0x8(%rsi),%r80x0000000000401480 <+36>:    mov    $0x4025c3,%esi0x0000000000401485 <+41>:    mov    $0x0,%eax0x000000000040148a <+46>:    callq  0x400bf0 <__isoc99_sscanf@plt>0x000000000040148f <+51>:    cmp    $0x5,%eax0x0000000000401492 <+54>:    jg     0x401499 <read_six_numbers+61>0x0000000000401494 <+56>:    callq  0x40143a <explode_bomb>0x0000000000401499 <+61>:    add    $0x18,%rsp0x000000000040149d <+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   %rbp0x0000000000400efd <+1>:     push   %rbx0x0000000000400efe <+2>:     sub    $0x28,%rsp0x0000000000400f02 <+6>:     mov    %rsp,%rsi0x0000000000400f05 <+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),%eax0x0000000000400f1a <+30>:    add    %eax,%eax0x0000000000400f1c <+32>:    cmp    %eax,(%rbx)0x0000000000400f1e <+34>:    je     0x400f25 <phase_2+41>0x0000000000400f20 <+36>:    callq  0x40143a <explode_bomb>0x0000000000400f25 <+41>:    add    $0x4,%rbx0x0000000000400f29 <+45>:    cmp    %rbp,%rbx0x0000000000400f2c <+48>:    jne    0x400f17 <phase_2+27>0x0000000000400f2e <+50>:    jmp    0x400f3c <phase_2+64>0x0000000000400f30 <+52>:    lea    0x4(%rsp),%rbx0x0000000000400f35 <+57>:    lea    0x18(%rsp),%rbp0x0000000000400f3a <+62>:    jmp    0x400f17 <phase_2+27>0x0000000000400f3c <+64>:    add    $0x28,%rsp0x0000000000400f40 <+68>:    pop    %rbx0x0000000000400f41 <+69>:    pop    %rbp0x0000000000400f42 <+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,%rsp0x0000000000400f47 <+4>:     lea    0xc(%rsp),%rcx0x0000000000400f4c <+9>:     lea    0x8(%rsp),%rdx0x0000000000400f51 <+14>:    mov    $0x4025cf,%esi0x0000000000400f56 <+19>:    mov    $0x0,%eax0x0000000000400f5b <+24>:    callq  0x400bf0 <__isoc99_sscanf@plt>0x0000000000400f60 <+29>:    cmp    $0x1,%eax0x0000000000400f63 <+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),%eax0x0000000000400f75 <+50>:    jmpq   *0x402470(,%rax,8)0x0000000000400f7c <+57>:    mov    $0xcf,%eax0x0000000000400f81 <+62>:    jmp    0x400fbe <phase_3+123>0x0000000000400f83 <+64>:    mov    $0x2c3,%eax0x0000000000400f88 <+69>:    jmp    0x400fbe <phase_3+123>0x0000000000400f8a <+71>:    mov    $0x100,%eax0x0000000000400f8f <+76>:    jmp    0x400fbe <phase_3+123>0x0000000000400f91 <+78>:    mov    $0x185,%eax0x0000000000400f96 <+83>:    jmp    0x400fbe <phase_3+123>0x0000000000400f98 <+85>:    mov    $0xce,%eax0x0000000000400f9d <+90>:    jmp    0x400fbe <phase_3+123>0x0000000000400f9f <+92>:    mov    $0x2aa,%eax0x0000000000400fa4 <+97>:    jmp    0x400fbe <phase_3+123>0x0000000000400fa6 <+99>:    mov    $0x147,%eax0x0000000000400fab <+104>:   jmp    0x400fbe <phase_3+123>0x0000000000400fad <+106>:   callq  0x40143a <explode_bomb>0x0000000000400fb2 <+111>:   mov    $0x0,%eax0x0000000000400fb7 <+116>:   jmp    0x400fbe <phase_3+123>0x0000000000400fb9 <+118>:   mov    $0x137,%eax0x0000000000400fbe <+123>:   cmp    0xc(%rsp),%eax0x0000000000400fc2 <+127>:   je     0x400fc9 <phase_3+134>0x0000000000400fc4 <+129>:   callq  0x40143a <explode_bomb>0x0000000000400fc9 <+134>:   add    $0x18,%rsp0x0000000000400fcd <+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×16+1×162=3117+3\times 16+1\times 16^2=3117+3×16+1×162=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,%rsp0x0000000000401010 <+4>:     lea    0xc(%rsp),%rcx0x0000000000401015 <+9>:     lea    0x8(%rsp),%rdx0x000000000040101a <+14>:    mov    $0x4025cf,%esi0x000000000040101f <+19>:    mov    $0x0,%eax0x0000000000401024 <+24>:    callq  0x400bf0 <__isoc99_sscanf@plt>0x0000000000401029 <+29>:    cmp    $0x2,%eax0x000000000040102c <+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,%edx0x000000000040103f <+51>:    mov    $0x0,%esi0x0000000000401044 <+56>:    mov    0x8(%rsp),%edi0x0000000000401048 <+60>:    callq  0x400fce <func4>0x000000000040104d <+65>:    test   %eax,%eax0x000000000040104f <+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,%rsp0x0000000000401061 <+85>:    retq
End of assembler dump.
  • 这道题代码风格与前两题也非常相似，查看第5行知，依旧是读入两个数字，设第一个数字为num1，第二个数字为num2。其中num1存在(%rsp+0x8)中，num2存在(%rsp+0xc)中。
  • 第10，11行，若num1≤14num1 \leq 14num1≤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,%rsp0x0000000000400fd2 <+4>:     mov    %edx,%eax0x0000000000400fd4 <+6>:     sub    %esi,%eax0x0000000000400fd6 <+8>:     mov    %eax,%ecx0x0000000000400fd8 <+10>:    shr    $0x1f,%ecx0x0000000000400fdb <+13>:    add    %ecx,%eax0x0000000000400fdd <+15>:    sar    %eax0x0000000000400fdf <+17>:    lea    (%rax,%rsi,1),%ecx0x0000000000400fe2 <+20>:    cmp    %edi,%ecx0x0000000000400fe4 <+22>:    jle    0x400ff2 <func4+36>0x0000000000400fe6 <+24>:    lea    -0x1(%rcx),%edx0x0000000000400fe9 <+27>:    callq  0x400fce <func4>0x0000000000400fee <+32>:    add    %eax,%eax0x0000000000400ff0 <+34>:    jmp    0x401007 <func4+57>0x0000000000400ff2 <+36>:    mov    $0x0,%eax0x0000000000400ff7 <+41>:    cmp    %edi,%ecx0x0000000000400ff9 <+43>:    jge    0x401007 <func4+57>0x0000000000400ffb <+45>:    lea    0x1(%rcx),%esi0x0000000000400ffe <+48>:    callq  0x400fce <func4>0x0000000000401003 <+53>:    lea    0x1(%rax,%rax,1),%eax0x0000000000401007 <+57>:    add    $0x8,%rsp0x000000000040100b <+61>:    retq
End of assembler dump.

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

int func4 ( int edi, int esi, int edx )//初始值:edi=num1,esi=0x0,edx=0xe
{// 返回值为eaxeax = 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行elsereturn 0;
}

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

key

7 0

成功！

phase_5

反汇编phase_5

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

Part 1

   0x0000000000401062 <+0>:     push   %rbx0x0000000000401063 <+1>:     sub    $0x20,%rsp0x0000000000401067 <+5>:     mov    %rdi,%rbx0x000000000040106a <+8>:     mov    %fs:0x28,%rax0x0000000000401073 <+17>:    mov    %rax,0x18(%rsp)0x0000000000401078 <+22>:    xor    %eax,%eax0x000000000040107a <+24>:    callq  0x40131b <string_length>0x000000000040107f <+29>:    cmp    $0x6,%eax0x0000000000401082 <+32>:    je     0x4010d2 <phase_5+112>0x0000000000401084 <+34>:    callq  0x40143a <explode_bomb>
  • 第3行，%rdi是用来传递参数的第一个寄存器，猜测此时我们输入的字符串就存在(%rdi)中，该行将其值赋给了%rbx
  • 第4，5行，把fs段偏移0x28的一个数据储存到%rsp+0x18处，这是为了防止缓存区溢出。
  • 第6行，自己与自己异或，清零。
  • 第7-10行，比较我们输入的字符串长度是否为6，否则爆炸。说明此题要求输入一个长度为6的字符串。接下来跳到0x4010d2处的代码
   0x00000000004010d2 <+112>:   mov    $0x0,%eax0x00000000004010d7 <+117>:   jmp    0x40108b <phase_5+41>
  • 清空(%eax)后跳至d7处，接下来作为part2部分讲解

Part 2

   0x000000000040108b <+41>:    movzbl (%rbx,%rax,1),%ecx0x000000000040108f <+45>:    mov    %cl,(%rsp)0x0000000000401092 <+48>:    mov    (%rsp),%rdx0x0000000000401096 <+52>:    and    $0xf,%edx0x0000000000401099 <+55>:    movzbl 0x4024b0(%rdx),%edx0x00000000004010a0 <+62>:    mov    %dl,0x10(%rsp,%rax,1)0x00000000004010a4 <+66>:    add    $0x1,%rax0x00000000004010a8 <+70>:    cmp    $0x6,%rax0x00000000004010ac <+74>:    jne    0x40108b <phase_5+41>

这段代码是一个循环

  • (%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,%esi0x00000000004010b8 <+86>:    lea    0x10(%rsp),%rdi0x00000000004010bd <+91>:    callq  0x401338 <strings_not_equal>0x00000000004010c2 <+96>:    test   %eax,%eax0x00000000004010c4 <+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,%eax0x00000000004010d7 <+117>:   jmp    0x40108b <phase_5+41>0x00000000004010d9 <+119>:   mov    0x18(%rsp),%rax0x00000000004010de <+124>:   xor    %fs:0x28,%rax0x00000000004010e7 <+133>:   je     0x4010ee <phase_5+140>0x00000000004010e9 <+135>:   callq  0x400b30 <__stack_chk_fail@plt>0x00000000004010ee <+140>:   add    $0x20,%rsp0x00000000004010f2 <+144>:   pop    %rbx0x00000000004010f3 <+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   %r140x00000000004010f6 <+2>:     push   %r130x00000000004010f8 <+4>:     push   %r120x00000000004010fa <+6>:     push   %rbp0x00000000004010fb <+7>:     push   %rbx0x00000000004010fc <+8>:     sub    $0x50,%rsp0x0000000000401100 <+12>:    mov    %rsp,%r130x0000000000401103 <+15>:    mov    %rsp,%rsi0x0000000000401106 <+18>:    callq  0x40145c <read_six_numbers>
  • 前几行是保存参数，分配栈帧
  • 看到read_six_numbers，有没有很眼熟的感觉？我们在phase_2中已经详细分析并画了图。这个函数调用的结果是调用者的栈上按顺序存储输入的6个数

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

Part 2

   0x000000000040110b <+23>:    mov    %rsp,%r140x000000000040110e <+26>:    mov    $0x0,%r12d0x0000000000401114 <+32>:    mov    %r13,%rbp0x0000000000401117 <+35>:    mov    0x0(%r13),%eax0x000000000040111b <+39>:    sub    $0x1,%eax0x000000000040111e <+42>:    cmp    $0x5,%eax0x0000000000401121 <+45>:    jbe    0x401128 <phase_6+52>0x0000000000401123 <+47>:    callq  0x40143a <explode_bomb>0x0000000000401128 <+52>:    add    $0x1,%r12d0x000000000040112c <+56>:    cmp    $0x6,%r12d0x0000000000401130 <+60>:    je     0x401153 <phase_6+95>0x0000000000401132 <+62>:    mov    %r12d,%ebx0x0000000000401135 <+65>:    movslq %ebx,%rax0x0000000000401138 <+68>:    mov    (%rsp,%rax,4),%eax0x000000000040113b <+71>:    cmp    %eax,0x0(%rbp)0x000000000040113e <+74>:    jne    0x401145 <phase_6+81>0x0000000000401140 <+76>:    callq  0x40143a <explode_bomb>0x0000000000401145 <+81>:    add    $0x1,%ebx0x0000000000401148 <+84>:    cmp    $0x5,%ebx0x000000000040114b <+87>:    jle    0x401135 <phase_6+65>0x000000000040114d <+89>:    add    $0x4,%r130x0000000000401151 <+93>:    jmp    0x401114 <phase_6+32>
  • 第5，6，7行，(%eax)=num[0]，由num[0]−1≤5num[0]-1\le 5num[0]−1≤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),%rsi0x0000000000401158 <+100>:   mov    %r14,%rax0x000000000040115b <+103>:   mov    $0x7,%ecx0x0000000000401160 <+108>:   mov    %ecx,%edx0x0000000000401162 <+110>:   sub    (%rax),%edx0x0000000000401164 <+112>:   mov    %edx,(%rax)0x0000000000401166 <+114>:   add    $0x4,%rax0x000000000040116a <+118>:   cmp    %rsi,%rax0x000000000040116d <+121>:   jne    0x401160 <phase_6+108>

这又是一段循环，但是比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,%esi0x0000000000401174 <+128>:   jmp    0x401197 <phase_6+163>0x0000000000401176 <+130>:   mov    0x8(%rdx),%rdx0x000000000040117a <+134>:   add    $0x1,%eax0x000000000040117d <+137>:   cmp    %ecx,%eax0x000000000040117f <+139>:   jne    0x401176 <phase_6+130>0x0000000000401181 <+141>:   jmp    0x401188 <phase_6+148>0x0000000000401183 <+143>:   mov    $0x6032d0,%edx0x0000000000401188 <+148>:   mov    %rdx,0x20(%rsp,%rsi,2)0x000000000040118d <+153>:   add    $0x4,%rsi0x0000000000401191 <+157>:   cmp    $0x18,%rsi0x0000000000401195 <+161>:   je     0x4011ab <phase_6+183>0x0000000000401197 <+163>:   mov    (%rsp,%rsi,1),%ecx0x000000000040119a <+166>:   cmp    $0x1,%ecx0x000000000040119d <+169>:   jle    0x401183 <phase_6+143>0x000000000040119f <+171>:   mov    $0x1,%eax0x00000000004011a4 <+176>:   mov    $0x6032d0,%edx0x00000000004011a9 <+181>:   jmp    0x401176 <phase_6+130>
  • 第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),%rbx0x00000000004011b0 <+188>:   lea    0x28(%rsp),%rax0x00000000004011b5 <+193>:   lea    0x50(%rsp),%rsi0x00000000004011ba <+198>:   mov    %rbx,%rcx0x00000000004011bd <+201>:   mov    (%rax),%rdx0x00000000004011c0 <+204>:   mov    %rdx,0x8(%rcx)0x00000000004011c4 <+208>:   add    $0x8,%rax0x00000000004011c8 <+212>:   cmp    %rsi,%rax0x00000000004011cb <+215>:   je     0x4011d2 <phase_6+222>0x00000000004011cd <+217>:   mov    %rdx,%rcx0x00000000004011d0 <+220>:   jmp    0x4011bd <phase_6+201>

这是一个循环，由于指针关系过于繁琐，我在这里重构了一个与它同功能的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,%ebp0x00000000004011df <+235>:   mov    0x8(%rbx),%rax0x00000000004011e3 <+239>:   mov    (%rax),%eax0x00000000004011e5 <+241>:   cmp    %eax,(%rbx)0x00000000004011e7 <+243>:   jge    0x4011ee <phase_6+250>0x00000000004011e9 <+245>:   callq  0x40143a <explode_bomb>0x00000000004011ee <+250>:   mov    0x8(%rbx),%rbx0x00000000004011f2 <+254>:   sub    $0x1,%ebp0x00000000004011f5 <+257>:   jne    0x4011df <phase_6+235>0x00000000004011f7 <+259>:   add    $0x50,%rsp0x00000000004011fb <+263>:   pop    %rbx0x00000000004011fc <+264>:   pop    %rbp0x00000000004011fd <+265>:   pop    %r120x00000000004011ff <+267>:   pop    %r130x0000000000401201 <+269>:   pop    %r140x0000000000401203 <+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,%rsp0x00000000004015c8 <+4>:     mov    %fs:0x28,%rax0x00000000004015d1 <+13>:    mov    %rax,0x68(%rsp)0x00000000004015d6 <+18>:    xor    %eax,%eax0x00000000004015d8 <+20>:    cmpl   $0x6,0x202181(%rip)        # 0x603760 <num_input_strings>0x00000000004015df <+27>:    jne    0x40163f <phase_defused+123>0x00000000004015e1 <+29>:    lea    0x10(%rsp),%r80x00000000004015e6 <+34>:    lea    0xc(%rsp),%rcx0x00000000004015eb <+39>:    lea    0x8(%rsp),%rdx0x00000000004015f0 <+44>:    mov    $0x402619,%esi0x00000000004015f5 <+49>:    mov    $0x603870,%edi0x00000000004015fa <+54>:    callq  0x400bf0 <__isoc99_sscanf@plt>0x00000000004015ff <+59>:    cmp    $0x3,%eax0x0000000000401602 <+62>:    jne    0x401635 <phase_defused+113>0x0000000000401604 <+64>:    mov    $0x402622,%esi0x0000000000401609 <+69>:    lea    0x10(%rsp),%rdi0x000000000040160e <+74>:    callq  0x401338 <strings_not_equal>0x0000000000401613 <+79>:    test   %eax,%eax0x0000000000401615 <+81>:    jne    0x401635 <phase_defused+113>0x0000000000401617 <+83>:    mov    $0x4024f8,%edi0x000000000040161c <+88>:    callq  0x400b10 <puts@plt>0x0000000000401621 <+93>:    mov    $0x402520,%edi0x0000000000401626 <+98>:    callq  0x400b10 <puts@plt>0x000000000040162b <+103>:   mov    $0x0,%eax0x0000000000401630 <+108>:   callq  0x401242 <secret_phase>0x0000000000401635 <+113>:   mov    $0x402558,%edi0x000000000040163a <+118>:   callq  0x400b10 <puts@plt>0x000000000040163f <+123>:   mov    0x68(%rsp),%rax0x0000000000401644 <+128>:   xor    %fs:0x28,%rax0x000000000040164d <+137>:   je     0x401654 <phase_defused+144>0x000000000040164f <+139>:   callq  0x400b30 <__stack_chk_fail@plt>0x0000000000401654 <+144>:   add    $0x78,%rsp0x0000000000401658 <+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   %rbx0x0000000000401243 <+1>:     callq  0x40149e <read_line>0x0000000000401248 <+6>:     mov    $0xa,%edx0x000000000040124d <+11>:    mov    $0x0,%esi0x0000000000401252 <+16>:    mov    %rax,%rdi0x0000000000401255 <+19>:    callq  0x400bd0 <strtol@plt>0x000000000040125a <+24>:    mov    %rax,%rbx0x000000000040125d <+27>:    lea    -0x1(%rax),%eax0x0000000000401260 <+30>:    cmp    $0x3e8,%eax0x0000000000401265 <+35>:    jbe    0x40126c <secret_phase+42>0x0000000000401267 <+37>:    callq  0x40143a <explode_bomb>0x000000000040126c <+42>:    mov    %ebx,%esi0x000000000040126e <+44>:    mov    $0x6030f0,%edi0x0000000000401273 <+49>:    callq  0x401204 <fun7>0x0000000000401278 <+54>:    cmp    $0x2,%eax0x000000000040127b <+57>:    je     0x401282 <secret_phase+64>0x000000000040127d <+59>:    callq  0x40143a <explode_bomb>0x0000000000401282 <+64>:    mov    $0x402438,%edi0x0000000000401287 <+69>:    callq  0x400b10 <puts@plt>0x000000000040128c <+74>:    callq  0x4015c4 <phase_defused>0x0000000000401291 <+79>:    pop    %rbx0x0000000000401292 <+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,%rsp0x0000000000401208 <+4>:     test   %rdi,%rdi0x000000000040120b <+7>:     je     0x401238 <fun7+52>0x000000000040120d <+9>:     mov    (%rdi),%edx0x000000000040120f <+11>:    cmp    %esi,%edx0x0000000000401211 <+13>:    jle    0x401220 <fun7+28>0x0000000000401213 <+15>:    mov    0x8(%rdi),%rdi0x0000000000401217 <+19>:    callq  0x401204 <fun7>0x000000000040121c <+24>:    add    %eax,%eax0x000000000040121e <+26>:    jmp    0x40123d <fun7+57>0x0000000000401220 <+28>:    mov    $0x0,%eax0x0000000000401225 <+33>:    cmp    %esi,%edx0x0000000000401227 <+35>:    je     0x40123d <fun7+57>0x0000000000401229 <+37>:    mov    0x10(%rdi),%rdi0x000000000040122d <+41>:    callq  0x401204 <fun7>0x0000000000401232 <+46>:    lea    0x1(%rax,%rax,1),%eax0x0000000000401236 <+50>:    jmp    0x40123d <fun7+57>0x0000000000401238 <+52>:    mov    $0xffffffff,%eax0x000000000040123d <+57>:    add    $0x8,%rsp0x0000000000401241 <+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;    //19if (rdi->val == esi)   //13return 0;       //20else if (rdi->val < esi)      //7return 2 * fun7(rdi -> right, esi) + 1;  //15,16elsereturn 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小时。

CSAPP-Lab02 Bomb Lab 详细解析相关推荐

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

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

  2. CSAPP——Lab2——Bomb Lab

    本篇博客是<深入理解计算机系统>实验记录的第二篇,也是非常有名的炸弹实验.首先吐槽一下学校的这个实验代码不更新的问题,教材和上课讲授的均是x86-64位汇编语言,结果实验给的还是第二版配套 ...

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

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

  4. CSAPP Lab2 实验记录 ---- Bomb Lab（Phase 1 - Phase 6详细解答 + Secret Phase彩蛋解析）

    文章目录 Lab 总结博客链接 实验前提引子 实验需要指令及准备 Phase 1 Phase 2 Phase 3 Phase 4 Phase 5 Phase 6 Phase Secret(彩蛋Phas ...

  5. CSAPP Bomb Lab记录

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

  6. CSAPP Bomb Lab

    CSAPP Bomb Lab bomb lab给了我们一个bomb的可执行文件,以及一个bomb.c的源文件,不过这个文件只是程序的逻辑逻辑框架,无法编译.进入bomb.c可以看到程序的流程是有6个p ...

  7. CSAPP实验二：二进制炸弹（Bomb Lab）

    本系列文章为中国科学技术大学计算机专业学科基础课<计算机系统>布置的实验,上课所用教材和内容为黑书CSAPP,当时花费很大精力和弯路,现来总结下各个实验,本文章为第二个实验--二进制炸弹( ...

  8. CSAPP实验之Bomb Lab详解

    前言 Bomb Lab来自<深入理解计算机系统>(CSAPP)一书的第三章"程序的机器级表示"的配套实验,该实验的目的是通过反汇编可执行程序,来反推出程序执行内容,进而 ...

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

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

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

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

最新文章

  1. ios实例开发精品源码文章推荐
  2. 本地化在ASP.NET 2.0中的实现
  3. Windows PE导出表编程4（重构导出表实现私有函数导出）
  4. 再见，再见，5 * 60 * 1000 //五分钟，再见，再见
  5. 02-线性结构2 一元多项式的乘法与加法运算 （20 分
  6. 12条守则：让你成功创业当老板
  7. pickle.dump()把大量数据写入文件发生MemoryError解决方法
  8. 一年多的远程办公带给我的感悟
  9. 每天一道剑指offer-二叉搜索数的后序遍历序列
  10. robocopy复制文件_Windows Robocopy命令教程以及以安全方式复制文件的示例
  11. linux虚拟机rzsz安装（wget方法，自测可用）
  12. candence与matlab电路仿真,电力电子电路仿真：MATLAB和PSpice应用
  13. 数据湖统一存储在 OPPO 的实践
  14. Matlab入门：实现简单的数据剔除
  15. 波动方程，达朗贝尔解和亥姆霍兹方程
  16. 电脑硬盘分区不见了怎么恢复数据？方法来啦
  17. latex数学公式编写（一）：latex矩阵编写
  18. 修改USB默认选中MTP模式
  19. 中专计算机毕业生登记表自我鉴定,中专毕业生登记表自我鉴定范文（精选5篇）...
  20. UCK区块链私享沙龙第二期圆满结束，感恩晚宴再聚共识

热门文章

  1. c语言贪吃蛇游戏视频,贪吃蛇游戏，贪吃蛇游戏视频
  2. 关于一台机器运行两个身份证读卡器模块（总结）
  3. binomial检验_R卡方检验的详细解析过程_R计算二项Binomial分布的P
  4. Linux 系统 /var/log/journal/ 垃圾日志清理
  5. c语言12M345,ADXL345倾角传感器模块资料+单片机程序
  6. 半次元收藏夹爬虫（残疾版，不喜勿喷）
  7. 拉丁超立方体抽样方法学习笔记
  8. PCB Layout初学者必会知识总结（转）
  9. 大话设计模式C++实现-第7章-代理模式
  10. 求生之路怎么显示服务器ip,怎么在求生之路后台查看本机局域网IP