<csapp> bomb lab (《深入理解计算机系统》lab2)

原创 2014年05月01日 23:22:32

bomblab下载页:http://download.csdn.net/download/u013648407/7279933  其中bomb是可执行文件  需要用objdump指令反汇编,c1.txt是我反汇编所得到的assembly code。

*****************************************************************************************************************************************************************************************

the second lab,bomb lab。

在我看来这个lab难度比较大。需要花不少时间和精力才能完成。对于这个lab,不同的人有不同的看法,有的人觉得通过阅读assembly code 来提高纯粹的阅读代码能力更重要,有的人觉得合理运用gdb获得更大效率更重要,仁者见仁吧。但不得不说这个lab是很有趣的一个lab,拆除炸弹那一瞬间的快感是无法用言语形容的。想要尝试的朋友可以自行下载,良心0积分。

废话不说,开始:

*****************************************************************************************************************************************************************************************

Q1:

080490b9 <phase_1>:
 80490b9: 55                            push   %ebp
 80490ba: 89 e5                        mov    %esp,%ebp
 80490bc: 83 ec 18                     sub    $0x18,%esp
 80490bf: c7 44 24 04 ec 9d 04 movl   $0x8049dec,0x4(%esp)<-将内存0x8049dec中的内容压栈
 80490c6: 08 
 80490c7: 8b 45 08                     mov    0x8(%ebp),%eax
 80490ca: 89 04 24                     mov    %eax,(%esp)<-将输入的内容压栈
 80490cd: e8 3d 00 00 00       call   804910f <strings_not_equal> <-调用这个函数,看名字知道是判断字符串相等与否的
 80490d2: 85 c0                        test   %eax,%eax<-判断返回值,返回值是1则跳到bomb,说明要求上面两个压栈的字符串必须相等
 80490d4: 74 05                        je     80490db <phase_1+0x22>
 80490d6: e8 44 07 00 00       call   804981f <explode_bomb>
 80490db: c9                                   leave  
 80490dc: 8d 74 26 00                  lea    0x0(%esi,%eiz,1),%esi
 80490e0: c3                                   ret    
 80490e1: 90                                   nop


分析如上,解决方法就是用gbd查看0x8049dec中的字符串,再将该字符串作为密码输入即可。指令为x/s 0x8049dec

*****************************************************************************************************************************************************************************************

Q2:

080490b9 <phase_1>:
 80490b9: 55                            push   %ebp
 80490ba: 89 e5                        mov    %esp,%ebp
 80490bc: 83 ec 18                     sub    $0x18,%esp
 80490bf: c7 44 24 04 ec 9d 04 movl   $0x8049dec,0x4(%esp)<-将内存0x8049dec中的内容压栈
 80490c6: 08 
 80490c7: 8b 45 08                     mov    0x8(%ebp),%eax
 80490ca: 89 04 24                     mov    %eax,(%esp)<-将输入的内容压栈
 80490cd: e8 3d 00 00 00       call   804910f <strings_not_equal> <-调用这个函数,看名字知道是判断字符串相等与否的
 80490d2: 85 c0                        test   %eax,%eax<-判断返回值,返回值是1则跳到bomb,说明要求上面两个压栈的字符串必须相等
 80490d4: 74 05                        je     80490db <phase_1+0x22>
 80490d6: e8 44 07 00 00       call   804981f <explode_bomb>
 80490db: c9                                   leave  
 80490dc: 8d 74 26 00                  lea    0x0(%esi,%eiz,1),%esi
 80490e0: c3                                   ret    
 80490e1: 90                                   nop


通过对主要部分的分析,看出这个密码是一个数列,首项为1,a[n]=n*a[n-1].

答案即是1 2 6 24 120 720

*****************************************************************************************************************************************************************************************

08048eb1 <phase_3>:
 8048eb1: 55                   push   %ebp
 8048eb2: 89 e5                mov    %esp,%ebp
 8048eb4: 53                   push   %ebx
 8048eb5: 83 ec 34             sub    $0x34,%esp
 8048eb8: 8d 45 f0             lea    -0x10(%ebp),%eax<-第三个输入存储在-0x10(%ebp)
 8048ebb: 89 44 24 10          mov    %eax,0x10(%esp)
 8048ebf: 8d 45 ef             lea    -0x11(%ebp),%eax<-第二个输入存储在-0x11(%ebp)
 8048ec2: 89 44 24 0c          mov    %eax,0xc(%esp)
 8048ec6: 8d 45 f4             lea    -0xc(%ebp),%eax<-第一个输入存储在-0xc(%ebp)
 8048ec9: 89 44 24 08          mov    %eax,0x8(%esp)
 8048ecd: c7 44 24 04 2e 9e 04 movl   $0x8049e2e,0x4(%esp)<-此处使用gdb设置断点调试得到0x8049e2e中存储的是一个“%d,%c,%d”,即输入的格式
 8048ed4: 08 
 8048ed5: 8b 45 08             mov    0x8(%ebp),%eax
 8048ed8: 89 04 24             mov    %eax,(%esp)
 8048edb: e8 48 fb ff ff       call   8048a28 <sscanf@plt>
 8048ee0: 83 f8 02             cmp    $0x2,%eax<-输入数据个数必须大于2,否则爆炸
 8048ee3: 7f 05                jg     8048eea <phase_3+0x39>
 8048ee5: e8 35 09 00 00       call   804981f <explode_bomb>
 8048eea: 83 7d f4 07          cmpl   $0x7,-0xc(%ebp)
 8048eee: 66 90                xchg   %ax,%ax
 8048ef0: 0f 87 34 01 00 00    ja     804902a <phase_3+0x179><-以上三行比较输入的第一个数字与7,若第一个输入大于7则爆炸(804802a直接相当于跳转到爆炸函数)
 8048ef6: 8b 5d f4             mov    -0xc(%ebp),%ebx<-switch开始,第二个输入放置到%ebx
 8048ef9: 8d b4 26 00 00 00 00 lea    0x0(%esi,%eiz,1),%esi
 8048f00: ff 24 9d 40 9e 04 08 jmp    *0x8049e40(,%ebx,4)<-jump table
*输入第一个数字为0
8048f07: 81 7d f0 b0 00 00 00 cmpl   $0xb0,-0x10(%ebp)<-比较输入第三个输入与0xb0。即第三个输入为0xb0,转化为10进制为176
 8048f0e: 66 90                xchg   %ax,%ax
 8048f10: 0f 84 2c 01 00 00    je     8049042 <phase_3+0x191>
 8048f16: 66 90                xchg   %ax,%ax
 8048f18: e8 02 09 00 00       call   804981f <explode_bomb>
 8048f1d: bb 79 00 00 00       mov    $0x79,%ebx<-第二个输入为0x79,转化为字符为y
 8048f22: 8d b6 00 00 00 00    lea    0x0(%esi),%esi
 8048f28: e9 1a 01 00 00       jmp    8049047 <phase_3+0x196>
*输入第一个数字为1
 8048f2d: bb 70 00 00 00       mov    $0x70,%ebx<-第二个输入为0x70,转化为字符为p
 8048f32: 81 7d f0 78 02 00 00 cmpl   $0x278,-0x10(%ebp)<-第三个输入为0x278
 8048f39: 8d b4 26 00 00 00 00 lea    0x0(%esi,%eiz,1),%esi
 8048f40: 0f 84 01 01 00 00    je     8049047 <phase_3+0x196>
 8048f46: 66 90                xchg   %ax,%ax
 8048f48: e8 d2 08 00 00       call   804981f <explode_bomb>
 8048f4d: 8d 76 00             lea    0x0(%esi),%esi
 8048f50: e9 f2 00 00 00       jmp    8049047 <phase_3+0x196>
*输入第一个数字为2
 8048f55: bb 68 00 00 00       mov    $0x68,%ebx<-第二个输入为0x68,转化为字符为h
 8048f5a: 81 7d f0 cf 02 00 00 cmpl   $0x2cf,-0x10(%ebp)<-第三个输入为0x2cf
 8048f61: 8d b4 26 00 00 00 00 lea    0x0(%esi,%eiz,1),%esi
 8048f68: 0f 84 d9 00 00 00    je     8049047 <phase_3+0x196>
 8048f6e: 66 90                xchg   %ax,%ax
 8048f70: e8 aa 08 00 00       call   804981f <explode_bomb>
 8048f75: 8d 76 00             lea    0x0(%esi),%esi
 8048f78: e9 ca 00 00 00       jmp    8049047 <phase_3+0x196>
*输入第一个数字为3
 8048f7d: 81 7d f0 a5 01 00 00 cmpl   $0x1a5,-0x10(%ebp)<-第三个输入为0x1a5
 8048f84: 8d 74 26 00          lea    0x0(%esi,%eiz,1),%esi
 8048f88: 0f 84 b4 00 00 00    je     8049042 <phase_3+0x191>
 8048f8e: 66 90                xchg   %ax,%ax
 8048f90: e8 8a 08 00 00       call   804981f <explode_bomb>
 8048f95: bb 79 00 00 00       mov    $0x79,%ebx<-第二个输入为0x79,转化为字符为y
 8048f9a: 8d b6 00 00 00 00    lea    0x0(%esi),%esi
 8048fa0: e9 a2 00 00 00       jmp    8049047 <phase_3+0x196>
*输入第一个数字为4
 8048fa5: bb 67 00 00 00       mov    $0x67,%ebx<-第二个输入为0x67,转化为字符为g
 8048faa: 81 7d f0 f8 01 00 00 cmpl   $0x1f8,-0x10(%ebp)<-第三个输入为0x1f8
 8048fb1: 8d b4 26 00 00 00 00 lea    0x0(%esi,%eiz,1),%esi
 8048fb8: 0f 84 89 00 00 00    je     8049047 <phase_3+0x196>
 8048fbe: 66 90                xchg   %ax,%ax
 8048fc0: e8 5a 08 00 00       call   804981f <explode_bomb>
 8048fc5: 8d 76 00             lea    0x0(%esi),%esi
 8048fc8: eb 7d                jmp    8049047 <phase_3+0x196>
*输入第一个数字为5
 8048fca: bb 61 00 00 00       mov    $0x61,%ebx<-第二个输入为0x61,转化为字符为a
 8048fcf: 81 7d f0 07 01 00 00 cmpl   $0x107,-0x10(%ebp)<-第三个输入为0x107
 8048fd6: 66 90                xchg   %ax,%ax
 8048fd8: 74 6d                je     8049047 <phase_3+0x196>
 8048fda: 8d b6 00 00 00 00    lea    0x0(%esi),%esi
 8048fe0: e8 3a 08 00 00       call   804981f <explode_bomb>
 8048fe5: 8d 76 00             lea    0x0(%esi),%esi
 8048fe8: eb 5d                jmp    8049047 <phase_3+0x196>
*输入第一个数字为6
 8048fea: bb 64 00 00 00       mov    $0x64,%ebx<-第二个输入为0x64,转化为字符为d
 8048fef: 81 7d f0 b3 02 00 00 cmpl   $0x2b3,-0x10(%ebp)<-第三个输入为0x2b3
 8048ff6: 66 90                xchg   %ax,%ax
 8048ff8: 74 4d                je     8049047 <phase_3+0x196>
 8048ffa: 8d b6 00 00 00 00    lea    0x0(%esi),%esi
 8049000: e8 1a 08 00 00       call   804981f <explode_bomb>
 8049005: 8d 76 00             lea    0x0(%esi),%esi
 8049008: eb 3d                jmp    8049047 <phase_3+0x196>
*输入第一个数字为7
 804900a: bb 6d 00 00 00       mov    $0x6d,%ebx<-第二个输入为0x6d,转化为字符为m
 804900f: 81 7d f0 e0 03 00 00 cmpl   $0x3e0,-0x10(%ebp)<-第三个输入为0x3e0
 8049016: 66 90                xchg   %ax,%ax
 8049018: 74 2d                je     8049047 <phase_3+0x196>
 804901a: 8d b6 00 00 00 00    lea    0x0(%esi),%esi
 8049020: e8 fa 07 00 00       call   804981f <explode_bomb>
 8049025: 8d 76 00             lea    0x0(%esi),%esi
 8049028: eb 1d                jmp    8049047 <phase_3+0x196>
 804902a: 8d b6 00 00 00 00    lea    0x0(%esi),%esi
 8049030: e8 ea 07 00 00       call   804981f <explode_bomb>
 8049035: bb 65 00 00 00       mov    $0x65,%ebx
 804903a: 8d b6 00 00 00 00    lea    0x0(%esi),%esi
 8049040: eb 05                jmp    8049047 <phase_3+0x196>
 8049042: bb 79 00 00 00       mov    $0x79,%ebx
 8049047: 3a 5d ef             cmp    -0x11(%ebp),%bl
 804904a: 8d b6 00 00 00 00    lea    0x0(%esi),%esi
 8049050: 74 0b                je     804905d <phase_3+0x1ac>
 8049052: 8d b6 00 00 00 00    lea    0x0(%esi),%esi
 8049058: e8 c2 07 00 00       call   804981f <explode_bomb>
 804905d: 83 c4 34             add    $0x34,%esp
 8049060: 5b                   pop    %ebx
 8049061: 5d                   pop    %ebp
 8049062: c3                   ret    

该phase是一个switch结构,输入任意一组都可以

如我的答案就是选择的第一个输入为7的一组,答案就是7 m 992(注意最后一个输入要换为10进制)

*****************************************************************************************************************************************************************************************

Q4:

08048e5b <phase_4>:
 8048e5b: 55                   push   %ebp
 8048e5c: 89 e5                mov    %esp,%ebp
 8048e5e: 53                   push   %ebx
 8048e5f: 83 ec 24             sub    $0x24,%esp
 8048e62: 8d 45 f4             lea    -0xc(%ebp),%eax
 8048e65: 89 44 24 08          mov    %eax,0x8(%esp)
 8048e69: c7 44 24 04 34 9e 04 movl   $0x8049e34,0x4(%esp)<-输入格式为%d,说明输入一个十进制数
 8048e70: 08 
 8048e71: 8b 45 08             mov    0x8(%ebp),%eax
 8048e74: 89 04 24             mov    %eax,(%esp)
 8048e77: e8 ac fb ff ff       call   8048a28 <sscanf@plt>
 8048e7c: 83 f8 01             cmp    $0x1,%eax<-比较输入数与1,若是不等于则爆炸,说明输入只有一个
 8048e7f: 75 06                jne    8048e87 <phase_4+0x2c>
 8048e81: 83 7d f4 00          cmpl   $0x0,-0xc(%ebp)
 8048e85: 7f 06                jg     8048e8d <phase_4+0x32>
 8048e87: 90                   nop
 8048e88: e8 92 09 00 00       call   804981f <explode_bomb>
 8048e8d: 8b 5d f4             mov    -0xc(%ebp),%ebx<-将输入数放入ebx
 8048e90: 89 1c 24             mov    %ebx,(%esp)<-将输入数压栈,作为func4函数的参数传入,func4函数具体在下面解释
 8048e93: e8 d8 fd ff ff       call   8048c70 <func4>
 8048e98: 3d b0 13 00 00       cmp    $0x13b0,%eax<-将函数返回值与0x13b0比较,即输入要使经过func4运算后得到0x13b0
 8048e9d: 74 05                je     8048ea4 <phase_4+0x49>
 8048e9f: e8 7b 09 00 00       call   804981f <explode_bomb>
 8048ea4: 83 c4 24             add    $0x24,%esp
 8048ea7: 5b                   pop    %ebx
 8048ea8: 5d                   pop    %ebp
 8048ea9: 8d b4 26 00 00 00 00 lea    0x0(%esi,%eiz,1),%esi
 8048eb0: c3                   ret    
-----------------------------------------------------------------------
08048c70 <func4>:
 8048c70: 55                   push   %ebp
 8048c71: 89 e5                mov    %esp,%ebp
 8048c73: 53                   push   %ebx
 8048c74: 83 ec 14             sub    $0x14,%esp
 8048c77: 8b 5d 08             mov    0x8(%ebp),%ebx <-ebx作为counter,即所谓的n.
 8048c7a: b8 01 00 00 00       mov    $0x1,%eax
 8048c7f: 83 fb 01             cmp    $0x1,%ebx
 8048c82: 7e 0e                jle    8048c92 <func4+0x22><-若n=1则跳出递归
 8048c84: 8d 43 ff             lea    -0x1(%ebx),%eax<-eax存放n-1
 8048c87: 89 04 24             mov    %eax,(%esp)<-将n-1作为参数压栈
 8048c8a: e8 e1 ff ff ff       call   8048c70 <func4><-递归
 8048c8f: 0f af c3             imul   %ebx,%eax<-n*n-1(此处n为当前参数)
 8048c92: 83 c4 14             add    $0x14,%esp
 8048c95: 5b                   pop    %ebx
 8048c96: 5d                   pop    %ebp
 8048c97: c3                   ret    


可以看出func4的作用是求当n!。

综合对phase4的分析可以知道n!=0x13b0(即5040),可以推断出n=7,即输入密码为7

*****************************************************************************************************************************************************************************************

08048e0a <phase_5>:
 8048e0a: 55                   push   %ebp
 8048e0b: 89 e5                mov    %esp,%ebp
 8048e0d: 57                   push   %edi
 8048e0e: 56                   push   %esi
 8048e0f: 53                   push   %ebx
 8048e10: 83 ec 1c             sub    $0x1c,%esp
 8048e13: 8b 7d 08             mov    0x8(%ebp),%edi
 8048e16: 89 3c 24             mov    %edi,(%esp)<-以上两行将输入字符串压栈
 8048e19: e8 d2 02 00 00       call   80490f0 <string_length><-根据函数名称推断该函数返回输入字符串的长度
 8048e1e: 83 f8 06             cmp    $0x6,%eax<-输入字符串长度必须为6
 8048e21: 74 05                je     8048e28 <phase_5+0x1e>
 8048e23: e8 f7 09 00 00       call   804981f <explode_bomb>
 8048e28: be 00 00 00 00       mov    $0x0,%esi
 8048e2d: bb 00 00 00 00       mov    $0x0,%ebx<-ebx即为counter,也就是n
 8048e32: b8 60 9e 04 08       mov    $0x8049e60,%eax<-0x8049e60是一个表,在此处利用gdb调试断点,使用x/s指令可以打印出表中内容
 8048e37: 0f be 14 1f          movsbl (%edi,%ebx,1),%edx<-输入的字符串的第n个放入edx
 8048e3b: 83 e2 0f             and    $0xf,%edx<-取出edx中存储的字符ask码的最后一位(解释一下,如字符a,其ask码为0x61,经过该操作取出了最后一个,得到的即为1)
 8048e3e: 03 34 90             add    (%eax,%edx,4),%esi<-利用上一句操作得到的数字,在上面打印出的表中进行偏移,取出表中的第n个,加到esi中(esi是一个存放累加和的寄存器)
 8048e41: 83 c3 01             add    $0x1,%ebx
 8048e44: 83 fb 06             cmp    $0x6,%ebx<-循环直到n=6
 8048e47: 75 ee                jne    8048e37 <phase_5+0x2d>
 8048e49: 83 fe 45             cmp    $0x45,%esi<-比较累加和与0x45,即输入的字符串只要满足使得经过上面操作偏移后得到的数字之和为0x45即可,所以可能有很多组答案,输入满足条件的其中一组即可
 8048e4c: 74 05                je     8048e53 <phase_5+0x49>
 8048e4e: e8 cc 09 00 00       call   804981f <explode_bomb>
 8048e53: 83 c4 1c             add    $0x1c,%esp
 8048e56: 5b                   pop    %ebx
 8048e57: 5e                   pop    %esi
 8048e58: 5f                   pop    %edi
 8048e59: 5d                   pop    %ebp
 8048e5a: c3                   ret    


po主在这里的答案是AAAAEO,答案不唯一。

*****************************************************************************************************************************************************************************************

Q6:

08048dbc <phase_6>:
 8048dbc: 55                   push   %ebp
 8048dbd: 89 e5                mov    %esp,%ebp
 8048dbf: 83 ec 18             sub    $0x18,%esp
 8048dc2: 89 5d f8             mov    %ebx,-0x8(%ebp)
 8048dc5: 89 75 fc             mov    %esi,-0x4(%ebp)
 8048dc8: c7 44 24 08 0a 00 00 movl   $0xa,0x8(%esp)
 8048dcf: 00 
 8048dd0: c7 44 24 04 00 00 00 movl   $0x0,0x4(%esp)
 8048dd7: 00 
 8048dd8: 8b 45 08             mov    0x8(%ebp),%eax
 8048ddb: 89 04 24             mov    %eax,(%esp)<-将输入压栈
 8048dde: e8 15 fb ff ff       call   80488f8 <strtol@plt><-该函数是string转化为long的一个函数
 8048de3: 89 c6                mov    %eax,%esi<-将返回值放入esi寄存器
 8048de5: c7 04 24 20 b6 04 08 movl   $0x804b620,(%esp)<-!!!注意!此处是将内存0x804b620中的数据压栈,并以此为参数调用fun6函数!与输入无关!由此可以看出fun6的具体结果不受输入值得影响,那么可以随便输入一个数字,再利用gdb获取fun6的返回值即可!
 8048dec: e8 a7 fe ff ff       call   8048c98 <fun6>
 8048df1: 8b 58 08             mov    0x8(%eax),%ebx
 8048df4: 8b 43 08             mov    0x8(%ebx),%eax
 8048df7: 39 30                cmp    %esi,(%eax)<-在此处利用p/x操作获得eax寄存器中的值即可,所得即是要输入的密码!
 8048df9: 74 05                je     8048e00 <phase_6+0x44>
 8048dfb: e8 1f 0a 00 00       call   804981f <explode_bomb>
 8048e00: 8b 5d f8             mov    -0x8(%ebp),%ebx
 8048e03: 8b 75 fc             mov    -0x4(%ebp),%esi
 8048e06: 89 ec                mov    %ebp,%esp
 8048e08: 5d                   pop    %ebp
 8048e09: c3                   ret    


这个phase确实是很大的一个陷阱,初看很容易一头扎进fun6研究函数的作用而忽略的fun6的参数实际是固定地址的问题。

po主在做的时候就差点死在fun6的一群跳转中,最后也只是看出是一个类似链表的操作,后来仔细看了phase6才发现了这个函数的特点。

*****************************************************************************************************************************************************************************************

以为这样就完了么?没有!还有隐藏phase等着我们呢!但是正常按照上面步骤做会发现好像输入了第六个phase的结果之后程序就跳出了,那怎么发现secret-phase呢?

先来看看phase-defused函数,就是完成条件吧!

0804978a <phase_defused>:
 804978a: 55                   push   %ebp
 804978b: 89 e5                mov    %esp,%ebp
 804978d: 53                   push   %ebx
 804978e: 83 ec 74             sub    $0x74,%esp
 8049791: c7 04 24 01 00 00 00 movl   $0x1,(%esp)
 8049798: e8 98 fc ff ff       call   8049435 <send_msg>
 804979d: 83 3d 0c b7 04 08 06 cmpl   $0x6,0x804b70c<-必须完成6个phase才能开启隐藏phase
 80497a4: 75 73                jne    8049819 <phase_defused+0x8f>
 80497a6: 8d 45 a8             lea    -0x58(%ebp),%eax
 80497a9: 89 44 24 0c          mov    %eax,0xc(%esp)
 80497ad: 8d 45 a4             lea    -0x5c(%ebp),%eax
 80497b0: 89 44 24 08          mov    %eax,0x8(%esp)
 80497b4: c7 44 24 04 15 a0 04 movl   $0x804a015,0x4(%esp)<-在这里,我们需要从主函数(main函数)的代码中看到每个phase的输入都是利用了read_line这个函数的,那我们利用gdb在read_line函数中设置断点来看每一个phase中读入输入值的位置,可以看出这个804a015是phase4函数读入输入值的位置
 80497bb: 08 
 80497bc: c7 04 24 10 b8 04 08 movl   $0x804b810,(%esp)<-利用gdb调试,该地址中存的是"%d,%s"
 80497c3: e8 60 f2 ff ff       call   8048a28 <sscanf@plt>
 80497c8: 83 f8 02             cmp    $0x2,%eax<-输入值有两个,而phase4输入的是一个十进制数7,则可以看出我们还需要在这个7之后加一个字符串才可以满足打开隐藏phase的条件
 80497cb: 75 34                jne    8049801 <phase_defused+0x77>
 80497cd: c7 44 24 04 1b a0 04 movl   $0x804a01b,0x4(%esp)<-将0x804a01b中的内容压栈,在后面调用了string_not_equal函数来比较这个内容与输入的字符串。在此处用gdb的x/s的指令查看0x804a01b中的内容,得到字符串"austinpowers“,即可得知需要在phase4的输入后面加上字符串austinpowers,这样才能打开隐藏phase
 80497d4: 08 
 80497d5: 8d 45 a8             lea    -0x58(%ebp),%eax
 80497d8: 89 04 24             mov    %eax,(%esp)
 80497db: e8 2f f9 ff ff       call   804910f <strings_not_equal>
 80497e0: 85 c0                test   %eax,%eax
 80497e2: 75 1d                jne    8049801 <phase_defused+0x77>
 80497e4: c7 04 24 ec a0 04 08 movl   $0x804a0ec,(%esp)
 80497eb: e8 28 f2 ff ff       call   8048a18 <puts@plt>
 80497f0: c7 04 24 14 a1 04 08 movl   $0x804a114,(%esp)
 80497f7: e8 1c f2 ff ff       call   8048a18 <puts@plt>
 80497fc: e8 55 f5 ff ff       call   8048d56 <secret_phase>
 8049801: c7 04 24 4c a1 04 08 movl   $0x804a14c,(%esp)
 8049808: e8 0b f2 ff ff       call   8048a18 <puts@plt>
 804980d: c7 04 24 78 a1 04 08 movl   $0x804a178,(%esp)
 8049814: e8 ff f1 ff ff       call   8048a18 <puts@plt>
 8049819: 83 c4 74             add    $0x74,%esp
 804981c: 5b                   pop    %ebx
 804981d: 5d                   pop    %ebp
 804981e: c3                   ret    


-----------------------------------------------------------------------

打开了隐藏phase,我们来看看隐藏phase究竟是何方神圣!

08048d56 <secret_phase>:
 8048d56: 55                   push   %ebp
 8048d57: 89 e5                mov    %esp,%ebp
 8048d59: 53                   push   %ebx
 8048d5a: 83 ec 14             sub    $0x14,%esp
 8048d5d: e8 d8 0b 00 00       call   804993a <read_line>
 8048d62: c7 44 24 08 0a 00 00 movl   $0xa,0x8(%esp)
 8048d69: 00 
 8048d6a: c7 44 24 04 00 00 00 movl   $0x0,0x4(%esp)
 8048d71: 00 
 8048d72: 89 04 24             mov    %eax,(%esp)<-将输入值压栈,调用strtol函数将其转化为long型
 8048d75: e8 7e fb ff ff       call   80488f8 <strtol@plt>
 8048d7a: 89 c3                mov    %eax,%ebx<-将输入值放入ebx
 8048d7c: 8d 40 ff             lea    -0x1(%eax),%eax
 8048d7f: 3d e8 03 00 00       cmp    $0x3e8,%eax<-(不妨设输入值为x)比较x-1与0x3e8。即输入值不能大于0x3e9,否则boom!
 8048d84: 76 05                jbe    8048d8b <secret_phase+0x35>
 8048d86: e8 94 0a 00 00       call   804981f <explode_bomb>
 8048d8b: 89 5c 24 04          mov    %ebx,0x4(%esp)<-将输入值作为参数压栈
 8048d8f: c7 04 24 d4 b6 04 08 movl   $0x804b6d4,(%esp)<-将地址0x804b6d4压栈
 8048d96: e8 6a ff ff ff       call   8048d05 <fun7>
 8048d9b: 83 f8 01             cmp    $0x1,%eax<-比较fun7(x)函数的结果与1,即要求输入值能使fun7函数得到1,fun7函数在下面解释
 8048d9e: 74 05                je     8048da5 <secret_phase+0x4f>
 8048da0: e8 7a 0a 00 00       call   804981f <explode_bomb>
 8048da5: c7 04 24 c4 9d 04 08 movl   $0x8049dc4,(%esp)
 8048dac: e8 67 fc ff ff       call   8048a18 <puts@plt>
 8048db1: e8 d4 09 00 00       call   804978a <phase_defused>
 8048db6: 83 c4 14             add    $0x14,%esp
 8048db9: 5b                   pop    %ebx
 8048dba: 5d                   pop    %ebp
 8048dbb: c3                   ret    
-----------------------------------------------------------------------
08048d05 <fun7>:
 8048d05: 55                   push   %ebp
 8048d06: 89 e5                mov    %esp,%ebp
 8048d08: 53                   push   %ebx
 8048d09: 83 ec 14             sub    $0x14,%esp
 8048d0c: 8b 55 08             mov    0x8(%ebp),%edx<-edx中存储参数1(用x代表),即是0x804b6d4
 8048d0f: 8b 4d 0c             mov    0xc(%ebp),%ecx<-ecx中存储参数2(用y代表),即是隐藏phase中输入的值
情况1:
 8048d12: b8 ff ff ff ff       mov    $0xffffffff,%eax
 8048d17: 85 d2                test   %edx,%edx <-x=0时返回-1
 8048d19: 74 35                je     8048d50 <fun7+0x4b>
情况2:
 8048d1b: 8b 1a                mov    (%edx),%ebx<-ebx=*x
 8048d1d: 39 cb                cmp    %ecx,%ebx<-若 *x<y,则开始递归
 8048d1f: 7e 13                jle    8048d34 <fun7+0x2f>
 8048d21: 89 4c 24 04          mov    %ecx,0x4(%esp)
 8048d25: 8b 42 04             mov    0x4(%edx),%eax
 8048d28: 89 04 24             mov    %eax,(%esp)
 8048d2b: e8 d5 ff ff ff       call   8048d05 <fun7><-调用fun7(0x4(%edx),%ecx)
 8048d30: 01 c0                add    %eax,%eax<-返回ret*2(即每次递归返回值*2)
 8048d32: eb 1c                jmp    8048d50 <fun7+0x4b>
 情况3:
8048d34: b8 00 00 00 00       mov    $0x0,%eax
 8048d39: 39 cb                cmp    %ecx,%ebx<-若*x=y,则返回0
 8048d3b: 74 13                je     8048d50 <fun7+0x4b>
情况4:
 8048d3d: 89 4c 24 04          mov    %ecx,0x4(%esp)<-没有判断条件可以看出是default情况
 8048d41: 8b 42 08             mov    0x8(%edx),%eax
 8048d44: 89 04 24             mov    %eax,(%esp)
 8048d47: e8 b9 ff ff ff       call   8048d05 <fun7><-调用fun7(0x8(%edx),%ecx)
 8048d4c: 8d 44 00 01          lea    0x1(%eax,%eax,1),%eax<-返回ret*2+1(即每次递归返回值*2+1)
 8048d50: 83 c4 14             add    $0x14,%esp

 8048d53: 5b                   pop    %ebx
 8048d54: 5d                   pop    %ebp
 8048d55: c3                   ret    


根据返回值是1,可以判断出递归结构是    (情况4(情况3))

那么可以判断情况4中调用的0x8(%edx)是0x804b6dc,利用gdb查看该地址中的内容是0x804b6bc,再看情况三中要求输入值与*(0x804b6bc)相等才能满足,那么再使用gdb调试出*(0x804b6bc)即可,得到结果是50,即为隐藏phase的密码。

*****************************************************************************************************************************************************************************************

bomblab完成!是不是有点小激动呢!

CSAPP 六个重要实验 lab2

哈哈~ 不愧是“美国进口的六级炸弹”!爽歪歪的“升级打怪” 我把实验材料都上传到下面这个link了,0分下载(良心啊~)...
  • u011368821
  • u011368821
  • 2014-09-10 21:37:39
  • 7606

csapp lab2 bomb 二进制炸弹《深入理解计算机系统》

bomb炸弹实验 首先对bomb这个文件进行反汇编,得到一个1000+的汇编程序,看的头大。 phase_1: 0000000000400ef0 : 400ef0: 48 83 ec 08...
  • fang92
  • fang92
  • 2015-06-05 17:13:25
  • 3266

CSAPP lab2 实验指导说明

  • 2014年09月10日 21:23
  • 272KB
  • 下载

csapp - lab2

花了一天多时间, 做完了csapp很有名的bomb实验,感到有趣的同时受益匪浅。这个lab一共有6关,关数越高,难度越大。个人觉得最后一个lab是最有趣的,涉及到了链表以及排序。...
  • zerodshei
  • zerodshei
  • 2016-08-03 10:59:15
  • 505

CSAPP 六个重要实验 lab2 实验材料

  • 2014年09月10日 21:19
  • 40KB
  • 下载

CSAPP LAB————二进制炸弹(bomblab)

LAB3 预先准备 首先查看整个bomb.c的代码,发现整个炸弹组是由6个小炸弹(函数)组成的。整个main函数比较简单,函数间变量几乎没有影响。因此,只需要依次解除6个小炸弹即可。 所以,接下来便...
  • The_V_
  • The_V_
  • 2015-07-11 15:42:10
  • 13911

Boom!!!计算机系统,从理解到爆炸,Bomblab

进入目录下 ./bomb 开始运行炸弹 对于炸弹command not found之类的鬼畜情况: chmod 777 bomb 然后再运行炸弹objdump -d bomb > bomb....
  • cww97
  • cww97
  • 2016-04-09 20:23:08
  • 5756

深入理解计算机系统bomb_lab

深入理解计算机系统 bomb_lab实验,菜菜的解题过程
  • hapoyige
  • hapoyige
  • 2016-05-07 10:26:50
  • 1774

CSAPP: Bomb Lab(2)

CSAPP Bomb Lab,Bomb3 和Bomb4 解决方法
  • u012336567
  • u012336567
  • 2016-06-18 19:10:48
  • 2209

CSAPP3e - x86-64 assembly code analysis - Bomb Lab: phase 4

先看看phase_4做了什么: 000000000040100c : 40100c: 48 83 ec 18 sub $0x18,%rsp 401010:...
  • Jason_Ranger
  • Jason_Ranger
  • 2016-06-04 23:07:28
  • 1727
收藏助手
不良信息举报
您举报文章:<csapp> bomb lab (《深入理解计算机系统》lab2)
举报原因:
原因补充:

(最多只允许输入30个字)