CSAPP-Lab02 Bomb Lab 详细解析

目录

  • 实验概览
  • 实验过程
    • `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文件:

CSAPP-Lab02 Bomb Lab 详细解析_第1张图片

提示我们输入内容,先随便输入试试!

CSAPP-Lab02 Bomb Lab 详细解析_第2张图片

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

实验过程

bomb.c代码分析

CSAPP-Lab02 Bomb Lab 详细解析_第3张图片

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

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

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

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

phase_1

反汇编 phase_1

使用gdbdisassemble命令反汇编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位置对应内存存的字符串即可:

image-20220224170749197

这句话就是phase_1

key

Border relations with Canada have never been better.

CSAPP-Lab02 Bomb Lab 详细解析_第4张图片

成功!

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

此时,栈的情况为:

CSAPP-Lab02 Bomb Lab 详细解析_第5张图片

反汇编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行,寄存器及栈存储内容的指向如图所示:

CSAPP-Lab02 Bomb Lab 详细解析_第6张图片

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

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

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

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

CSAPP-Lab02 Bomb Lab 详细解析_第7张图片

所以,我们应该输入的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行把我迷惑了很久,rbprbx肯定是不相等的,不知道这样设置的意义。继续跳到第17行,进入循环。
  • 这里循环的规律是,每个数都要与上一个数的2倍相等,从而可以得到剩下的4个数分别为:4,8,16,32

key

1 2 4 8 16 32

CSAPP-Lab02 Bomb Lab 详细解析_第8张图片

成功!

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个数字

image-20220225143138464

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

image-20220225144723573

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

image-20220225145341466

发现成功了!

  • 再试试设第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行,若 n u m 1 ≤ 14 num1 \leq 14 num114,则继续,否则爆炸
  • 第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

image-20220225230440595

成功!

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行,这里给了一个内存地址,我们先查看一下:

image-20220226150753736

得到字符串:

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位置内存的内容

image-20220226155413396

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

key

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

maduiersnfotvbylf为第9位,l为第15位,y第14位,e第5位,r第6位,s第7位

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

aASCII码为01100001,即可定位到6个字符分别为:ionuvw

image-20220226160813025

成功!

由于只限制了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个数

返回后,栈及指针情况为:

CSAPP-Lab02 Bomb Lab 详细解析_第9张图片

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],由 n u m [ 0 ] − 1 ≤ 5 num[0]-1\le 5 num[0]15num[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行这里,给了一个地址,我们查看一下:

CSAPP-Lab02 Bomb Lab 详细解析_第10张图片

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

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的操作了,它是通过我们输入的六个数字分别作为索引对链表进行重排。

该步完成后,栈的情况如下:

CSAPP-Lab02 Bomb Lab 详细解析_第11张图片

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

image-20220227153314603

成功了!

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行给的内存地址:

image-20220227155337268

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

image-20220227155023476

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

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

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

image-20220227162018104

这不正是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行,比较我们的数与传入内存地址中存的数,

  • 查看该地址存的内容:

CSAPP-Lab02 Bomb Lab 详细解析_第12张图片

这类似树结构,结构定义如下:

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

根据节点关系,画出树:

CSAPP-Lab02 Bomb Lab 详细解析_第13张图片

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

  • 这是一个递归调用的函数,写出它的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

CSAPP-Lab02 Bomb Lab 详细解析_第14张图片

成功!

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

总结

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

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

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

你可能感兴趣的:(CSAPP,gdb)