今天刚刚验收CSAPP实验3，趁着余温，记录一下这个实验，顺便回顾下CSAPP课程的相关知识。
实验目的
1.使用gdb工具反汇编出汇编代码，结合c语言文件找到每个关卡的入口函数。然后分析汇编代码，分析得到每一关的通关密码。
2.熟悉linux指令,学会如何使用gdb对程序进行调试
实验环境
个人电脑PC，32位ubuntu系统环境
实验内容及操作步骤
实验内容
“二进制炸弹”是Linux可执行C程序，包含六个“阶段”和一个秘密“阶段”。 每个阶段都要求输入特定的字符串在stdin上。 如果输入了预期的字符串，则该阶段通过，进入下一阶段。 否则，炸弹会通过打印“ BOOM !!!”而“爆炸”。
操作步骤
拆弹前准备
(1).进入Ubuntu系统，将自己的程序包复制到虚拟机中，并使用tar xvf bomb201808010515.tar进行解压。
(2).输入objdump –d bomb >my_bomb.txt，将反汇编代码输入到my_bomb.txt的文件中，便于拆弹时的查看和注释。
(3).打开反汇编文件，发现phase_i系列的函数，结合实验题目，可以知道这是每一个关卡对应的函数。
开始拆炸弹
PS：每个关卡汇编代码下面有相应的文字分析。
phase_1：确定输入字符串
- 查看汇编代码
08048b50 <phase_1>:
8048b50: 83 ec 1c sub $0x1c,%esp
8048b53: c7 44 24 04 84 a1 04 movl $0x804a184,0x4(%esp) //传入一个立即数
8048b5a: 08
8048b5b: 8b 44 24 20 mov 0x20(%esp),%eax
8048b5f: 89 04 24 mov %eax,(%esp)
8048b62: e8 3d 04 00 00 call 8048fa4 <strings_not_equal> //输入字符串进入函数进行比较
8048b67: 85 c0 test %eax,%eax
8048b69: 74 05 je 8048b70 <phase_1+0x20> //返回值为0，结束，否则爆炸
8048b6b: e8 46 05 00 00 call 80490b6 <explode_bomb>
8048b70: 83 c4 1c add $0x1c,%esp
8048b73: c3 ret
- 分析：
(1).可以看到在%eax!=0的时候就会调用<explode_bomb>，所以在调用<strings_not_equal> 函数之后的返回值%eax必须为0。往前看，发现代码movl $0x804a184,0x4(%esp)有立即数，是将此处地址的值拿来用，输入gdb –q bomb进入调试状态，用x/s 0x804a184查看内容。
(2).下面一步 mov 0x20(%esp),%eax就是把我们输入的参数放进%eax中，然后放进(%esp) ，再调用函数<strings_not_equal>。所以猜测要输入的就是0x804a184中的字符。开始第一关的尝试,重新打开一个终端，用来测试。测试结果如下，输出"Phase 1 defused. How about the next one?",成功通关。
phase_2: 确定一个有规律的数列
- 分析：
08048b74 <phase_2>:
8048b74: 56 push %esi
8048b75: 53 push %ebx
8048b76: 83 ec 34 sub $0x34,%esp //开辟栈帧
8048b79: 8d 44 24 18 lea 0x18(%esp),%eax
8048b7d: 89 44 24 04 mov %eax,0x4(%esp)
8048b81: 8b 44 24 40 mov 0x40(%esp),%eax
8048b85: 89 04 24 mov %eax,(%esp)
8048b88: e8 5e 06 00 00 call 80491eb <read_six_numbers>
8048b8d: 83 7c 24 18 01 cmpl $0x1,0x18(%esp) //esp+0x18-1
8048b92: 74 05 je 8048b99 <phase_2+0x25> //esp+0x18==1
8048b94: e8 1d 05 00 00 call 80490b6 <explode_bomb> //esp+0x18!=1,爆炸
8048b99: 8d 5c 24 1c lea 0x1c(%esp),%ebx //ebx=esp+0x1c
8048b9d: 8d 74 24 30 lea 0x30(%esp),%esi //esi=esp+0x30
(1). 首先注意到这个函数，这里应该是读取6个数字。接下来看到esp+0x18中存放的值和1进行比较，不相等则爆炸，由此猜测第1个数为1。连续的两条lea语句是将esp+0x1c,esp+0x30的值存放入对应寄存器。从esp+0x18到esp+0x30刚好存放6个int 类型的数据，故esp+0x30是最后一个数据，esp+0x1c是第2个数据。
8048ba1: 8b 43 fc mov -0x4(%ebx),%eax //eax=esp+0x1c-0x4=esp+0x18
8048ba4: 01 c0 add %eax,%eax //eax=eax*2=2*(esp+0x18)
8048ba6: 39 03 cmp %eax,(%ebx) //(ebx)-eax
8048ba8: 74 05 je 8048baf <phase_2+0x3b> //(ebx)==2
8048baa: e8 07 05 00 00 call 80490b6 <explode_bomb> //(ebx)!=2,爆炸
8048baf: 83 c3 04 add $0x4,%ebx //ebx=ebx+4=esp+0x20,地址+4，下一个数字
8048bb2: 39 f3 cmp %esi,%ebx //ebx-esi=esp+0x20-(esp+0x30)
8048bb4: 75 eb jne 8048ba1 <phase_2+0x2d> //不相等,继续循环
8048bb6: 83 c4 34 add $0x34,%esp //结束
8048bb9: 5b pop %ebx
8048bba: 5e pop %esi
8048bbb: c3 ret
(2). 接下来将ebx-0x4的中存放的值传给eax,执行add %eax,%eax操作，即eax中存放的数乘以2，再将这个值与第2个数据进行比较，如果不相等就爆炸，说明第2个数就是在第1个数的基础上乘以2。继续往下看，执行add $0x4,%ebx,将ebx中的地址加0x4,即下一个数字，接着的判断语句是和最后一个数字比较，不相等就跳转到对应位置继续循环。由此可知，这6个数字对应的递推关系为a[i+1]=2*a[i],其中a[0]=1,i=0,1，…，4。
(3). 切换到之前测试用的终端，输入1 2 4 8 16 32，终端显示“That’s number 2. Keep going!”，第二关顺利通过。结果如下图所示：
phase_3 :switch语句
- 分析
08048bbc <phase_3>:
8048bbc: 83 ec 2c sub $0x2c,%esp //开辟栈帧
8048bbf: 8d 44 24 1c lea 0x1c(%esp),%eax
8048bc3: 89 44 24 0c mov %eax,0xc(%esp) //参数y esp+0x1c
8048bc7: 8d 44 24 18 lea 0x18(%esp),%eax
8048bcb: 89 44 24 08 mov %eax,0x8(%esp) //参数x esp+0x18
8048bcf: c7 44 24 04 a3 a3 04 movl $0x804a3a3,0x4(%esp) //查看汇编后知道需要输入两个数(%d %d)
8048bd6: 08
8048bd7: 8b 44 24 30 mov 0x30(%esp),%eax
8048bdb: 89 04 24 mov %eax,(%esp)
8048bde: e8 8d fc ff ff call 8048870 <__isoc99_sscanf@plt>
(1).看到上面这段汇编代码，注意到函数_isoc99_sscanf@plt,说明这部分存在输入信息，往前看，发现movl $804a3a3,0x4(%esp)。进入GDB调试，设置断点 b phase_3,尝试使用x/s查看内容，发现是“%d %d”（如下图）,说明需要输入两个数据。结合前面传入两个参数，这两个参数就是输入的数据,设为x,y。
8048be3: 83 f8 01 cmp $0x1,%eax //eax-1
8048be6: 7f 05 jg 8048bed <phase_3+0x31> //eax>1
8048be8: e8 c9 04 00 00 call 80490b6 <explode_bomb> //eax<1,爆炸
8048bed: 83 7c 24 18 07 cmpl $0x7,0x18(%esp) //x-7
8048bf2: 77 3c ja 8048c30 <phase_3+0x74> //x>7或者x<0，引爆炸弹
8048bf4: 8b 44 24 18 mov 0x18(%esp),%eax //eax=x
8048bf8: ff 24 85 e0 a1 04 08 jmp *0x804a1e0(,%eax,4) //switch语句，gdb查看*0x804a1e0
(2). 接下来看到cmpl $0x7,%eax，进行无符号数比较，如果大于7或者小于0就爆炸，故可以知道eax中存放的值(参数1)的取值范围为0-7的整数。往下发现很多跳转指令，结合jmp *0x804a1e0(,%eax,4)知道，这是一个跳转表结构。
8048bf8: ff 24 85 e0 a1 04 08 jmp *0x804a1e0(,%eax,4) //switch语句，gdb查看*0x804a1e0
8048bff: b8 cc 01 00 00 mov $0x1cc,%eax //eax=0x1cc,x=0 对应查看*0x804a1e0
8048c04: eb 3b jmp 8048c41 <phase_3+0x85>
8048c06: b8 b6 03 00 00 mov $0x3b6,%eax //eax=0x3b6,x=2 对应查看*0x804a1e8
8048c0b: eb 34 jmp 8048c41 <phase_3+0x85>
8048c0d: b8 03 03 00 00 mov $0x303,%eax //eax=0x303,x=3
8048c12: eb 2d jmp 8048c41 <phase_3+0x85>
8048c14: b8 1d 01 00 00 mov $0x11d,%eax //eax=0x11d,x=4
8048c19: eb 26 jmp 8048c41 <phase_3+0x85>
8048c1b: b8 a0 01 00 00 mov $0x1a0,%eax //eax=0x1a0,x=5
8048c20: eb 1f jmp 8048c41 <phase_3+0x85>
8048c22: b8 60 03 00 00 mov $0x360,%eax //eax=0x360,x=6
8048c27: eb 18 jmp 8048c41 <phase_3+0x85>
8048c29: b8 6f 02 00 00 mov $0x26f,%eax //eax=0x26f,x=7
8048c2e: eb 11 jmp 8048c41 <phase_3+0x85>
8048c30: e8 81 04 00 00 call 80490b6 <explode_bomb> //爆炸
8048c35: b8 00 00 00 00 mov $0x0,%eax //eax=0
8048c3a: eb 05 jmp 8048c41 <phase_3+0x85>
8048c3c: b8 7a 00 00 00 mov $0x7a,%eax //eax=0x7a,x=1
(3).分析这个跳转表
假设x为0，则得到地址0x804a1e0+4*0=0x804a1e0,使用x/8bx 0x804a1e0查看信息，为0x8048bff,即case 0的入口地址。
根据case 0的入口地址0x8048bff找到执行执行mov $0x1cc,%eax。
假设x为1，则得到地址0x804a1e0+4*1=0x804a1e4,使用x/8bx 0x804a1e4查看信息，为0x804c3c,即case 1的入口地址。
根据case 1的入口地址0x8048c3c找到执行执行mov $0x7a,%eax。同理可以确定其他几组数据。
8048c41: 3b 44 24 1c cmp 0x1c(%esp),%eax //eax-y
8048c45: 74 05 je 8048c4c <phase_3+0x90> //eax==y
8048c47: e8 6a 04 00 00 call 80490b6 <explode_bomb> //eax!=y,爆炸
8048c4c: 83 c4 2c add $0x2c,%esp //结束
8048c4f: c3 ret
(4).最后一部分将eax的值和输入的参数y进行比较，不相等则爆炸，说明输入的第2个数字y为case语句中传给eax的值。由此可以确定这个关卡有8组不同的通关答案，分别是0 460,1 122，2 950, 3 771, 4 285, 5 416，6 864， 7 623。下面对2组数据进行验证：
phase_4 :函数过程调用
- 分析
08048cb9 <phase_4>:
8048cb9: 83 ec 2c sub $0x2c,%esp //开辟栈帧
8048cbc: 8d 44 24 1c lea 0x1c(%esp),%eax
8048cc0: 89 44 24 0c mov %eax,0xc(%esp) //参数y
8048cc4: 8d 44 24 18 lea 0x18(%esp),%eax
8048cc8: 89 44 24 08 mov %eax,0x8(%esp) //参数x
8048ccc: c7 44 24 04 a3 a3 04 movl $0x804a3a3,0x4(%esp) 查看汇编后知道需要输入两个数(%d %d)
8048cd3: 08
(1).查看上面这一段代码，分析得出输入两个数字（和关卡3一样，用gdb调试看0x804a3a3中存放的内容）。结合前面传入两个参数，这两个参数就是输入的数据,设为x,y。
8048cd4: 8b 44 24 30 mov 0x30(%esp),%eax
8048cd8: 89 04 24 mov %eax,(%esp)
8048cdb: e8 90 fb ff ff call 8048870 <__isoc99_sscanf@plt> //调用某个函数
8048ce0: 83 f8 02 cmp $0x2,%eax //eax-2 判断传入参数的个数是否满足条件
8048ce3: 75 0d jne 8048cf2 <phase_4+0x39> //eax!=2 引爆
8048ce5: 8b 44 24 18 mov 0x18(%esp),%eax //eax=x
8048ce9: 85 c0 test %eax,%eax //判断x
8048ceb: 78 05 js 8048cf2 <phase_4+0x39> //x<0 引爆
8048ced: 83 f8 0e cmp $0xe,%eax //x-0xe
8048cf0: 7e 05 jle 8048cf7 <phase_4+0x3e> //x<=0xe
8048cf2: e8 bf 03 00 00 call 80490b6 <explode_bomb>
(2).分析这一部分代码，test判断x是否小于0，cmp判断x是否大于0xe,故要是炸弹不爆炸，则参数x的取值范围为0-0xe的整数。
8048cf7: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp) //esp+0x8=0xe
8048cfe: 00
8048cff: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) //esp+0x4=0
8048d06: 00
8048d07: 8b 44 24 18 mov 0x18(%esp),%eax //eax=x
8048d0b: 89 04 24 mov %eax,(%esp) //esp=x
8048d0e: e8 3d ff ff ff call 8048c50 <func4> //调用func4
(3). 在调用func4之前将参数压入栈帧.
8048d13: 83 f8 07 cmp $0x7,%eax //eax-7,eax里面存放的是func4的返回值
8048d16: 75 07 jne 8048d1f <phase_4+0x66> //eax!=7,引爆
8048d18: 83 7c 24 1c 07 cmpl $0x7,0x1c(%esp) //y-7
8048d1d: 74 05 je 8048d24 <phase_4+0x6b> //y==7,结束
8048d1f: e8 92 03 00 00 call 80490b6 <explode_bomb>
8048d24: 83 c4 2c add $0x2c,%esp
8048d27: c3 ret
(4). 继续分析发现下面对func4的返回值和参数y分别对7进行比较，如果不为7，则引爆炸弹，分析到此，可以知道对于x属于[0,0xe]使得func4(x,0,0xe)返回值为0x7的x即为所求。
08048c50 <func4>:
8048c50: 83 ec 1c sub $0x1c,%esp //开辟栈帧
8048c53: 89 5c 24 14 mov %ebx,0x14(%esp)
8048c57: 89 74 24 18 mov %esi,0x18(%esp)
8048c5b: 8b 44 24 20 mov 0x20(%esp),%eax //设esp+0x20存储x=>eax=x
8048c5f: 8b 54 24 24 mov 0x24(%esp),%edx //设esp+0x24存储y=>edx=y
8048c63: 8b 74 24 28 mov 0x28(%esp),%esi //设esp+0x28存储z=>esi=z
8048c67: 89 f1 mov %esi,%ecx //ecx=z
8048c69: 29 d1 sub %edx,%ecx //ecx=z-y
8048c6b: 89 cb mov %ecx,%ebx //ebx=z-y
8048c6d: c1 eb 1f shr $0x1f,%ebx //逻辑右移，ebx=(z-y)>>31,得到符号位s
8048c70: 01 d9 add %ebx,%ecx //ecx=ebx+ecx=s+z-y
8048c72: d1 f9 sar %ecx //算术右移，ecx=(s+z-y)>>1
8048c74: 8d 1c 11 lea (%ecx,%edx,1),%ebx //ebx=edx*1+ecx=y+ecx=y+(s+z-y)>>1
8048c77: 39 c3 cmp %eax,%ebx //ebx-x,比较计算结果y+(s+z-y)>>1和x
8048c79: 7e 17 jle 8048c92 <func4+0x42> //ebx<=eax
8048c7b: 8d 4b ff lea -0x1(%ebx),%ecx //ecx=ebx-1
8048c7e: 89 4c 24 08 mov %ecx,0x8(%esp) //esp+0x8=ecx=ebx-1
8048c82: 89 54 24 04 mov %edx,0x4(%esp) //esp+0x4=edx=y
8048c86: 89 04 24 mov %eax,(%esp) //esp=x
8048c89: e8 c2 ff ff ff call 8048c50 <func4> //递归调用函数func4
8048c8e: 01 c3 add %eax,%ebx //ebx=ebx+eax
8048c90: eb 19 jmp 8048cab <func4+0x5b>
8048c92: 39 c3 cmp %eax,%ebx //ebx-eax
8048c94: 7d 15 jge 8048cab <func4+0x5b> //ebx>=eax
8048c96: 89 74 24 08 mov %esi,0x8(%esp) //esp+0x8=esi=z
8048c9a: 8d 53 01 lea 0x1(%ebx),%edx //edx=ebx+1
8048c9d: 89 54 24 04 mov %edx,0x4(%esp) //esp+0x4=ebx+1
8048ca1: 89 04 24 mov %eax,(%esp) //esp=eax=x
8048ca4: e8 a7 ff ff ff call 8048c50 <func4> //递归调用函数func4
8048ca9: 01 c3 add %eax,%ebx //ebx=eax+ebx
8048cab: 89 d8 mov %ebx,%eax //eax=ebx
8048cad: 8b 5c 24 14 mov 0x14(%esp),%ebx
8048cb1: 8b 74 24 18 mov 0x18(%esp),%esi
8048cb5: 83 c4 1c add $0x1c,%esp
8048cb8: c3 ret
(5).现在重点就是分析func4函数，看到汇编代码可以发现这是一个递归函数，关键在于找到递归的条件和退出函数的条件，以及递归之前函数的参数压栈准备。根据这段汇编代码写出C语言代码如下:
int func4(int x,int y,int z)
{
int t=(((z-y)+((z-y)>>31))>>1)+y;
if(t<=x)
{
if(t==x)
{
return t;
}
else return func4(x,t+1,z)+x;
}
else
{
return func4(x,y,t-1)+x;
}
}
(6).编写测试函数如下
int main()
{
int i=0;
for(i=0;i<=14;i++)//每一种取值都进行测试
{
printf("func4(%d,0,14)=%d ",i,func4(i,0,14));
if((i+1)%5==0) printf("\n");
}
return 0;
}
运行代码结果如下，可以发现返回值为0x7对应的x只有0x7一种值，故第4关通关输入为7 7。
切换到之前测试用的终端，输入7 7，终端显示“So you got that one. Try this one.”，第四关顺利通过。
phase_5: 序列的构造和数组寻址
- 分析
08048d28 <phase_5>:
8048d28: 53 push %ebx
8048d29: 83 ec 18 sub $0x18,%esp //开辟栈帧
8048d2c: 8b 5c 24 20 mov 0x20(%esp),%ebx //参数1 x存储在ebx
8048d30: 89 1c 24 mov %ebx,(%esp)
8048d33: e8 53 02 00 00 call 8048f8b <string_length>
8048d38: 83 f8 06 cmp $0x6,%eax //eax-6(猜测eax是字符串的长度）
8048d3b: 74 05 je 8048d42 <phase_5+0x1a> //eax==6
8048d3d: e8 74 03 00 00 call 80490b6 <explode_bomb> //eax不是6，引爆
(1).注意到<string_length>函数，结合后面eax和0x6比较，可知这一关输入的参数是一个长度为6的字符串，需要我们去匹配出这个字符串。
8048d42: ba 00 00 00 00 mov $0x0,%edx //edx=0
8048d47: b8 00 00 00 00 mov $0x0,%eax //eax=0
//movsbl指令负责拷贝一个字节，并用源操作数的最高位填充其目的操作数中的其余各位，这种扩展方式叫“符号扩展”
8048d4c: 0f be 0c 03 movsbl (%ebx,%eax,1),%ecx //ecx=(eax+ebx) 长度为6的字符串的第eax个字符
8048d50: 83 e1 0f and $0xf,%ecx //f=00001111 取ecx的低4位
8048d53: 03 14 8d 00 a2 04 08 add 0x804a200(,%ecx,4),%edx //edx=edx+4*ecx+0x804a200
8048d5a: 83 c0 01 add $0x1,%eax //eax+1
8048d5d: 83 f8 06 cmp $0x6,%eax //eax-6
8048d60: 75 ea jne 8048d4c <phase_5+0x24> //eax！=6
8048d62: 83 fa 2b cmp $0x2b,%edx //edx-0x2b
8048d65: 74 05 je 8048d6c <phase_5+0x44> //相等
8048d67: e8 4a 03 00 00 call 80490b6 <explode_bomb> //爆炸
8048d6c: 83 c4 18 add $0x18,%esp //结束
8048d6f: 5b pop %ebx
8048d70: c3 ret
(2).接着edx,eax寄存器的值初始化为0，movsbl (%ebx,%eax,1),%ecx,这一句是表示将长度为6的字符串的第eax个字符存入ecx中。取ecx中的低4位，利用基址比例变址寻址的方式，到数组中找值，并累和在寄存器edx中。往下看，可以看到cmp $0x2b,%edx，如果不相等则爆炸，说明累和得到的值必须为0x2b。
(3).分析到此，关键在于找到数组中的值，由汇编我们知道数组首地址为0x804a200,进入GDB调试，设置断点b phase_5,运行后查看其内容，从里边找出一组和为0x2b的数字，这里取出一组 {2,a,6,1,c,c}。
对应下标为0,1,2,3,4,4，去ascii表中找低四位为0,1，2,3，4,4的字符，故得到其中一组解为pabcdd。
(4). 切换到之前测试用的终端，输入pabcdd，终端显示“Good work! On to the next…!”，第五关顺利通过。
phase_6: 链表
- 分析
08048d71 <phase_6>:
8048d71: 56 push %esi
8048d72: 53 push %ebx
8048d73: 83 ec 44 sub $0x44,%esp //开辟栈帧
8048d76: 8d 44 24 10 lea 0x10(%esp),%eax
8048d7a: 89 44 24 04 mov %eax,0x4(%esp) //参数2 y
8048d7e: 8b 44 24 50 mov 0x50(%esp),%eax
8048d82: 89 04 24 mov %eax,(%esp) //参数1 x
8048d85: e8 61 04 00 00 call 80491eb <read_six_numbers>
(1).首先看到函数，根据之前的经验，猜测这里也是读取6个数字。
8048d8a: be 00 00 00 00 mov $0x0,%esi //esi=0
8048d8f: 8b 44 b4 10 mov 0x10(%esp,%esi,4),%eax //eax=(4*esi+y)
8048d93: 83 e8 01 sub $0x1,%eax //eax--
8048d96: 83 f8 05 cmp $0x5,%eax //eax-5
8048d99: 76 05 jbe 8048da0 <phase_6+0x2f> //无符号数<=
8048d9b: e8 16 03 00 00 call 80490b6 <explode_bomb> //引爆
8048da0: 83 c6 01 add $0x1,%esi //esi+=1，，esi=1
8048da3: 83 fe 06 cmp $0x6,%esi //esi-6
8048da6: 74 33 je 8048ddb <phase_6+0x6a> //等于跳转
//以上代码是确定6个数字的范围。
8048da8: 89 f3 mov %esi,%ebx //ebx=esi
8048daa: 8b 44 9c 10 mov 0x10(%esp,%ebx,4),%eax //eax=(4*ebx+y)
8048dae: 39 44 b4 0c cmp %eax,0xc(%esp,%esi,4) //(4*esi+esp+0xc)-eax
8048db2: 75 05 jne 8048db9 <phase_6+0x48> //不相等
8048db4: e8 fd 02 00 00 call 80490b6 <explode_bomb> //相等，引爆
8048db9: 83 c3 01 add $0x1,%ebx //ebx++
8048dbc: 83 fb 05 cmp $0x5,%ebx //ebx-5
8048dbf: 7e e9 jle 8048daa <phase_6+0x39> //小于等于跳转
8048dc1: eb cc jmp 8048d8f <phase_6+0x1e>
8048dc3: 8b 52 08 mov 0x8(%edx),%edx //edx=(edx+0x8)=(0x804c13c+0x8)
8048dc6: 83 c0 01 add $0x1,%eax //eax++
8048dc9: 39 c8 cmp %ecx,%eax //eax-ecx
8048dcb: 75 f6 jne 8048dc3 <phase_6+0x52> //不相等，继续执行
8048dcd: 89 54 b4 28 mov %edx,0x28(%esp,%esi,4) //4*esi+esp+0x28=edx
8048dd1: 83 c3 01 add $0x1,%ebx //ebx++
8048dd4: 83 fb 06 cmp $0x6,%ebx //ebx-6
8048dd7: 75 07 jne 8048de0 <phase_6+0x6f> //不相等
8048dd9: eb 1c jmp 8048df7 <phase_6+0x86>
//以上代码是判断数字之间是否互不相等。
(2).这里的汇编代码包括两个循环，用来给出数字的取值范围是属于1-6，并且数字之间彼此两两不相等。
//链表初始化
8048df7: 8b 5c 24 28 mov 0x28(%esp),%ebx /ebx=x1
8048dfb: 8b 44 24 2c mov 0x2c(%esp),%eax //eax=x2
8048dff: 89 43 08 mov %eax,0x8(%ebx) //x1->x2
8048e02: 8b 54 24 30 mov 0x30(%esp),%edx //edx=x3
8048e06: 89 50 08 mov %edx,0x8(%eax) //x1->x2->x3
8048e09: 8b 44 24 34 mov 0x34(%esp),%eax //eax=x4
8048e0d: 89 42 08 mov %eax,0x8(%edx) //x1->x2->x3->x4
8048e10: 8b 54 24 38 mov 0x38(%esp),%edx //edx=x5
8048e14: 89 50 08 mov %edx,0x8(%eax) //x1->x2->x3->x4->x5
8048e17: 8b 44 24 3c mov 0x3c(%esp),%eax //eax=x6
8048e1b: 89 42 08 mov %eax,0x8(%edx) //x1->x2->x3->x4->x5->x6
8048e1e: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) //链表尾
(3). 接下来对链表的结点进行了连接
(4).进入GDB调试，设置断点b phase_6,往下分析代码过程中看到一个立即数，查看其值，出现一个node1,猜测这是一个链表的数据结构。于是多查看几个值，发现了其中的规律，每三个数为一组，第1个是数据域中的值，第2个是下标，第3个比较大，类似于地址，是指针域，然后对猜想进行验证。调试后验证猜测正确。根据之前对链表进行连接，顺序为322->370->1c1->24b->0a1->192。
//递增序列
8048e25: be 05 00 00 00 mov $0x5,%esi //esi=5
8048e2a: 8b 43 08 mov 0x8(%ebx),%eax //eax=x2的地址
8048e2d: 8b 10 mov (%eax),%edx //edx=x2
8048e2f: 39 13 cmp %edx,(%ebx) //x1-x2
8048e31: 7e 05 jle 8048e38 <phase_6+0xc7> //x1<=x2
8048e33: e8 7e 02 00 00 call 80490b6 <explode_bomb>
8048e38: 8b 5b 08 mov 0x8(%ebx),%ebx //ebx=ebx+0x8,下一个数
8048e3b: 83 ee 01 sub $0x1,%esi //esi--
8048e3e: 75 ea jne 8048e2a <phase_6+0xb9>
8048e40: 83 c4 44 add $0x44,%esp
8048e43: 5b pop %ebx
8048e44: 5e pop %esi
8048e45: c3 ret
(5).ebx+0x8存储的是第2个数字的地址，取出第2个数字x2，和edx存储的第1个数字x1进行比较,需要满足x1<=x2,接下来ebx地址加0x8,对下一个进行约束。由此可以看出这个序列是一个递增序列。
(6).结合之前输入的6个数字在1-6之间，且互不相同，这里应该是排序后递增链表序列的下标。故得到下标为5 6 3 4 1 2。切换到之前测试用的终端，输入5 6 3 4 1 2，终端显示“Congratulations! You’ve defused the bomb!”，第六关顺利通过。
secret_phase:二叉树
做完前6关，看到提示信息的那一刻，我以为就这样结束，但是听说还有秘密关卡，仔细一看汇编代码，果然有serect_phase的汇编代码片段。起初没有思路，不知道该从何入手，在网上参考了一些资料，结合bomb.c的代码，发现每个阶段函数结束后都调用了phase_defused（）函数，猜测秘密关卡可能隐藏在某一关中。
- 分析如何找到秘密关卡
查看汇编代码如下
0804923b <phase_defused>:
804923b: 81 ec 8c 00 00 00 sub $0x8c,%esp
8049241: 65 a1 14 00 00 00 mov %gs:0x14,%eax
8049247: 89 44 24 7c mov %eax,0x7c(%esp)
804924b: 31 c0 xor %eax,%eax
804924d: 83 3d cc c3 04 08 06 cmpl $0x6,0x804c3cc
8049254: 75 72 jne 80492c8 <phase_defused+0x8d>
8049256: 8d 44 24 2c lea 0x2c(%esp),%eax
804925a: 89 44 24 10 mov %eax,0x10(%esp)
804925e: 8d 44 24 28 lea 0x28(%esp),%eax
8049262: 89 44 24 0c mov %eax,0xc(%esp)
8049266: 8d 44 24 24 lea 0x24(%esp),%eax
804926a: 89 44 24 08 mov %eax,0x8(%esp)
804926e: c7 44 24 04 a9 a3 04 movl $0x804a3a9,0x4(%esp)
8049275: 08
8049276: c7 04 24 d0 c4 04 08 movl $0x804c4d0,(%esp)
804927d: e8 ee f5 ff ff call 8048870 <__isoc99_sscanf@plt>
8049282: 83 f8 03 cmp $0x3,%eax
8049285: 75 35 jne 80492bc <phase_defused+0x81>
8049287: c7 44 24 04 b2 a3 04 movl $0x804a3b2,0x4(%esp)
804928e: 08
804928f: 8d 44 24 2c lea 0x2c(%esp),%eax
8049293: 89 04 24 mov %eax,(%esp)
8049296: e8 09 fd ff ff call 8048fa4 <strings_not_equal>
804929b: 85 c0 test %eax,%eax
804929d: 75 1d jne 80492bc <phase_defused+0x81>
804929f: c7 04 24 78 a2 04 08 movl $0x804a278,(%esp)
80492a6: e8 55 f5 ff ff call 8048800 <puts@plt>
80492ab: c7 04 24 a0 a2 04 08 movl $0x804a2a0,(%esp)
80492b2: e8 49 f5 ff ff call 8048800 <puts@plt>
80492b7: e8 db fb ff ff call 8048e97 <secret_phase>
80492bc: c7 04 24 d8 a2 04 08 movl $0x804a2d8,(%esp)
80492c3: e8 38 f5 ff ff call 8048800 <puts@plt>
80492c8: 8b 44 24 7c mov 0x7c(%esp),%eax
80492cc: 65 33 05 14 00 00 00 xor %gs:0x14,%eax
80492d3: 74 05 je 80492da <phase_defused+0x9f>
80492d5: e8 f6 f4 ff ff call 80487d0 <__stack_chk_fail@plt>
80492da: 81 c4 8c 00 00 00 add $0x8c,%esp
80492e0: c3 ret
80492e1: 90 nop
80492e2: 90 nop
80492e3: 90 nop
80492e4: 90 nop
80492e5: 90 nop
80492e6: 90 nop
80492e7: 90 nop
80492e8: 90 nop
80492e9: 90 nop
80492ea: 90 nop
80492eb: 90 nop
80492ec: 90 nop
80492ed: 90 nop
80492ee: 90 nop
80492ef: 90 nop
(1).结合前面关卡，发现这里有2个立即数，使用gdb调试查看其内容
发现提示输入两个数字和一个字符串，以及第4关的输入。于是猜测秘密关卡藏在第4关，而这个字符串就是打开秘密关卡的“钥匙”。
(2). 可以看到这里将0x804a3b2中存放的内容传入函数strings_not_equal中进行比较，如果返回值不为0，就跳转到0x80492bc,输出0x804a2d8中的内容，否则就一次往下输出0x804a278,0x804a2a0的信息，最后输出0x804a2d8的信息。猜测：0x804a3b2就是进入秘密关卡的“钥匙”，当“钥匙”输入错误就直接结束。
添加断点，用gdb调试查看上述提到的4个地址中的内容，验证了猜测的正确性。
- 分析如何通关
08048e97 <secret_phase>:
8048e97: 53 push %ebx
8048e98: 83 ec 18 sub $0x18,%esp //开辟栈帧
8048e9b: e8 3d 02 00 00 call 80490dd <read_line>
8048ea0: c7 44 24 08 0a 00 00 movl $0xa,0x8(%esp) //参数3 z=a
8048ea7: 00
8048ea8: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) //参数2 y=0
8048eaf: 00
8048eb0: 89 04 24 mov %eax,(%esp) //参数1 x
8048eb3: e8 28 fa ff ff call 80488e0 <strtol@plt>
8048eb8: 89 c3 mov %eax,%ebx //ebx=x
8048eba: 8d 40 ff lea -0x1(%eax),%eax //eax=x-1
8048ebd: 3d e8 03 00 00 cmp $0x3e8,%eax //eax-0x3e8
8048ec2: 76 05 jbe 8048ec9 <secret_phase+0x32> 无符号数比较，小于等于
8048ec4: e8 ed 01 00 00 call 80490b6 <explode_bomb>
(1).这段代码首先将三个参数放入栈帧中，接下来调用了strtol函数。mov %eax,%ebx；lea -0x1(%eax),%eax；cmp $0x3e8,%eax；jbe 8048ec9 <secret_phase+0x32>；这4句对参数x的范围进行了限定，x的取值是1-0x3e9。
8048ec9: 89 5c 24 04 mov %ebx,0x4(%esp) //fun7参数2 n=x
8048ecd: c7 04 24 88 c0 04 08 movl $0x804c088,(%esp) //fun7参数1 m=0x804c088
8048ed4: e8 6d ff ff ff call 8048e46 <fun7> //调用fun7
8048ed9: 85 c0 test %eax,%eax //eax and eax
8048edb: 74 05 je 8048ee2 <secret_phase+0x4b> //等于0，不是0就爆炸
8048edd: e8 d4 01 00 00 call 80490b6 <explode_bomb>
8048ee2: c7 04 24 b8 a1 04 08 movl $0x804a1b8,(%esp)
8048ee9: e8 12 f9 ff ff call 8048800 <puts@plt>
8048eee: e8 48 03 00 00 call 804923b <phase_defused>
8048ef3: 83 c4 18 add $0x18,%esp
8048ef6: 5b pop %ebx
8048ef7: c3 ret
8048ef8: 90 nop
8048ef9: 90 nop
8048efa: 90 nop
8048efb: 90 nop
8048efc: 90 nop
8048efd: 90 nop
8048efe: 90 nop
8048eff: 90 nop
(2).这段代码中主要调用了函数fun7,调用之前可以分析出参数，即fun7(地址，n),第1个参数为某个数组或者链表的首地址，第2个参数为1-1001之间的整数。通关的条件是fun7()的返回值为0。分析fun7中代码，并结合返回值为0，故可以知道保证传入fun7中两个参数相等即可。
08048e46 <fun7>:
8048e46: 53 push %ebx
8048e47: 83 ec 18 sub $0x18,%esp //开辟栈帧
8048e4a: 8b 54 24 20 mov 0x20(%esp),%edx //参数1，edx=&x
8048e4e: 8b 4c 24 24 mov 0x24(%esp),%ecx //参数2，ecx=y
8048e52: 85 d2 test %edx,%edx //判断edx是否为0
8048e54: 74 37 je 8048e8d <fun7+0x47> //等于0
8048e56: 8b 1a mov (%edx),%ebx //取出地址中的值，给ebx,即ebx=x
8048e58: 39 cb cmp %ecx,%ebx //x-y
8048e5a: 7e 13 jle 8048e6f <fun7+0x29> //x<=y
8048e5c: 89 4c 24 04 mov %ecx,0x4(%esp) //esp+0x4=y
8048e60: 8b 42 04 mov 0x4(%edx),%eax
8048e63: 89 04 24 mov %eax,(%esp) //esp=edx+0x4
8048e66: e8 db ff ff ff call 8048e46 <fun7> //调用函数fun7
8048e6b: 01 c0 add %eax,%eax //eax=eax*2
8048e6d: eb 23 jmp 8048e92 <fun7+0x4c>
8048e6f: b8 00 00 00 00 mov $0x0,%eax //eax=0
8048e74: 39 cb cmp %ecx,%ebx //x-y
8048e76: 74 1a je 8048e92 <fun7+0x4c> //如果x==y
8048e78: 89 4c 24 04 mov %ecx,0x4(%esp) //esp+0x4=y
8048e7c: 8b 42 08 mov 0x8(%edx),%eax
8048e7f: 89 04 24 mov %eax,(%esp) //esp=edx+0x8
8048e82: e8 bf ff ff ff call 8048e46 <fun7> //调用函数fun7
8048e87: 8d 44 00 01 lea 0x1(%eax,%eax,1),%eax eax=2*eax+1
8048e8b: eb 05 jmp 8048e92 <fun7+0x4c>
8048e8d: b8 ff ff ff ff mov $0xffffffff,%eax
8048e92: 83 c4 18 add $0x18,%esp
8048e95: 5b pop %ebx
8048e96: c3 ret
(3).根据fun7的汇编代码写出对应的C语言代码
int fun7(int *x,int y)
{
if(x==0)
return 0xffffffff;
if(*x<=y)
{
if(*x==y) return 0;
x+=8;
return 2*fun7(x,y)+1;
}
else
{
x+=4;
return 2*fun7(x,y);
}
}
(4).根据前面的分析，要使炸弹不爆炸需要fun7返回值为0，从函数中可以看出，返回值为0，只需*x=y即可，于是查看传入fun7中x中的内容即可。
8048ecd: c7 04 24 88 c0 04 08 movl $0x804c088,(%esp) //fun7参数1 m=0x804c088
8048ed4: e8 6d ff ff ff call 8048e46 <fun7> //调用fun7
(5).切换到之前测试用的终端，运行./bomb,从第一关开始输入，在第四关时，加上字符串“DrEvil”,最终输入秘密关卡的36,终端显示“Wow! You’ve defused the secret stage!Congratulations! You’ve defused the bomb!”。
(6).秘密关卡到这里就结束了，而对于这个关卡涉及到的结构可以进行进一步探索。查看0x804c088中内容发现有3个值，第1个是数值，第2,3个值比较大，是两个地址，联系所学，这两个地址就是左，右子结点的地址。将整个结构用图表示如下，可以看出这是一个典型的二叉树结构。
实验结果及分析
- 所有关卡通关密码均已找出，执行结果如上。
- 对每一关进行简单分析：第1关是确定输入字符串；第2关是确定一个有规律的数列；第3关是switch语句的考察；第4关是函数过程调用的检测；第5关是序列的构造和数组寻址方式；第6关是考察链表的相关知识；秘密关卡的寻找考察了考查Linux Canary绕过技术及ROP(Return-Oriented-Programming)攻击负载的构造（如何找到秘密和关卡的入口），秘密关卡则考察了二叉树。
收获与体会
1.本次实验进一步熟悉了GDB调试工具，调试能力得到了一定的提高。
2.熟悉了linux中一些之前没有见过的指令，如movsbl指令movsbl指令负责拷贝一个字节，并用源操作数的最高位填充其目的操作数中的其余各位，这种扩展方式叫符号扩展，对linux指令更加熟悉。
3.对过程调用和参数准备工作得到了进一步的理解。
4.学到了一些更为复杂的数据表示，比如链表，二叉树的在计算机中的具体存储，以及在底层的使用。
5.实验中每个人的实验的可执行文件都是不同，实验过程中，也帮其他同学看过一些代码，对于不同的反汇编代码更加熟悉，也间接复习了之前计算机系统关于汇编语言的相关知识。
6.结合之前缓冲区溢出攻击的学习，在实验做完后，尝试了用hexedit去直接修改可执行文件的某些执行，使得无论输入什么，都不会跳转到爆炸函数处，进一步理解了缓冲区溢出攻击的原理。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
