【深入理解计算机系统】CSAPP-实验二:BombLab 2020最新详解

前言

本章以“拆解炸弹”为背景,通过gdb调试器对程序进行分析,是一次汇编以及反编译的有趣实践。

本机使用win10 +wsl2.0 + ubuntu18.04完成实验。

点击查看我的全部代码

reference

【施工完成】CSAPP bomb lab

【实战🚀】手摸手教你Bomb Lab

答案

Border relations with Canada have never been better.
1 2 4 8 16 32
0 207
0 0
ionefg
4 3 2 1 6 5

Phase_1

Dump of assembler code for function phase_1:
   0x0000000000400ee0 <+0>:     sub    $0x8,%rsp //申请栈空间
   0x0000000000400ee4 <+4>:     mov    $0x402400,%esi //将内存空间放入%esi寄存器
   0x0000000000400ee9 <+9>:     callq  0x401338 <strings_not_equal>//调用函数判断string是否相等
   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.

清晰明了。

所以查看一下内存空间$0x402400是一个什么值就可以了。

(gdb) x/s 0x402400
0x402400:       "Border relations with Canada have never been better."

答案

Border relations with Canada have never been better.

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) //栈顶元素与1比较,如果相等则跳转到<phase_2+52>。否则爆炸。所以我们接着去看<phase_2+52>
   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 //eax保存了上一个元素
   0x0000000000400f1a <+30>:    add    %eax,%eax //eax翻倍
   0x0000000000400f1c <+32>:    cmp    %eax,(%rbx) //比较eax和rbx。如果相等则跳转到<phase_2+41>,否则爆炸。
   0x0000000000400f1e <+34>:    je     0x400f25 <phase_2+41>
   0x0000000000400f20 <+36>:    callq  0x40143a <explode_bomb>
       
   0x0000000000400f25 <+41>:    add    $0x4,%rbx //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 //rbx取下一个元素
   0x0000000000400f35 <+57>:    lea    0x18(%rsp),%rbp //rbp记录了六个元素的末尾元素地址
   0x0000000000400f3a <+62>:    jmp    0x400f17 <phase_2+27>//do-while循环
       
   0x0000000000400f3c <+64>:    add    $0x28,%rsp //归还空间
   0x0000000000400f40 <+68>:    pop    %rbx //恢复寄存器
   0x0000000000400f41 <+69>:    pop    %rbp
       
       
   0x0000000000400f42 <+70>:    retq
End of assembler dump.

于是,可以确定:

  • 一共有六个数字
  • 第一个数字为1
  • 下一个数字是前一个数字的两倍

答案

1 2 4 8 16 32

Phase 3

Dump of assembler code for function phase_3:
   0x0000000000400f43 <+0>:     sub    $0x18,%rsp //申请栈空间
       
   0x0000000000400f47 <+4>:     lea    0xc(%rsp),%rcx //这里rcx和rdx寄存器分别存了两个局部变量。
   0x0000000000400f4c <+9>:     lea    0x8(%rsp),%rdx
	
   //这里读了一个内存内容到寄存器esi(参数),同时把eax清零(return),这两步都是为调用函数做准备。
   0x0000000000400f51 <+14>:    mov    $0x4025cf,%esi //查看了内存值,为"%d %d",可以确定指明了解析格式。gdb看下,Value returned is $1 = 2 。所以调用结束后eax的值就是2了。scanf返回读取的数量,是2
   0x0000000000400f56 <+19>:    mov    $0x0,%eax
   0x0000000000400f5b <+24>:    callq  0x400bf0 <__isoc99_sscanf@plt>
       
   0x0000000000400f60 <+29>:    cmp    $0x1,%eax //如果eax大于1,则跳转到<phase_3+39>,否则爆炸。
   0x0000000000400f63 <+32>:    jg     0x400f6a <phase_3+39>
   0x0000000000400f65 <+34>:    callq  0x40143a <explode_bomb>
       
   //将0x8(%rsp)和7比较。如果大于7,则爆炸。所以0x8(%rsp)这个值必须小于7。ja是无符号比较, 所以可知第一个参数的1值必须在0~7之间
   0x0000000000400f6a <+39>:    cmpl   $0x7,0x8(%rsp)
   0x0000000000400f6f <+44>:    ja     0x400fad <phase_3+106>
   
   0x0000000000400f71 <+46>:    mov    0x8(%rsp),%eax //0x8(%rsp)移入寄存器eax. switch初始化
       
   //switch跳转。我们必须把跳跃表打印出来才知道跳转规律是什么。x/w就可以打印其中一个,0x00400f7c,此时%rax = 0. 所以跳到<phase_3+57>,对应的函数值是0xcf(207),然后跳到 <phase_3+123>
   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
       
   //判断0xc(%rsp)与%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
End of assembler dump.

可以推断

  1. 答案共有8个组合:前面是switch的label值,后面是对应的一个内存值。
  2. 任意一个组合都可以过关。

答案(不唯一)

0 207

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 // "%d %d" 可知仍然是两个整数
   0x000000000040101f <+19>:    mov    $0x0,%eax
   0x0000000000401024 <+24>:    callq  0x400bf0 <__isoc99_sscanf@plt>
       
   0x0000000000401029 <+29>:    cmp    $0x2,%eax
   0x000000000040102c <+32>:    jne    0x401035 <phase_4+41> //%eax必须等于2,否则爆炸
   0x000000000040102e <+34>:    cmpl   $0xe,0x8(%rsp)//0x8(%rsp)必须小于或等于14,否则爆炸。这里也是unsigned
   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 //第一个参数
   //调用<func4>,返回值必须等于0,否则爆炸
   0x0000000000401048 <+60>:    callq  0x400fce <func4>
   0x000000000040104d <+65>:    test   %eax,%eax
   0x000000000040104f <+67>:    jne    0x401058 <phase_4+76>
   //0xc(%rsp)的值必须等于0,否则爆炸。
   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
End of assembler dump.

可以确定:

  1. 输入为两个整型,分别存在0x8(%rsp)和0xc(%rsp),前者是第一个输入,后者是第二个输入
  2. input1的取值范围是[0,14]
  3. 调用func4(input1, 0,14)的返回值必须是0,否则爆炸
  4. 调用后input2的值也必须是0,否则爆炸。留意到func4并不会修改input2,所以可以确定input2 = 0

于是来我们来看看func4的反编译代码,来确定input1是多少
(一开始写注释的时候不知道要递归,所以就直接用数字来计算。所以后面再使用c语言去描述了抽象出来的含义)

Dump of assembler code for function func4:
	// %edi input1
	// %esi 0
	// %edx 14
        
   0x0000000000400fce <+0>:     sub    $0x8,%rsp //申请栈空间
       
   0x0000000000400fd2 <+4>:     mov    %edx,%eax //(%eax) =14
   0x0000000000400fd4 <+6>:     sub    %esi,%eax //(%eax) =14-0=14
   0x0000000000400fd6 <+8>:     mov    %eax,%ecx //new, (%ecx) = 14,边界长度
   0x0000000000400fd8 <+10>:    shr    $0x1f,%ecx //逻辑右移,ecx右移动31位,剩下符号位0
   0x0000000000400fdb <+13>:    add    %ecx,%eax //(%eax)  = 14+0 = 14
   0x0000000000400fdd <+15>:    sar    %eax//算术右移动,默认1,算数移动1位。即eax/=2,eax=7. 此处打断点验证是对的
       
   0x0000000000400fdf <+17>:    lea    (%rax,%rsi,1),%ecx //%ecx =  7 + 0*1 = 7
   0x0000000000400fe2 <+20>:    cmp    %edi,%ecx //留意到目前为值,完全没有调用过%edi或者%rdi,可以确定%ecx必然=7,所以input1必然和7做比较。如果7<=input1,则跳转到 <func4+36>。
   0x0000000000400fe4 <+22>:    jle    0x400ff2 <func4+36>
       
   //到这里说明input1<7.
   0x0000000000400fe6 <+24>:    lea    -0x1(%rcx),%edx //(%edx) = 7 - 1 = 6
   	//这里出现了递归调用。
       	// %edi input1
		// %esi 0
		// %edx 6
   0x0000000000400fe9 <+27>:    callq  0x400fce <func4>
   0x0000000000400fee <+32>:    add    %eax,%eax //(%eax)翻倍,然后走出程序
   0x0000000000400ff0 <+34>:    jmp    0x401007 <func4+57>
   
   //到这里说明input1>=7
   0x0000000000400ff2 <+36>:    mov    $0x0,%eax
   0x0000000000400ff7 <+41>:    cmp    %edi,%ecx //比较input1和7. 如果7>=input1,则跳转到<func4+57>,是程序出口。此时返回确实是0.
   0x0000000000400ff9 <+43>:    jge    0x401007 <func4+57>
   0x0000000000400ffb <+45>:    lea    0x1(%rcx),%esi //%esi=7+1 = 8。
   //这里也出现了递归
        // %edi input1
		// %esi 8
		// %edx 14
   0x0000000000400ffe <+48>:    callq  0x400fce <func4>
   0x0000000000401003 <+53>:    lea    0x1(%rax,%rax,1),%eax //%eax = 2* %rax +1. 即返回值翻倍再加1
       
   0x0000000000401007 <+57>:    add    $0x8,%rsp //归还栈空间
   0x000000000040100b <+61>:    retq
End of assembler dump.

由于涉及到递归调用,我们必须分清楚调用的参数的改变。通过分析参数(过程在注释中),我们也很敏锐地发现,这是一个二分递归的过程。

我们重新整理成伪代码,便于查看分析:

   int func4(
      int edi = input1,
      int esi = 0,
      int edx = 14
   ){
      int eax;
      
      eax = edx; //赋值右边界
      eax -= esi; //减去左边界

      int ecx = eax; //保留了区间长度值
      ecx>>=31; //符号位,此时ecx=0
      eax+=ecx; //eax = 14
      eax>>=1; //eax/=2,eax=7。此时eax存的是区间长度的一半

      ecx = rax(即eax)+ rsi(即esi); //exc存的是:左边界值+区间长度的一半。所以ecx存的就是区间的中点的index

      //准备进入左区间递归
      if(edi<ecx){ 
         edx = rac(即ecx) -1 ; //更新左区间的右顶点值
         eax = func4(edi,esi,edx); //递归,除了edx,其他都没有改变。这里之所以是eax直接被赋值,因为func并没有通过push和pop方法把目前变量存储起来,所以可以推断这里是直接修改值。
         eax *=2;
      }
      else if(ecx==edi) {  //ecx>=edi,edi>=ecx,只能两者相等了
            return 0;
      }
      //准备进入右区间递归。此时edi>=ecx
      {
         esi = rac(即ecx) +1; //更新右区间的左顶点值
         eax = func4(edi,esi,edx);  //递归,除了esi,其他都没有改变。
         eax = 2 * rax(即eax) + 1;
      }

      return eax;
   }
   

为了让返回值等于0,所以不能进入右区间递归(因为会被+1),即每次都进入左区间递归。所以很简单,第一个参数也是0。

答案

0 0

Phase_5

Dump of assembler code for function phase_5:
   0x0000000000401062 <+0>:     push   %rbx 
   0x0000000000401063 <+1>:     sub    $0x20,%rsp //申请内存
       
   0x0000000000401067 <+5>:     mov    %rdi,%rbx //第一个参数存入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 //存储了输入长度。输入长度必须是6,否则爆炸。
   0x0000000000401082 <+32>:    je     0x4010d2 <phase_5+112>
   0x0000000000401084 <+34>:    callq  0x40143a <explode_bomb>
   0x0000000000401089 <+39>:    jmp    0x4010d2 <phase_5+112>
   
       /*
       		接下来要进入do while循环。从0到5。
       */
   0x000000000040108b <+41>:    movzbl (%rbx,%rax,1),%ecx //rbx存了传入的六个字符串。这里是遍历每一个char的意思
   0x000000000040108f <+45>:    mov    %cl,(%rsp)//ecx包含cl。作为char,cl足够存储。于是%rsp(栈顶)现在存储的是正在遍历的char
   0x0000000000401092 <+48>:    mov    (%rsp),%rdx //new寄存器,存储正在遍历的char
   0x0000000000401096 <+52>:    and    $0xf,%edx //edx只保留末尾的byte
   0x0000000000401099 <+55>:    movzbl 0x4024b0(%rdx),%edx //%rdx作为存储在$0x4024b0位置的下标索引. 这里更新了edx。我们先看看0x4024b0存储了什么。0x4024b0 <array.3449>:  "maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"
   0x00000000004010a0 <+62>:    mov    %dl,0x10(%rsp,%rax,1)//将更新后的rdx存到以(%rsp+0x10)开始的位置。
   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 //"flyers",作为第二个参数。
   0x00000000004010b8 <+86>:    lea    0x10(%rsp),%rdi //第一个参数,是0x10(%rsp)。如果0x10(%rsp)和输入字符串相等,则程序退出。否则爆炸。
   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>
   
       //只是把eax清空就跳回去了
   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
End of assembler dump.

清晰明了。确定如下:

  1. 输入为六个char,我这里名为InputString。

  2. "flyers"要与 InputString在0x4024b0中的映射后的字符串相等才可以通过。

  3. 0x4024b0中的字符串为"maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"

  4. 我们来分析一下映射关系:

    1. 同理,全部计算过程如下:

      目标char在0x4024b0中对应的Index末byte为第二列的char
      f9i
      lfo
      yen
      e5e
      r6f
      s7g

答案(不唯一)

ionefg

Phase_6

这个汇编代码太长了。

而且寄存器也比较陌生,对我刚接触汇编的人来说还是比较难懂的。

所以留下一个博主的答案。

https://mcginn7.github.io/2020/02/16/CSAPP-bomblab/#phase-6

本人暂时放弃Phase_6。

后话

这个lab对我来说很难。因为没有学习过汇编。

今天学习OS的时候发现也需要不少的汇编知识。但目前来说也不算是应需求,就先放下了。

等有一天觉得时机成熟我再来做这个Phase_6。

欢迎留言交流。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值