【深入理解计算机系统】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比较，如果相等则跳转到。否则爆炸。所以我们接着去看
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。如果相等则跳转到，否则爆炸。
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，则跳转到，否则爆炸。
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. 所以跳到，对应的函数值是0xcf(207),然后跳到
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.
可以推断
- 答案共有8个组合：前面是switch的label值，后面是对应的一个内存值。
- 任意一个组合都可以过关。
答案(不唯一)
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 //第一个参数
//调用，返回值必须等于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.
可以确定：
- 输入为两个整型，分别存在0x8(%rsp)和0xc(%rsp)，前者是第一个输入，后者是第二个输入
- input1的取值范围是[0,14]
- 调用func4(input1, 0,14)的返回值必须是0，否则爆炸
- 调用后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，则跳转到 。
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，则跳转到，是程序出口。此时返回确实是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 : "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.
清晰明了。确定如下：
-
输入为六个char，我这里名为InputString。
-
"flyers"要与 InputString在0x4024b0中的映射后的字符串相等才可以通过。
-
0x4024b0中的字符串为"maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"
-
我们来分析一下映射关系：
-
同理，全部计算过程如下：
目标char 在0x4024b0中对应的Index 末byte为第二列的char f 9 i l f o y e n e 5 e r 6 f s 7 g
-
答案(不唯一)
ionefg
Phase_6
这个汇编代码太长了。
而且寄存器也比较陌生，对我刚接触汇编的人来说还是比较难懂的。
所以留下一个博主的答案。
https://mcginn7.github.io/2020/02/16/CSAPP-bomblab/#phase-6
本人暂时放弃Phase_6。
后话
这个lab对我来说很难。因为没有学习过汇编。
今天学习OS的时候发现也需要不少的汇编知识。但目前来说也不算是应需求，就先放下了。
等有一天觉得时机成熟我再来做这个Phase_6。
欢迎留言交流。