bomblab

拆炸弹实验报告
【实验目的】 理解汇编语言，学会使用调试器。
【实验原理】 二进制炸弹是作为一个目标代码文件提供给学生们的程序，运行时，它提示用户输入6个不同的字符串。如果其中任何一个不正确，炸弹就会“爆炸”：打印出一条错误信息。学生通过反汇编和逆向工程来确定是哪六个字符串，从而解除他们各自炸弹的雷管。
【实验过程】
一、准备阶段
1、打开c代码，发现没有每一关的具体代码。
2、输入objdump -d bomb > bomb.txt将汇编代码输出到服务器上自动生成的bomb.txt文件中。
3、首先找到main函数，发现调用了从phase1到phase6这六个函数（即每一关需要看懂的函数）。
二、拆炸弹
 
【phase1】
08048b50 <phase_1>:
8048b50: 83 ec 1c sub $0x1c,%esp
8048b53: c7 44 24 04 8c a2 04 movl $0x804a28c,0x4(%esp)②
8048b5a: 08
8048b5b: 8b 44 24 20 mov 0x20(%esp),%eax③
8048b5f: 89 04 24 mov %eax,(%esp) ③
8048b62: e8 5d 05 00 00 call 80490c4 <strings_not_equal>③
8048b67: 85 c0 test %eax,%eax①
8048b69: 74 05 je 8048b70 <phase_1+0x20>①
8048b6b: e8 66 06 00 00 call 80491d6 <explode_bomb>①
8048b70: 83 c4 1c add $0x1c,%esp
8048b73: c3 ret
1、根据①中的代码，在%eax=0时跳过<explode_bomb>，所以在调用<strings_not_equal>函数之后的返回值%eax必须为0。
2、②是使用0x804a28c中的内容，③是把输入的参数放进%eax中再放进 (%esp)然后调用函数，因此猜测输入字符串和设定的字符串相同时不会“爆炸”。
3、输入gdb bomb进入调试状态，用x/s 0x804a28c查看0x804a28c中的内容。
*发现提示权限不足，输入chmod 777 bomb解决问题。

4、<explode_bomb>的入口地址是0x80491d6，设置断点break *0x80491d6，然后输入命令run，进入程序，在输入提示的下一行输入"The future will be better tomorrow."，终端显示 “Phase 1 defused. How about the next one?”即第一关顺利通过。

【phase2】
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 7e 07 00 00 call 804930b <read_six_numbers>①
8048b8d: 83 7c 24 18 00 cmpl $0x0,0x18(%esp)②
8048b92: 75 07 jne 8048b9b <phase_2+0x27>②
8048b94: 83 7c 24 1c 01 cmpl $0x1,0x1c(%esp)③
8048b99: 74 05 je 8048ba0 <phase_2+0x2c>③
8048b9b: e8 36 06 00 00 call 80491d6 <explode_bomb>②
8048ba0: 8d 5c 24 20 lea 0x20(%esp),%ebx
8048ba4: 8d 74 24 30 lea 0x30(%esp),%esi
8048ba8: 8b 43 f8 mov -0x8(%ebx),%eax⑤
8048bab: 03 43 fc add -0x4(%ebx),%eax⑤
8048bae: 39 03 cmp %eax,(%ebx)④
8048bb0: 74 05 je 8048bb7 <phase_2+0x43>④
8048bb2: e8 1f 06 00 00 call 80491d6 <explode_bomb>④
8048bb7: 83 c3 04 add $0x4,%ebx⑥
8048bba: 39 f3 cmp %esi,%ebx⑥
8048bbc: 75 ea jne 8048ba8 <phase_2+0x34>⑥
8048bbe: 83 c4 34 add $0x34,%esp
8048bc1: 5b pop %ebx
8048bc2: 5e pop %esi
8048bc3: c3 ret
1、根据①，这一关应该输入6个数字。
2、根据②，如果0x18(%esp)！=0x0则第一个炸弹爆炸，因此第一个数字是0。
3、根据③，如果0x1c(%esp)！=0x1则第一个炸弹爆炸，因此第二个数字是1。
4、根据④，如果 (%ebx)！= %eax则第二个炸弹爆炸。根据⑤，%eax=-0x8(%ebx)，%eax=-0x4(%ebx)+%eax，而%ebx=0x20(%esp)，所以易得%eax=0x18(%esp)+0x1c(%esp)=0+1=1。因此第三个数字是1。
5、可以看出来④⑤⑥部分是一个循环，每次输入的值都是前两次输入的数字之和，因此六个数字为0 1 1 2 3 5。

【phase3】
08048bc4 <phase_3>:
8048bc4: 83 ec 3c sub $0x3c,%esp
8048bc7: 8d 44 24 28 lea 0x28(%esp),%eax
8048bcb: 89 44 24 10 mov %eax,0x10(%esp)
8048bcf: 8d 44 24 2f lea 0x2f(%esp),%eax
8048bd3: 89 44 24 0c mov %eax,0xc(%esp)
8048bd7: 8d 44 24 24 lea 0x24(%esp),%eax
8048bdb: 89 44 24 08 mov %eax,0x8(%esp)
8048bdf: c7 44 24 04 d6 a2 04 movl $0x804a2d6,0x4(%esp)
8048be6: 08
8048be7: 8b 44 24 40 mov 0x40(%esp),%eax
8048beb: 89 04 24 mov %eax,(%esp)
8048bee: e8 7d fc ff ff call 8048870 __isoc99_sscanf@plt
8048bf3: 83 f8 02 cmp $0x2,%eax①
8048bf6: 7f 05 jg 8048bfd <phase_3+0x39>①
8048bf8: e8 d9 05 00 00 call 80491d6 <explode_bomb>①
8048bfd: 83 7c 24 24 07 cmpl $0x7,0x24(%esp)①
8048c02: 0f 87 f5 00 00 00 ja 8048cfd <phase_3+0x139>①
8048c08: 8b 44 24 24 mov 0x24(%esp),%eax
8048c0c: ff 24 85 e8 a2 04 08 jmp *0x804a2e8(,%eax,4)
8048c13: b8 6d 00 00 00 mov $0x6d,%eax③
8048c18: 81 7c 24 28 a4 01 00 cmpl $0x1a4,0x28(%esp)②
8048c1f: 00
8048c20: 0f 84 e1 00 00 00 je 8048d07 <phase_3+0x143>②
8048c26: e8 ab 05 00 00 call 80491d6 <explode_bomb>②
8048c2b: b8 6d 00 00 00 mov $0x6d,%eax
8048c30: e9 d2 00 00 00 jmp 8048d07 <phase_3+0x143>
8048c35: b8 6d 00 00 00 mov $0x6d,%eax
8048c3a: 81 7c 24 28 01 02 00 cmpl $0x201,0x28(%esp)
8048c41: 00
8048c42: 0f 84 bf 00 00 00 je 8048d07 <phase_3+0x143>
8048c48: e8 89 05 00 00 call 80491d6 <explode_bomb>
8048c4d: b8 6d 00 00 00 mov $0x6d,%eax
8048c52: e9 b0 00 00 00 jmp 8048d07 <phase_3+0x143>
8048c57: b8 65 00 00 00 mov $0x65,%eax
8048c5c: 81 7c 24 28 a1 00 00 cmpl $0xa1,0x28(%esp)
8048c63: 00
8048c64: 0f 84 9d 00 00 00 je 8048d07 <phase_3+0x143>
8048c6a: e8 67 05 00 00 call 80491d6 <explode_bomb>
8048c6f: b8 65 00 00 00 mov $0x65,%eax
8048c74: e9 8e 00 00 00 jmp 8048d07 <phase_3+0x143>
8048c79: b8 74 00 00 00 mov $0x74,%eax
8048c7e: 81 7c 24 28 98 01 00 cmpl $0x198,0x28(%esp)
8048c85: 00
8048c86: 74 7f je 8048d07 <phase_3+0x143>
8048c88: e8 49 05 00 00 call 80491d6 <explode_bomb>
8048c8d: b8 74 00 00 00 mov $0x74,%eax
8048c92: eb 73 jmp 8048d07 <phase_3+0x143>
8048c94: b8 6b 00 00 00 mov $0x6b,%eax
8048c99: 81 7c 24 28 af 00 00 cmpl $0xaf,0x28(%esp)
8048ca0: 00
8048ca1: 74 64 je 8048d07 <phase_3+0x143>
8048ca3: e8 2e 05 00 00 call 80491d6 <explode_bomb>
8048ca8: b8 6b 00 00 00 mov $0x6b,%eax
8048cad: eb 58 jmp 8048d07 <phase_3+0x143>
8048caf: b8 67 00 00 00 mov $0x67,%eax
8048cb4: 83 7c 24 28 71 cmpl $0x71,0x28(%esp)
8048cb9: 74 4c je 8048d07 <phase_3+0x143>
8048cbb: e8 16 05 00 00 call 80491d6 <explode_bomb>
8048cc0: b8 67 00 00 00 mov $0x67,%eax
8048cc5: eb 40 jmp 8048d07 <phase_3+0x143>
8048cc7: b8 63 00 00 00 mov $0x63,%eax
8048ccc: 81 7c 24 28 90 00 00 cmpl $0x90,0x28(%esp)
8048cd3: 00
8048cd4: 74 31 je 8048d07 <phase_3+0x143>
8048cd6: e8 fb 04 00 00 call 80491d6 <explode_bomb>
8048cdb: b8 63 00 00 00 mov $0x63,%eax
8048ce0: eb 25 jmp 8048d07 <phase_3+0x143>
8048ce2: b8 61 00 00 00 mov $0x61,%eax
8048ce7: 81 7c 24 28 c2 01 00 cmpl $0x1c2,0x28(%esp)
8048cee: 00
8048cef: 74 16 je 8048d07 <phase_3+0x143>
8048cf1: e8 e0 04 00 00 call 80491d6 <explode_bomb>
8048cf6: b8 61 00 00 00 mov $0x61,%eax
8048cfb: eb 0a jmp 8048d07 <phase_3+0x143>
8048cfd: e8 d4 04 00 00 call 80491d6 <explode_bomb>①
8048d02: b8 6a 00 00 00 mov $0x6a,%eax
8048d07: 3a 44 24 2f cmp 0x2f(%esp),%al③
8048d0b: 74 05 je 8048d12 <phase_3+0x14e>③
8048d0d: e8 c4 04 00 00 call 80491d6 <explode_bomb>③
8048d12: 83 c4 3c add $0x3c,%esp
8048d15: c3 ret
1、汇编代码开头部分有指令movl $0x804a2d6,0x4(%esp)，在命令行gdb调试中输入指令x/s 0x804a2d6查看，得到"%d %c %d"，由此显示出这一题要输入数字、字符、数字。

2、根据①，参数个数大于2，第一个数字小于等于7，可能是0、1、2、3、4、5、6、7。
3、jmp 0x804a2e8(,%eax,4)，跳转的地址是0x804a2e8+4%eax，这是一个switch语句。

假设输入0，跳转到0x8048c13。
4、根据②，第二个数字为0x1a4，即420。
5、根据③，字符的ASCⅡ码为0x6d=109，即m。
6、
 

【phase4】
08048d16 :
8048d16: 83 ec 1c sub $0x1c,%esp
8048d19: 89 5c 24 14 mov %ebx,0x14(%esp)
8048d1d: 89 74 24 18 mov %esi,0x18(%esp)
8048d21: 8b 54 24 20 mov 0x20(%esp),%edx
8048d25: 8b 44 24 24 mov 0x24(%esp),%eax
8048d29: 8b 5c 24 28 mov 0x28(%esp),%ebx
8048d2d: 89 d9 mov %ebx,%ecx
8048d2f: 29 c1 sub %eax,%ecx
8048d31: 89 ce mov %ecx,%esi
8048d33: c1 ee 1f shr $0x1f,%esi
8048d36: 01 f1 add %esi,%ecx
8048d38: d1 f9 sar %ecx
8048d3a: 01 c1 add %eax,%ecx
8048d3c: 39 d1 cmp %edx,%ecx
8048d3e: 7e 17 jle 8048d57 <func4+0x41>//x-m>=0
8048d40: 83 e9 01 sub $0x1,%ecx
8048d43: 89 4c 24 08 mov %ecx,0x8(%esp)
8048d47: 89 44 24 04 mov %eax,0x4(%esp)
8048d4b: 89 14 24 mov %edx,(%esp)
8048d4e: e8 c3 ff ff ff call 8048d16
8048d53: 01 c0 add %eax,%eax
8048d55: eb 20 jmp 8048d77 <func4+0x61>
8048d57: b8 00 00 00 00 mov $0x0,%eax
8048d5c: 39 d1 cmp %edx,%ecx
8048d5e: 7d 17 jge 8048d77 <func4+0x61>
8048d60: 89 5c 24 08 mov %ebx,0x8(%esp)
8048d64: 83 c1 01 add $0x1,%ecx
8048d67: 89 4c 24 04 mov %ecx,0x4(%esp)
8048d6b: 89 14 24 mov %edx,(%esp)
8048d6e: e8 a3 ff ff ff call 8048d16
8048d73: 8d 44 00 01 lea 0x1(%eax,%eax,1),%eax
8048d77: 8b 5c 24 14 mov 0x14(%esp),%ebx
8048d7b: 8b 74 24 18 mov 0x18(%esp),%esi
8048d7f: 83 c4 1c add $0x1c,%esp
8048d82: c3 ret

08048d83 <phase_4>:
8048d83: 83 ec 2c sub $0x2c,%esp
8048d86: 8d 44 24 1c lea 0x1c(%esp),%eax
8048d8a: 89 44 24 0c mov %eax,0xc(%esp)
8048d8e: 8d 44 24 18 lea 0x18(%esp),%eax
8048d92: 89 44 24 08 mov %eax,0x8(%esp)
8048d96: c7 44 24 04 7b a4 04 movl $0x804a47b,0x4(%esp)
8048d9d: 08
8048d9e: 8b 44 24 30 mov 0x30(%esp),%eax
8048da2: 89 04 24 mov %eax,(%esp)
8048da5: e8 c6 fa ff ff call 8048870 __isoc99_sscanf@plt
8048daa: 83 f8 02 cmp $0x2,%eax
8048dad: 75 0d jne 8048dbc <phase_4+0x39>
8048daf: 8b 44 24 18 mov 0x18(%esp),%eax①
8048db3: 85 c0 test %eax,%eax①
8048db5: 78 05 js 8048dbc <phase_4+0x39>①
8048db7: 83 f8 0e cmp $0xe,%eax②
8048dba: 7e 05 jle 8048dc1 <phase_4+0x3e>②
8048dbc: e8 15 04 00 00 call 80491d6 <explode_bomb>①
8048dc1: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)③
8048dc8: 00
8048dc9: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)③
8048dd0: 00
8048dd1: 8b 44 24 18 mov 0x18(%esp),%eax③
8048dd5: 89 04 24 mov %eax,(%esp)③
8048dd8: e8 39 ff ff ff call 8048d16 ③
8048ddd: 83 f8 04 cmp $0x4,%eax③
8048de0: 75 07 jne 8048de9 <phase_4+0x66>③
8048de2: 83 7c 24 1c 04 cmpl $0x4,0x1c(%esp)④
8048de7: 74 05 je 8048dee <phase_4+0x6b>
8048de9: e8 e8 03 00 00 call 80491d6 <explode_bomb>③
8048dee: 83 c4 2c add $0x2c,%esp
8048df1: c3 ret
1、同3，需要输入两个数字。

2、根据①，第一个参数不是负数。
3、根据②，第一个参数小于等于0xe=14时跳过炸弹。
4、根据③，调用，若结果不等于 0x4则爆炸，所以调用得到的结果等于0x4。输入了第一个参数的值，调用函数，得到4，所以可以写出c程序运行查看输入几的时候输出4。
5、根据的汇编代码写出c程序，运行得到，输入2时结果为4，因此第一个参数是2。

6、根据④，若0x1c(%esp)地址中的值与0x4不相等则炸弹爆炸，因此第二个参数是4。

【phase5】
08048df2 <phase_5>:
8048df2: 53 push %ebx
8048df3: 83 ec 28 sub $0x28,%esp
8048df6: 8b 5c 24 30 mov 0x30(%esp),%ebx
8048dfa: 65 a1 14 00 00 00 mov %gs:0x14,%eax
8048e00: 89 44 24 1c mov %eax,0x1c(%esp)
8048e04: 31 c0 xor %eax,%eax
8048e06: 89 1c 24 mov %ebx,(%esp)
8048e09: e8 9d 02 00 00 call 80490ab <string_length>①
8048e0e: 83 f8 06 cmp $0x6,%eax①
8048e11: 74 05 je 8048e18 <phase_5+0x26>①
8048e13: e8 be 03 00 00 call 80491d6 <explode_bomb>①
8048e18: b8 00 00 00 00 mov $0x0,%eax②
8048e1d: 0f be 14 03 movsbl (%ebx,%eax,1),%edx②
8048e21: 83 e2 0f and $0xf,%edx②
8048e24: 0f b6 92 08 a3 04 08 movzbl 0x804a308(%edx),%edx②
8048e2b: 88 54 04 15 mov %dl,0x15(%esp,%eax,1) ②
8048e2f: 83 c0 01 add $0x1,%eax②
8048e32: 83 f8 06 cmp $0x6,%eax②
8048e35: 75 e6 jne 8048e1d <phase_5+0x2b>②
8048e37: c6 44 24 1b 00 movb $0x0,0x1b(%esp)
8048e3c: c7 44 24 04 df a2 04 movl $0x804a2df,0x4(%esp)③
8048e43: 08
8048e44: 8d 44 24 15 lea 0x15(%esp),%eax
8048e48: 89 04 24 mov %eax,(%esp)
8048e4b: e8 74 02 00 00 call 80490c4 <strings_not_equal>③
8048e50: 85 c0 test %eax,%eax
8048e52: 74 05 je 8048e59 <phase_5+0x67>
8048e54: e8 7d 03 00 00 call 80491d6 <explode_bomb>
8048e59: 8b 44 24 1c mov 0x1c(%esp),%eax
8048e5d: 65 33 05 14 00 00 00 xor %gs:0x14,%eax
8048e64: 74 05 je 8048e6b <phase_5+0x79>
8048e66: e8 65 f9 ff ff call 80487d0 __stack_chk_fail@plt
8048e6b: 83 c4 28 add $0x28,%esp
8048e6e: 5b pop %ebx
8048e6f: 90 nop
8048e70: c3 ret
1、根据①，字符串的长度为6。
2、②是一个循环，%eax中的数据从0开始增长，到6时结束，循环中首先对第一个字符取它二进制表示的低4位，然后用基址变址寻址从0x804a308 (%edx)中找到相应的字符传到edx，再取低8位也就是正好一个char类型的字符传到0x15(%esp,%eax,1)这样的一个地址中去。
3、根据③，
，前面通过计算变换得到的字符串是“bruins”。因此我们可以推回输入的字符串。首先查看地址0x804a308 里面存放的数据。

可以看到前面有一串字符，因为bruins是通过基址变址寻址得到的，因此通过这个字符串我们就能得到他们对应的偏移分别是13、6、3、4、8、7，而这些偏移正是通过我们输入的字符的ASCII码的后四位得到的，因此他们对应的二进制分别是1101、0110、0011、0100、1000、0111，然后从ASCII码表中找出对应的低位能对应上的字母即可，同样这一题的答案也是不唯一的。
4、查表，其中一种答案是mfcdhw。

【phase6】
08048e71 <phase_6>:
8048e71: 56 push %esi
8048e72: 53 push %ebx
8048e73: 83 ec 44 sub $0x44,%esp
8048e76: 8d 44 24 10 lea 0x10(%esp),%eax
8048e7a: 89 44 24 04 mov %eax,0x4(%esp)
8048e7e: 8b 44 24 50 mov 0x50(%esp),%eax
8048e82: 89 04 24 mov %eax,(%esp)
8048e85: e8 81 04 00 00 call 804930b <read_six_numbers>①
8048e8a: be 00 00 00 00 mov $0x0,%esi
8048e8f: 8b 44 b4 10 mov 0x10(%esp,%esi,4),%eax③
8048e93: 83 e8 01 sub $0x1,%eax③
8048e96: 83 f8 05 cmp $0x5,%eax②
8048e99: 76 05 jbe 8048ea0 <phase_6+0x2f>②
8048e9b: e8 36 03 00 00 call 80491d6 <explode_bomb>②
8048ea0: 83 c6 01 add $0x1,%esi
8048ea3: 83 fe 06 cmp $0x6,%esi
8048ea6: 74 1b je 8048ec3 <phase_6+0x52>④
8048ea8: 89 f3 mov %esi,%ebx④
8048eaa: 8b 44 9c 10 mov 0x10(%esp,%ebx,4),%eax④
8048eae: 39 44 b4 0c cmp %eax,0xc(%esp,%esi,4)④
8048eb2: 75 05 jne 8048eb9 <phase_6+0x48>④
8048eb4: e8 1d 03 00 00 call 80491d6 <explode_bomb>④
8048eb9: 83 c3 01 add $0x1,%ebx④
8048ebc: 83 fb 05 cmp $0x5,%ebx④
8048ebf: 7e e9 jle 8048eaa <phase_6+0x39>④
8048ec1: eb cc jmp 8048e8f <phase_6+0x1e>④
8048ec3: 8d 44 24 10 lea 0x10(%esp),%eax⑧
8048ec7: 8d 5c 24 28 lea 0x28(%esp),%ebx⑧
8048ecb: b9 07 00 00 00 mov $0x7,%ecx⑧
8048ed0: 89 ca mov %ecx,%edx⑧
8048ed2: 2b 10 sub (%eax),%edx⑧
8048ed4: 89 10 mov %edx,(%eax)⑧
8048ed6: 83 c0 04 add $0x4,%eax⑧
8048ed9: 39 d8 cmp %ebx,%eax⑧
8048edb: 75 f3 jne 8048ed0 <phase_6+0x5f>⑧
8048edd: bb 00 00 00 00 mov $0x0,%ebx
8048ee2: eb 16 jmp 8048efa <phase_6+0x89>
8048ee4: 8b 52 08 mov 0x8(%edx),%edx⑤
8048ee7: 83 c0 01 add $0x1,%eax⑤
8048eea: 39 c8 cmp %ecx,%eax⑤
8048eec: 75 f6 jne 8048ee4 <phase_6+0x73>⑤
8048eee: 89 54 b4 28 mov %edx,0x28(%esp,%esi,4)⑤
8048ef2: 83 c3 01 add $0x1,%ebx⑤
8048ef5: 83 fb 06 cmp $0x6,%ebx⑤
8048ef8: 74 17 je 8048f11 <phase_6+0xa0>⑤
8048efa: 89 de mov %ebx,%esi⑤
8048efc: 8b 4c 9c 10 mov 0x10(%esp,%ebx,4),%ecx⑤
8048f00: b8 01 00 00 00 mov $0x1,%eax⑤
8048f05: ba 3c c1 04 08 mov $0x804c13c,%edx⑤
8048f0a: 83 f9 01 cmp $0x1,%ecx⑤
8048f0d: 7f d5 jg 8048ee4 <phase_6+0x73>⑤
8048f0f: eb dd jmp 8048eee <phase_6+0x7d>⑤
8048f11: 8b 5c 24 28 mov 0x28(%esp),%ebx⑥
8048f15: 8b 44 24 2c mov 0x2c(%esp),%eax⑥
8048f19: 89 43 08 mov %eax,0x8(%ebx)⑥
8048f1c: 8b 54 24 30 mov 0x30(%esp),%edx⑥
8048f20: 89 50 08 mov %edx,0x8(%eax)⑥
8048f23: 8b 44 24 34 mov 0x34(%esp),%eax⑥
8048f27: 89 42 08 mov %eax,0x8(%edx) ⑥
8048f2a: 8b 54 24 38 mov 0x38(%esp),%edx⑥
8048f2e: 89 50 08 mov %edx,0x8(%eax) ⑥
8048f31: 8b 44 24 3c mov 0x3c(%esp),%eax⑥
8048f35: 89 42 08 mov %eax,0x8(%edx) ⑥
8048f38: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) ⑥
8048f3f: be 05 00 00 00 mov $0x5,%esi⑦
8048f44: 8b 43 08 mov 0x8(%ebx),%eax⑦
8048f47: 8b 10 mov (%eax),%edx⑦
8048f49: 39 13 cmp %edx,(%ebx)⑦
8048f4b: 7d 05 jge 8048f52 <phase_6+0xe1>⑦
8048f4d: e8 84 02 00 00 call 80491d6 <explode_bomb>⑦
8048f52: 8b 5b 08 mov 0x8(%ebx),%ebx⑦
8048f55: 83 ee 01 sub $0x1,%esi⑦
8048f58: 75 ea jne 8048f44 <phase_6+0xd3>⑦
8048f5a: 83 c4 44 add $0x44,%esp
8048f5d: 5b pop %ebx
8048f5e: 5e pop %esi
8048f5f: c3 ret
1、根据①，输入的是六个数字。
2、根据②，%eax<=0x5。根据③，第一个数字小于等于6。
3、④是一个循环，mov 0x10(%esp,%ebx,4),%eax和cmp %eax,0xc(%esp,%esi,4)两条指令把当前的数和之前的数进行比较，必须不相同才不会爆炸，经过6次循环之后，可以判断这六个数都互不相同。
4、⑤是一个循环（*），根据我们输入的6个数字，从首地址0x804c13c开始，根据输入的数字的不同在内存中查找相应的存储单元中的数据存到栈空间内。

*由循环里对%ebx的迭代发现这是一个链表，赋给%edx的初值看作链表头节点的地址，然后每一个节点都有一个指针域指向下一个节点，那么这个迭代过程就是在节点之间移动。这六个节点的地址按照输入数字的顺序存入栈帧中。
5、⑥把节点中的数据和地址按照输入的数据存放在栈帧中。
6、⑦是一个比较排序的循环，mov 0x8(%ebx),%eax、mov (%eax),%edx、cmp %edx,(%ebx)每次都取前一个节点的值和后一个比较，前一个节点的值必须大于后一个节点才不会爆炸。因此输入6个数字进行排序的时候，内存中存储的值大的必须排在前面。通过查看内存的数据，6个值分别是16进制的0x213、0x399、0x2fa、0x20f、0x34f、0x3b7，在输入数据时必须保证大的在前面，所以输入的顺序为6 2 5 3 1 4。
7、输入不正确，返回去看汇编代码，发现是忽略了⑧，所有数组元素执行a[i]=7-a[i]，因此六个数字为1 5 2 4 6 3。