于是 run, 输入, 果然 :Phase 1 defused. How about the next one? 然后来看 phase2: 08048bb6 <phase_2>: 8048bb6: 55 push %ebp 8048bb7: 89 e5 mov %esp,%ebp 8048bb9:

Size: px

Start display at page:

Download "于是 run, 输入, 果然 :Phase 1 defused. How about the next one? 然后来看 phase2: 08048bb6 <phase_2>: 8048bb6: 55 push %ebp 8048bb7: 89 e5 mov %esp,%ebp 8048bb9:"

数绚阮
5 years ago
Views:

1 二进制炸弹实验报告登录服务器后, 首先运行静态分析工具 OBJDUMP 来获得程序的反汇编版本 bomb.txt, 用 word 打开便可通过汇编代码来分析程序运行 gdb bomb, 便可以在开始进行动态调试首先要做的是 break explode_bomb, 即在爆炸函数的的入口设置断点, 这样就可以避免调试过程中各种原因引起的爆炸首先来看 phase1 的代码 : 08048b90 <phase_1>: 8048b90: 55 push %ebp 8048b91: 89 e5 mov %esp,%ebp 8048b93: 83 ec 08 sub $0x8,%esp 8048b96: c c movl $0x80498c0,0x4(%esp) 8048b9d: b9e: 8b mov 0x8(%ebp),%eax 8048ba1: mov %eax,(%esp) 8048ba4: e call <strings_not_equal> 8048ba9: 85 c0 test %eax,%eax 8048bab: je 8048bb2 <phase_1+0x22> 8048bad: e8 7e call <explode_bomb> 8048bb2: 89 ec mov %ebp,%esp 8048bb4: 5d pop %ebp 8048bb5: c3 ret 注意 strings_not_equal 这个函数, 从字面上可以猜想地理解为 : 把输入的字符串和内存某处字符串相比较, 不相等的时候函数返回值的为 1 再看接下来两句 :test %eax,%eax je 8048bb2 <phase_1+0x22> Test 是把两个操作数进行与运算, 而通常这两个操作数是一样的, 此操作的意义就在于影响标志位, 当 %eax 为 0 时, 零标志位置 1, 否则零标志为 0 而从 je 指令可以知道当 %eax 为 0 时程序会跳过接下来一句对爆炸函数的引用, 所以我们的目标就是要是 %eax 即 strings_not_equal 的返回值为 0, 即要是输入的字符串与内存某处的存放的字符串相等于是现在的关键就是找出那个字符串是放在内存的哪个地方其实非常明显, $0x80498c0 这个地址在程序里实在太显眼, 用 x/s 0x80498c0 命令一查, 果然那里存放有一句话 :"I am not part of the problem.i am a Republican."

2 于是 run, 输入, 果然 :Phase 1 defused. How about the next one? 然后来看 phase2: 08048bb6 <phase_2>: 8048bb6: 55 push %ebp 8048bb7: 89 e5 mov %esp,%ebp 8048bb9: 53 push %ebx 8048bba: 83 ec 34 sub $0x34,%esp 8048bbd: 8d 45 d8 lea 0xffffffd8(%ebp),%eax 8048bc0: mov %eax,0x4(%esp) 8048bc4: 8b mov 0x8(%ebp),%eax 8048bc7: mov %eax,(%esp) 8048bca: e8 d call 8048fa8 <read_six_numbers> 8048bcf: 83 7d d8 01 cmpl $0x1,0xffffffd8(%ebp) 8048bd3: je 8048bda <phase_2+0x24> 8048bd5: e call <explode_bomb> 8048bda: bb mov $0x1,%ebx 8048bdf: 8d lea 0x1(%ebx),%eax 8048be2: 0f af 44 9d d4 imul 0xffffffd4(%ebp,%ebx,4),%eax 8048be7: d d8 cmp %eax,0xffffffd8(%ebp,%ebx,4) 8048beb: je 8048bf2 <phase_2+0x3c> 8048bed: e8 3e call <explode_bomb> 8048bf2: 43 inc %ebx 8048bf3: 83 fb 05 cmp $0x5,%ebx 8048bf6: 7e e7 jle 8048bdf <phase_2+0x29> 8048bf8: 83 c4 34 add $0x34,%esp 8048bfb: 5b pop %ebx 8048bfc: 5d pop %ebp 8048bfd: c3 ret 注意到 read_six_numbers 这个函数, 同样故名思义我先猜他为输入 6 个数字暂且不看 read_six_numbers 函数的内容, 先注意 8048bcf 这句,cmpl 显然是要引起我高度注意的, 因为比较的结果往往直接关系到爆不爆的问题这条指令的内容很明确, 就是看 0xffffffd8(%ebp) 处的数字是否为 1, 不是的话就会调用爆炸函数于是我非常坚定地认为 1 便是我该输入的第一个数字, 而输入的数字是存放在 0xffffffd8(%ebp) 开始的地址处的接着看下去,lea 0x1(%ebx),%eax 这句将 %eax 置为 be2 这句中的 0xffffffd4(%ebp,%ebx,4) 这个存储器操作数稍作思考便可以知道其实就是 0xffffffd8(%ebp), 即是我们要输入的第一个数字, 因为此时 %ebx 为 1 所以这句是将第一个数字乘以 2 放入 %eax 8048be7 又来 cmp 了, 很容易看出 0xffffffd8(%ebp,%ebx,4) 是我们输入第 2 个数字的地方, 还是因为此时 %ebx 为 1, 所以这里告诉我们, 要输入的第 2 个数字就是第一个乘以 2 的结果 8048bf2 和 8048bf3 两句告诉我们从 %ebx 等于 1 到 5 分别进行以上两段的操作,

3 即后面一个数字由前面一个数字乘以 %eax 得到, 而每次的乘数 %eax 为 %ebx 加 1, 即乘数分别为 2,3,4,5,6, 所以可以确定这六个数字分别为 1,2,3,4,5, 6 的阶乘, 即于是输入, 果然 :That's number 2. Keep going! 来看第 3 个 bomb: 08048bfe <phase_3>: 8048bfe: 55 push %ebp 8048bff:89 e5 mov %esp,%ebp 8048c01: 83 ec 28 sub $0x28,%esp 8048c04: 89 5d fc mov %ebx,0xfffffffc(%ebp) 8048c07: 8d 45 f8 lea 0xfffffff8(%ebp),%eax 8048c0a: mov %eax,0x10(%esp) 8048c0e: 8d 45 f7 lea 0xfffffff7(%ebp),%eax 8048c11: c mov %eax,0xc(%esp) 8048c15: 8d 45 f0 lea 0xfffffff0(%ebp),%eax 8048c18: mov %eax,0x8(%esp) 8048c1c: c movl $0x ,0x4(%esp) 8048c23: c24: 8b mov 0x8(%ebp),%eax 8048c27: mov %eax,(%esp) 8048c2a: e8 95 fc ff ff call 80488c4 <sscanf@plt> 8048c2f: 83 f8 02 cmp $0x2,%eax 8048c32: 7f 05 jg 8048c39 <phase_3+0x3b> 8048c34: e8 f call <explode_bomb> 8048c39: 83 7d f0 07 cmpl $0x7,0xfffffff0(%ebp) 8048c3d: ja 8048ca0 <phase_3+0xa2> 8048c3f: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 8048c42: ff jmp *0x (,%eax,4) 8048c49: b3 72 mov $0x72,%bl 8048c4b: 81 7d f8 2a cmpl $0x12a,0xfffffff8(%ebp) 8048c52: eb 48 jmp 8048c9c <phase_3+0x9e> 8048c54: b3 76 mov $0x76,%bl 8048c56: 81 7d f cmpl $0x129,0xfffffff8(%ebp) 8048c5d: eb 3d jmp 8048c9c <phase_3+0x9e> 8048c5f: b3 65 mov $0x65,%bl 8048c61: 83 7d f8 52 cmpl $0x52,0xfffffff8(%ebp) 8048c65: eb 35 jmp 8048c9c <phase_3+0x9e> 8048c67: b3 6e mov $0x6e,%bl 8048c69: 81 7d f8 cb cmpl $0xcb,0xfffffff8(%ebp) 8048c70: eb 2a jmp 8048c9c <phase_3+0x9e> 8048c72: b3 61 mov $0x61,%bl 8048c74: 81 7d f8 d cmpl $0x1d8,0xfffffff8(%ebp) 8048c7b: eb 1f jmp 8048c9c <phase_3+0x9e>

4 8048c7d: b3 6f mov $0x6f,%bl 8048c7f: 81 7d f8 c cmpl $0x3c8,0xfffffff8(%ebp) 8048c86: eb 14 jmp 8048c9c <phase_3+0x9e> 8048c88: b3 63 mov $0x63,%bl 8048c8a: 81 7d f cmpl $0x269,0xfffffff8(%ebp) 8048c91: eb 09 jmp 8048c9c <phase_3+0x9e> 8048c93: b3 7a mov $0x7a,%bl 8048c95: 81 7d f cmpl $0x277,0xfffffff8(%ebp) 8048c9c: je 8048ca7 <phase_3+0xa9> 8048c9e: eb 02 jmp 8048ca2 <phase_3+0xa4> 8048ca0: b3 70 mov $0x70,%bl 8048ca2: e call <explode_bomb> 8048ca7: 3a 5d f7 cmp 0xfffffff7(%ebp),%bl 8048caa: je 8048cb1 <phase_3+0xb3> 8048cac: e8 7f call <explode_bomb> 8048cb1: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 8048cb4: 89 ec mov %ebp,%esp 8048cb6: 5d pop %ebp 8048cb7: c3 ret Bomb3 的代码就比较长了, 先抓住重点 :jmp *0x (,%eax,4) 这句话让我想起了 switch 语句再翻翻书, 发现这段代码就是一个跳转表结构从语句上便可以看出备选的跳转地址存放在 0x 开始的地址处, 通过 %eax 的值来选择通过打印 0x 处的 16 进制数可以确认 : (gdb) print /x *0x $3 = 0x8048c49 (gdb) print /x *0x804993c $4 = 0x8048c54 (gdb) print /x *0x $5 = 0x8048c5f (gdb) print /x *0x $6 = 0x8048c67 (gdb) print /x *0x $7 = 0x8048c72 (gdb) print /x *0x804994c $8 = 0x8048c7d (gdb) print /x *0x $9 = 0x8048c88 (gdb) print /x *0x $10 = 0x8048c93 可以看到这 8 个 16 进制数正好是程序中的 8 个地址 ( 都用黑体标出 ), 对应于 %eax 为 0 到 7 时的跳转地址

5 由于 cmp $0x2,%eax jg 8048c39 <phase_3+0x3b> 两句限定了 %eax 大于 2, 所以我取 %eax 为 3, 然后查表到 8048c67 处,mov $0x6e,%bl 和 cmp 0xfffffff7(%ebp),%bl 告诉了我们 0xfffffff7(%ebp) 处应该输入的值,cmpl $0xcb,0xfffffff8(%ebp) 与 je 8048ca7 <phase_3+0xa9> 告诉了我们 0xfffffff8(%ebp) 处应该输入的值, 然后我很自然的把 0x6e 和 0xcb 换算成了 10 进制数 110 和 203, 然后迫不及待地输入 , 结果很失望的到了 break point1 这里我困惑了挺久, 我还试了 16 进制的输入, 甚至怀疑自己整个的理解是否有问题终于我发现了一个问题 : 第 2 个数字的地址为 0xfffffff7(%ebp) 而第三个为 0xfffffff8(%ebp), 显然这是不合常理的, 不可能只占一个字节而只占一个字节的东西, 我就只能想到字符了, 但明明分析程序看到的是一个数字, 要把数字与字符联系起来, 就是 ASCII 码了! 查表,6e 果然对应着一个字母 :n 于是迫不及待地输入 :3 n 203, 果然 Halfway there! 当然对应于不同的第一个数字, 有不同的答案事后我还发现, 语句 8048c1c: c movl $0x ,0x4(%esp) 中的 $0x 处的字符串 :(gdb) x/s 0x x <_IO_stdin_used+514>: "%d %c %d" 原来对输入的格式早有说明! 第 4 个 bomb: 08048cb8 <func4>: 8048cb8: 55 push %ebp 8048cb9: 89 e5 mov %esp,%ebp 8048cbb: 83 ec 0c sub $0xc,%esp 8048cbe: 89 5d f8 mov %ebx,0xfffffff8(%ebp) 8048cc1: fc mov %esi,0xfffffffc(%ebp) 8048cc4: 8b mov 0x8(%ebp),%esi 8048cc7: b mov $0x1,%eax 8048ccc: 83 fe 01 cmp $0x1,%esi 8048ccf:7e 1b jle 8048cec <func4+0x34> 8048cd1: 8d 46 ff lea 0xffffffff(%esi),%eax 8048cd4: mov %eax,(%esp) 8048cd7: e8 dc ff ff ff call 8048cb8 <func4> 8048cdc: 89 c3 mov %eax,%ebx 8048cde: 8d 46 fe lea 0xfffffffe(%esi),%eax 8048ce1: mov %eax,(%esp) 8048ce4: e8 cf ff ff ff call 8048cb8 <func4> 8048ce9: 8d lea (%eax,%ebx,1),%eax 8048cec: 8b 5d f8 mov 0xfffffff8(%ebp),%ebx 8048cef:8b 75 fc mov 0xfffffffc(%ebp),%esi 8048cf2: 89 ec mov %ebp,%esp 8048cf4: 5d pop %ebp

6 8048cf5: c3 ret 08048cf6 <phase_4>: 8048cf6: 55 push %ebp 8048cf7: 89 e5 mov %esp,%ebp 8048cf9: 83 ec 18 sub $0x18,%esp 8048cfc:8d 45 fc lea 0xfffffffc(%ebp),%eax 8048cff: mov %eax,0x8(%esp) 8048d03: c c movl $0x804992c,0x4(%esp) 8048d0a: d0b: 8b mov 0x8(%ebp),%eax 8048d0e: mov %eax,(%esp) 8048d11: e8 ae fb ff ff call 80488c4 8048d16: 83 f8 01 cmp $0x1,%eax 8048d19: jne 8048d21 <phase_4+0x2b> 8048d1b: 83 7d fc 00 cmpl $0x0,0xfffffffc(%ebp) 8048d1f: 7f 05 jg 8048d26 <phase_4+0x30> 8048d21: e8 0a call <explode_bomb> 8048d26: 8b 45 fc mov 0xfffffffc(%ebp),%eax 8048d29: mov %eax,(%esp) 8048d2c: e8 87 ff ff ff call 8048cb8 <func4> 8048d31: 83 f8 59 cmp $0x59,%eax 8048d34: je 8048d3b <phase_4+0x45> 8048d36: e8 f call <explode_bomb> 8048d3b: 89 ec mov %ebp,%esp 8048d3d: 5d pop %ebp 8048d3e: c3 ret 首先要研究下 func4 的功能容易看出是一个递归函数 lea 0xffffffff(%esi),%eax 是得到 %esi-1 的值然后调用 func4, 同样 lea 0xfffffffe(%esi),%eax 是得到 %esi-2 的值然后调用 func4,lea (%eax,%ebx,1),%eax 即是将 f(%esi-1) 的返回值 ( 在 %ebx 里面 ) 与 f(%esi-2) 的返回值相加放在 %eax 中作为 func4 的返回值, 很明显这是一个斐波那契数列的函数明白了 func4 的意思, 我直插 phase4 的心脏 :cmp $0x59,%eax Je 8048d3b <phase_4+0x45> 很清楚, 当 %eax 等于 0x59 的时候就可以过关了 %eax 是什么? 是 call 8048cb8 <func4> 后的返回值! 那此次调用的函数参数是什么呢? 就是我们输入的东西了 8048d11 和 8048d16 两句也说明了输入的是一个数字然后把斐波那契数列一排,0x59 对应的序号为 10, 输入, 果然 :So you got that one. Try this one. 看第 5 个 :

7 08048d3f <phase_5>: 8048d3f: 55 push %ebp 8048d40: 89 e5 mov %esp,%ebp 8048d42: 53 push %ebx 8048d43: 83 ec 24 sub $0x24,%esp 8048d46: 8b 5d 08 mov 0x8(%ebp),%ebx 8048d49: 89 1c 24 mov %ebx,(%esp) 8048d4c: e8 a call 8048ff9 <string_length> 8048d51: 83 f8 06 cmp $0x6,%eax 8048d54: je 8048d5b <phase_5+0x1c> 8048d56: e8 d call <explode_bomb> 8048d5b: ba mov $0x0,%edx 8048d60: 0f be 04 1a movsbl (%edx,%ebx,1),%eax 8048d64: 83 e0 0f and $0xf,%eax 8048d67: 0f b6 80 c0 a movzbl 0x804a5c0(%eax),%eax 8048d6e: a e8 mov %al,0xffffffe8(%edx,%ebp,1) 8048d72: 42 inc %edx 8048d73: 83 fa 05 cmp $0x5,%edx 8048d76: 7e e8 jle 8048d60 <phase_5+0x21> 8048d78: c6 45 ee 00 movb $0x0,0xffffffee(%ebp) 8048d7c: c f movl $0x804992f,0x4(%esp) 8048d83: d84: 8d 45 e8 lea 0xffffffe8(%ebp),%eax 8048d87: mov %eax,(%esp) 8048d8a: e call <strings_not_equal> 8048d8f: 85 c0 test %eax,%eax 8048d91: je 8048d98 <phase_5+0x59> 8048d93: e call <explode_bomb> 8048d98: 83 c4 24 add $0x24,%esp 8048d9b: 5b pop %ebx 8048d9c: 5d pop %ebp 8048d9d: c3 ret 首先,call 8048ff9 <string_length> 和 cmp $0x6,%eax 两句告诉我们要输入的是 6 个字符在指令 movsbl (%edx,%ebx,1),%eax 中,%ebx 为 6 个字符的起始地址, 通过循环增加 %edx 的值来依次将这 6 个字符的 ASCII 码传给 %eax 进行下一步操作研究下这句 :movzbl 0x804a5c0(%eax),%eax 刚才已经说了 %eax 是我们输入字符的 ASCII 码, 经过 and $0xf,%eax 处理后也就是相应 ASCII 码的低 4 位查看 0x804a5c0 处存放的东西 : (gdb) x/s 0x804a5c0 0x804a5c0 <array.0>: "isrveawhobpnutfgs\001"

8 0x804a5c0(%eax) 的寻址方式说明了这条指令是将字符串 "isrveawhobpnutfgs\001" 中的第 %eax 个字符传送给 %eax,%eax 起到了一个索引的作用循环 6 次以后, 以输入的 6 个字符的的 ASCII 码低 4 位为索引得到的字符串 "isrveawhobpnutfgs\001" 中的 6 个字符, 被装入 0xffffffe8(%ebp) 为起始地址的连续存储空间中可以看到 8048d8a 处调用了 strings_not_equal,8048d7c 处清楚地说明了比较的对象, 查看 0x804992f 处的字符串 : (gdb) x/s 0x804992f 0x804992f <_IO_stdin_used+523>: "giants" 说明我们只要使索引得到的字符串为 "giants" 就可以了! 反推回去,g i a n t s 对应的索引值为所以只要使我们输入的 6 个字符的 ASCII 码低 4 位依次为就可以了我取为 o0ekma, 于是 :Good work! On to the next... 第 6 个 bomb: 08048d9e <phase_6>: 8048d9e: 55 push %ebp 8048d9f: 89 e5 mov %esp,%ebp 8048da1: 57 push %edi 8048da2: 56 push %esi 8048da3: 53 push %ebx 8048da4: 83 ec 6c sub $0x6c,%esp 8048da7: c7 45 a4 0c a movl $0x804a60c,0xffffffa4(%ebp) 8048dae: 8d 45 c8 lea 0xffffffc8(%ebp),%eax 8048db1: mov %eax,0x4(%esp) 8048db5: 8b mov 0x8(%ebp),%eax 8048db8: mov %eax,(%esp) 8048dbb: e8 e call 8048fa8 <read_six_numbers> 8048dc0: bf mov $0x0,%edi 8048dc5: 8b 44 bd c8 mov 0xffffffc8(%ebp,%edi,4),%eax 8048dc9: 48 dec %eax 8048dca: 83 f8 05 cmp $0x5,%eax 8048dcd: jbe 8048dd4 <phase_6+0x36> 8048dcf: e8 5c call <explode_bomb> 8048dd4: 8d 5f 01 lea 0x1(%edi),%ebx 8048dd7: 83 fb 05 cmp $0x5,%ebx 8048dda: 7f 15 jg 8048df1 <phase_6+0x53> 8048ddc: 8b 44 bd c8 mov 0xffffffc8(%ebp,%edi,4),%eax 8048de0: 3b 44 9d c8 cmp 0xffffffc8(%ebp,%ebx,4),%eax 8048de4: jne 8048deb <phase_6+0x4d>

9 8048de6: e call <explode_bomb> 8048deb: 43 inc %ebx 8048dec: 83 fb 05 cmp $0x5,%ebx 8048def: 7e eb jle 8048ddc <phase_6+0x3e> 8048df1: 47 inc %edi 8048df2: 83 ff 05 cmp $0x5,%edi 8048df5: 7e ce jle 8048dc5 <phase_6+0x27> 8048df7: bf mov $0x0,%edi 8048dfc: 8b 75 a4 mov 0xffffffa4(%ebp),%esi 8048dff:bb mov $0x1,%ebx 8048e04: 3b 5c bd c8 cmp 0xffffffc8(%ebp,%edi,4),%ebx 8048e08: 7d 0c jge 8048e16 <phase_6+0x78> 8048e0a: 8b 44 bd c8 mov 0xffffffc8(%ebp,%edi,4),%eax 8048e0e: 8b mov 0x8(%esi),%esi 8048e11: 43 inc %ebx 8048e12: 39 c3 cmp %eax,%ebx 8048e14: 7c f8 jl 8048e0e <phase_6+0x70> 8048e16: bd a8 mov %esi,0xffffffa8(%ebp,%edi,4) 8048e1a: 47 inc %edi 8048e1b: 83 ff 05 cmp $0x5,%edi 8048e1e: 7e dc jle 8048dfc <phase_6+0x5e> 8048e20: 8b 75 a8 mov 0xffffffa8(%ebp),%esi 8048e23: a4 mov %esi,0xffffffa4(%ebp) 8048e26: bf mov $0x1,%edi 8048e2b: 8b 44 bd a8 mov 0xffffffa8(%ebp,%edi,4),%eax 8048e2f: mov %eax,0x8(%esi) 8048e32: 89 c6 mov %eax,%esi 8048e34: 47 inc %edi 8048e35: 83 ff 05 cmp $0x5,%edi 8048e38: 7e f1 jle 8048e2b <phase_6+0x8d> 8048e3a: c movl $0x0,0x8(%eax) 8048e41: 8b 75 a4 mov 0xffffffa4(%ebp),%esi 8048e44: bf mov $0x0,%edi 8048e49: 8b mov 0x8(%esi),%edx 8048e4c: 8b 06 mov (%esi),%eax 8048e4e: 3b 02 cmp (%edx),%eax 8048e50: 7d 05 jge 8048e57 <phase_6+0xb9> 8048e52: e8 d call <explode_bomb> 8048e57: 8b mov 0x8(%esi),%esi 8048e5a: 47 inc %edi 8048e5b: 83 ff 04 cmp $0x4,%edi 8048e5e: 7e e9 jle 8048e49 <phase_6+0xab> 8048e60: 83 c4 6c add $0x6c,%esp

10 8048e63: 5b pop %ebx

11 8048e64: 5e pop %esi 8048e65: 5f pop %edi 8048e66: 5d pop %ebp 8048e67: c3 ret 前面的 bomb 我基本上都是靠读懂汇编代码的含义来拆的, 并没有依靠单步调试而到了这第 6 个, 发现代码实在很长, 虽然单独每句操作的意思都知道, 但加在一起就不知道在干什么了, 才忽然想起来这个实验是要强迫我们熟悉对 gdb 的使用, 而不仅仅是考我们能不能看懂代码于是, 我决定依靠单步调试并不断查看相关存储信息来理解并拆掉这第 6 个 bomb read_six_numbers 函数告诉我们要输入的是 6 个数字, 于是我先随便输入为在 8048dc5 处设置断点, 以进入程序内部进行单步调试如下 : Breakpoint 2, 0x08048dc5 in phase_6 () (gdb) nexti 0x08048dc9 in phase_6 () (gdb) info register eax 0x6 6 ecx 0xbffff edx 0xbffff8b ebx 0xbffffac esp 0xbffff9b0 0xbffff9b0 ebp 0xbffffa28 0xbffffa28 esi 0x0 0 edi 0x0 0 eip 0x8048dc9 0x8048dc9 eflags 0x cs 0x ss 0x7b 123 ds 0x7b 123 es 0x7b 123 fs 0x0 0 gs 0x33 51 可以看到我们输入的第一个数字 6 到了 %eax 中继续单步接下来 4 条指令告诉我们输入的第一个数字要小于等于 6( 其实也不是完全随便输的, 还是参考了这前面的代码 ) 接下来的 cmp $0x5,%ebx 和再下面的 cmp $0x5,%edi 这两条指令提示我们要进行循环, 结合 cmp 0xffffffc8(%ebp,%ebx,4),%eax 和 jne 8048deb

12 <phase_6+0x4d> 这两条指令, 可以看出这六个数字应该互不相等此时我发现由于循环太多, 完全单步的话实在吃不消也没必要, 便在适当位置设置断点, 以加快前进速度直接前进到 8048dfc 处, 跳出前面反反复复的循环单步运行 mov 0xffffffa4(%ebp),%esi, 查看寄存器 : (gdb) nexti 0x08048dff in phase_6 () (gdb) info register eax 0x0 0 ecx 0xbffff edx 0xbffff8b ebx 0x6 6 esp 0xbffff9b0 0xbffff9b0 ebp 0xbffffa28 0xbffffa28 esi 0x804a60c edi 0x0 0 eip 0x8048dff 0x8048dff eflags 0x cs 0x ss 0x7b 123 ds 0x7b 123 es 0x7b 123 fs 0x0 0 gs 0x33 51 我们应该注意到 %esi 被赋值 0x804a60c, 这是一个地址的形式继续往下运行两步, cmp 0xffffffc8(%ebp,%edi,4),%ebx 中 0xffffffc8(%ebp,%edi,4) 即为输入的第一个数字 6, 此时 %ebx 为 1 比它小, 所以不跳转继续运行,mov 0xffffffc8(%ebp,%edi,4),%eax 重新把 %eax 置为输入的第一个数字 6, 结合下文, 用来与 %ebx 比较 mov 0x8(%esi),%esi 这句指令, 一开始看起来不知道在做什么, 查看寄存器 : (gdb) nexti 0x08048e11 in phase_6 () (gdb) info register eax 0x6 6 ecx 0xbffff edx 0xbffff8b ebx 0x1 1 esp 0xbffff9b0 0xbffff9b0 ebp 0xbffffa28 0xbffffa28 esi 0x804a edi 0x0 0

13 eip 0x8048e11 0x8048e11 eflags 0x cs 0x ss 0x7b 123 ds 0x7b 123 es 0x7b 123 fs 0x0 0 gs 0x33 51 esi 的值变了, 但形式还是一个地址, 也就是说 0x8(0x804a60c) 处放的内容是 0x804a600 我之所以把这个对应关系记下来, 是发现这几句在循环知道 %ebx 增长到 %eax 时, 而这几句的主要操作也就是不断将 0x8(%esi) 传给 %esi, 一开始真不明白是什么目的跳出这个循环来到 8048e16 处, 查看寄存器发现此时 esi 值为 0x804a5d0,%ebx 等于 %eax 等于 6, 即进行了 5 次从 0x8(%esi) 到 %esi 的传递, 而进行几次这样的传递正是受 %eax 的值控制的! 当然现在还是不明白程序到底在干嘛 8048e16 处的指令, 把 esi 的值放在了 0xffffffa8(%ebp,%edi,4) 处, 似乎可以感觉到这个值是有用的了! 接下来 inc %edi 和 cmp $0x5,%edi 两条指令意味着又要循环了, 循环的还是刚才那个从 0x8(%esi) 到 %esi 的传递的过程, 但由于 edi 的增加, 使得作为结束循环比较标准的 %eax 相应的变成了输入的第个数字的值! 到这里我已经大概知道我们输入的数字就是为了控制产生一组 esi 的值然后放在 0xffffffa8(%ebp) 开始的连续存储空间! 通过查看存储器可以得到 : 0x804a5d0+0x8= 0x804a5dc= 383 0x804a5dc+0x8= 0x804a5e8= 386 0x804a5e8+0x8= 0x804a5f4= 759 0x804a5f4+0x8= 0x804a600= 411 0x804a600+0x8= 0x804a60c= 645 0x804a60c+0x8= 0x804a5d0= 371 箭头从相应地址指向存在这个地址的内容接下来的程序容易理解,(%edx) 和 %eax 分别是有我们输入的相邻两个数字控制产生的地址指向的其中两个数 cmp (%edx),%eax 和 jge 8048e57 <phase_6+0xb9> 说明了要不爆炸的话必须满足前面一个数大于后面一个, 也就是从大到小排列! 也就是说我们要控制这 6 个数字从小到大排列通过查看每次循环中寄存器中 esi 和 eax 的关系可以得到 : 搞定! 虽然写起来麻烦, 但其实我第 6 个解得蛮快的, 就一步步往下走, 走完一遍就 ok 了, 花的时间肯定比写刚才这段报告少, 不过这种纯实验的方法写起报告来把自己都搞晕了, 看来还是要把理论和实践结合起来才好

14 Secret phase 就不写了, 没研究过是怎么找出 austinpower 的, 做的时候听人说了这个就不想去找了, 都直接去解了,secret phase 本身倒是蛮简单的总结一句 : 实践出真知, 这个实验非常好, 不愧是美国进口的!

Visualize CMap

Visualize CMap 0001 0020 0002 0021 0003 0022 0004 0023 0005 0024 0006 0025 0007 0026 0008 0027 0009 0028 000A 0029 000B 002A 000C 002B 000D 002C 000E 002D 000F 002E 0010 002F 0011 0030 0012 0031 0013 0032 0014 0033 0015