HNU计算机系统实验二-拆炸弹

2401_84870313

1966人浏览 · 2025-07-22 17:52:59

2401_84870313 · 2025-07-22 17:52:59 发布

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

提示：这里可以添加本文要记录的大概内容：

实验二是一个二进制拆炸弹问题，也是CSAPP这本书8个实验其中之一，记得GIThub上有位博主讲的挺透彻，但是时间久远，记不住了。这个实验每个人分的内容（代码）都是不一样的，但是每一关的类型都是一样的，这些年的隐藏关卡都是二叉搜索树查找的汇编代码，知道其查找逻辑，基本上也就过的去。这次，我实验验收的等级是A，可以参考一下。不过建议最好全程自己做(可以用ai讲下思路，毕竟一开始接触汇编语言，难免有些吃力)，博主，当时是一边看着ai的答案，一边思考的，有几道关卡还是挺绕人的，特别是涉及到指针的一些关卡。

提示：以下是本篇文章正文内容，下面案例可供参考

【实验目的】

理解汇编语言，学会使用调试器。

【实验原理】

二进制炸弹是作为一个目标代码文件提供给学生们的程序，运行时，它提示用户输入6个不同的字符串。如果其中任何一个不正确，炸弹就会“爆炸”：打印出一条错误信息。学生通过反汇编和逆向工程来确定是哪六个字符串，从而解除他们各自炸弹的雷管。

【实验过程】

一、使用putty登录、修改密码

1、打开putty，输入用户名和密码（csapp），使用命令passwd username修改密码。
2、使用命令ls后看到有一个文件bomb49.tar，输入 tar xvf bomb49.tar 解压后，再用命令ls看到目录下新出现了bomb、bomb.c和README三个文件。一开始在看到.c文件后很开心，以为这样就可以看到c语言代码了，那拆炸弹的任务就变得简单多了。输入cat bomb.c后，把c代码看了一遍，发现原来这里只有主函数，每一关的具体代码都没有。看来只有从汇编代码入手了。
3、输入反汇编命令objdump -d bomb后，出现了大量汇编代码，在putty小窗口里看起来很麻烦。

二、用linux终端作准备

1、Ubuntu装好了之后，在终端输入ssh username@10.92.13.8连接到服务器，并开始
新一轮的尝试。
2、输入objdump -d bomb > 1.txt将汇编代码输出到服务器上一个自动生成的叫1.txt的文件中。

三、开始拆炸弹

1、首先是找到main函数，发现它调用了从phase1到phase6这六个函数。这应该就是每一关需要看懂的函数了。

2、于是找到phase1

,代码如下：

08048b33 <phase_1>:
8048b33: 83 ec 14 sub $0x14,%esp
8048b36: 68 ec 9f 04 08 push $0x8049fec
8048b3b: ff 74 24 1c pushl 0x1c(%esp)
8048b3f: e8 b4 04 00 00 call 8048ff8 <strings_not_equal>
8048b44: 83 c4 10 add $0x10,%esp
8048b47: 85 c0 test %eax,%eax
8048b49: 74 05 je 8048b50 <phase_1+0x1d>
8048b4b: e8 9f 05 00 00 call 80490ef <explode_bomb>
8048b50: 83 c4 0c add $0xc,%esp
8048b53: c3 ret

注意到两个push操作push $0x8049fec、pushl 0x1c(%esp)很容易知道pushl 0x1c(%esp)是将输入的数据压栈，而之后执行了<strings_not_equal>函数，很容易想到是与$0x8049fec中的数据比较！于是，用x/s 0x8049fec查看地址数据得到：”He is evil and fits easily into most overhead storage bins.” 这便是phase 1的答案！

3、08048b54 <phase_2>：

注意到call 8049114 <read_six_numbers> 很容易知道这一关是输入六个数字。

8048b73: 83 c4 10 add $0x10,%esp
8048b76: 83 7c 24 04 01 cmpl $0x1,0x4(%esp)
8048b7b: 74 05 je 8048b82 <phase_2+0x2e>
8048b7d: e8 6d 05 00 00 call 80490ef <explode_bomb>

对于这段代码，有cmp与je，很容易知道第一个数字必须是1 。

8048b82: 8d 5c 24 04 lea 0x4(%esp),%ebx
8048b86: 8d 74 24 18 lea 0x18(%esp),%esi
8048b8a: 8b 03 mov (%ebx),%eax
8048b8c: 01 c0 add %eax,%eax
8048b8e: 39 43 04 cmp %eax,0x4(%ebx)
8048b91: 74 05 je 8048b98 <phase_2+0x44>
8048b93: e8 57 05 00 00 call 80490ef <explode_bomb>

对于这段代码，先注意到add %eax,%eax 及将其值乘以2，又注意到cmp %eax,0x4(%ebx) 及将后一个数字与%eax比较，必须相等才不会引爆炸弹，因此，可知后一个数字是前一个数字的2倍！因此，这六个数字必须是1 2 4 8 16 32！

4、08048bb7 <phase_3>:

8048bcf: 50 push %eax
8048bd0: 68 97 a1 04 08 push $0x804a197
8048bd5: ff 74 24 2c pushl 0x2c(%esp)
8048bd9: e8 32 fc ff ff call 8048810 __isoc99_sscanf@plt
8048bde: 83 c4 10 add $0x10,%esp
8048be1: 83 f8 01 cmp $0x1,%eax
8048be4: 7f 05 jg 8048beb <phase_3+0x34>
8048be6: e8 04 05 00 00 call 80490ef <explode_bomb>

首先注意到sscanf函数，cmp $0x1,%eax、jg ，因此，输入的数据必须>1才行，而向前看到push $0x804a197 ，这一压栈操作，用x/s 0x804a197查看到%d %d ，可知输入的需是2个整型数据！继续往下看到：

8048beb: 83 7c 24 04 07 cmpl $0x7,0x4(%esp)
8048bf0: 77 3c ja 8048c2e <phase_3+0x77>
8048c2e: e8 bc 04 00 00 call 80490ef <explode_bomb>

可见，第一个数<=7 ！

8048bf2: 8b 44 24 04 mov 0x4(%esp),%eax
8048bf6: ff 24 85 58 a0 04 08 jmp *0x804a058(,%eax,4)
8048bfd: b8 4d 00 00 00 mov $0x4d,%eax

而这段代码是典型的switch使用跳转表操作。
而用p/x (0x804a058+4i)可以得到跳转表如下：
0：0x8048c3a
1：0x8048bfd
2：0x8048c04
3：0x8048c0b
4：0x8048c12
5：0x8048c19
6：0x8048c20
7：0x8048c27
依据：

8048bfd: b8 4d 00 00 00 mov $0x4d,%eax
8048c02: eb 3b jmp 8048c3f <phase_3+0x88>
8048c04: b8 e8 02 00 00 mov $0x2e8,%eax
8048c09: eb 34 jmp 8048c3f <phase_3+0x88>
8048c0b: b8 76 02 00 00 mov $0x276,%eax
8048c10: eb 2d jmp 8048c3f <phase_3+0x88>
8048c12: b8 1a 03 00 00 mov $0x31a,%eax
8048c17: eb 26 jmp 8048c3f <phase_3+0x88>
8048c19: b8 bd 01 00 00 mov $0x1bd,%eax
8048c1e: eb 1f jmp 8048c3f <phase_3+0x88>
8048c20: b8 63 00 00 00 mov $0x63,%eax
8048c25: eb 18 jmp 8048c3f <phase_3+0x88>
8048c27: b8 51 02 00 00 mov $0x251,%eax
8048c2c: eb 11 jmp 8048c3f <phase_3+0x88>
8048c2e: e8 bc 04 00 00 call 80490ef <explode_bomb>
8048c33: b8 00 00 00 00 mov $0x0,%eax
8048c38: eb 05 jmp 8048c3f <phase_3+0x88>
8048c3a: b8 15 02 00 00 mov $0x215,%eax
8048c3f: 3b 44 24 08 cmp 0x8(%esp),%eax
8048c43: 74 05 je 8048c4a <phase_3+0x93>

可以得出答案有如下几种:
0 533 、 1 77 、 2 744 、 3 630 、 4 794 、 5 280 、 6 99 、 7 593

5、08048cbe <phase_4>:

首先根据代码：

8048cd6: 50 push %eax
8048cd7: 68 97 a1 04 08 push $0x804a197
8048cdc: ff 74 24 2c pushl 0x2c(%esp)
8048ce0: e8 2b fb ff ff call 8048810__isoc99_sscanf@plt
8048ce5: 83 c4 10 add $0x10,%esp
8048ce8: 83 f8 02 cmp $0x2,%eax
8048ceb: 75 07 jne 8048cf4 <phase_4+0x36>
8048cf4: e8 f6 03 00 00 call 80490ef <explode_bomb>

注意到sscanf函数、cmp $0x2,%eax 、jne ，可知输入的数据必须是两个数据，不然会引爆炸弹！又注意到push $0x804a197压栈操作，用x/s 0x804a197 得到：%d %d 可见需输入两个整型数据！
又根据

8048ced: 83 7c 24 04 0e cmpl $0xe,0x4(%esp)
8048cf2: 76 05 jbe 8048cf9 <phase_4+0x3b>
···
8048cf9: 83 ec 04 sub $0x4,%esp
8048cfc: 6a 0e push $0xe
8048cfe: 6a 00 push $0x0
8048d00: ff 74 24 10 pushl 0x10(%esp)
8048d04: e8 57 ff ff ff call 8048c60
8048d09: 83 c4 10 add $0x10,%esp
8048d0c: 83 f8 03 cmp $0x3,%eax
8048d0f: 75 07 jne 8048d18 <phase_4+0x5a>
8048d18: e8 d2 03 00 00 call 80490ef <explode_bomb>

可以知道第一个数字要小于12，且会调用fun4函数，参数分别为14、0和第一个输入的数据！且函数的返回值必须是3！
下面分析fun4函数：

08048c60 :
8048c60: 56 push %esi
8048c61: 53 push %ebx
8048c62: 83 ec 04 sub $0x4,%esp
8048c65: 8b 4c 24 10 mov 0x10(%esp),%ecx
8048c69: 8b 5c 24 14 mov 0x14(%esp),%ebx
8048c6d: 8b 74 24 18 mov 0x18(%esp),%esi

通过以上代码可知%esi是第一个参数x初值14、%ebx是第二个参数y初值0、%ecx是第三个参数及输入的第一个数a。

8048c71: 89 f0 mov %esi,%eax
8048c73: 29 d8 sub %ebx,%eax
8048c75: 89 c2 mov %eax,%edx
8048c77: c1 ea 1f shr $0x1f,%edx
8048c7a: 01 d0 add %edx,%eax
8048c7c: d1 f8 sar %eax
8048c7e: 8d 14 18 lea (%eax,%ebx,1),%edx

这段代码是取x、y的中值，及%edx=(%esi-ebx)/2+ebx 。

8048c81: 39 ca cmp %ecx,%edx
8048c83: 7e 15 jle 8048c9a <func4+0x3a>

如果中值<=a则跳转。

8048c85: 83 ec 04 sub $0x4,%esp
8048c88: 83 ea 01 sub $0x1,%edx
8048c8b: 52 push %edx
8048c8c: 53 push %ebx
8048c8d: 51 push %ecx
8048c8e: e8 cd ff ff ff call 8048c60
递归调用，x=中值-1，y=y，a=a。
8048c93: 83 c4 10 add $0x10,%esp
8048c96: 01 c0 add %eax,%eax
返回值2
8048c98: eb 1e jmp 8048cb8 <func4+0x58>
8048c9a: b8 00 00 00 00 mov $0x0,%eax
8048c9f: 39 ca cmp %ecx,%edx
8048ca1: 7d 15 jge 8048cb8 <func4+0x58>
如果中值>=a则跳转，可见当==时，返回0！
8048ca3: 83 ec 04 sub $0x4,%esp
8048ca6: 56 push %esi
8048ca7: 83 c2 01 add $0x1,%edx
8048caa: 52 push %edx
8048cab: 51 push %ecx
8048cac: e8 af ff ff ff call 8048c60
递归调用x=x，y=中值+1，a=a。
8048cb1: 83 c4 10 add $0x10,%esp
8048cb4: 8d 44 00 01 lea 0x1(%eax,%eax,1),%eax
返回值2+1
8048cb8: 83 c4 04 add $0x4,%esp
8048cbb: 5b pop %ebx
8048cbc: 5e pop %esi
8048cbd: c3 ret

由此可知，fun4函数是一个查找函数，返回值依据查找深度和方向决定！
而知3=(0*2+1)*2+1，故深度为3，且查找方向为<、<、=！(中值比a)故计算出a=12！
再看<phase_4>接下来的代码：

8048d11: 83 7c 24 08 03 cmpl $0x3,0x8(%esp)
8048d16: 74 05 je 8048d1d <phase_4+0x5f>
8048d18: e8 d2 03 00 00 call 80490ef <explode_bomb>

可知输入的第二个数据必须为3！
因此<phase_4>的答案为：12 3

6、08048d33 <phase_5>:

注意到：

8048d47: 53 push %ebx
8048d48: e8 8c 02 00 00 call 8048fd9 <string_length>
8048d4d: 83 c4 10 add $0x10,%esp
8048d50: 83 f8 06 cmp $0x6,%eax
8048d53: 74 05 je 8048d5a <phase_5+0x27>
8048d55: e8 95 03 00 00 call 80490ef <explode_bomb>
调用了<string_length>函数且有cmp $0x6,%eax、je ，易知需要输入长度为6的字符串！
8048d5a: b8 00 00 00 00 mov $0x0,%eax
8048d5f: 0f b6 14 03 movzbl (%ebx,%eax,1),%edx
8048d63: 83 e2 0f and $0xf,%edx
取%edx的低4位
8048d66: 0f b6 92 78 a0 04 08 movzbl 0x804a078(%edx),%edx
8048d6d: 88 54 04 05 mov %dl,0x5(%esp,%eax,1)
将带+%edx偏移量的字符入栈
8048d71: 83 c0 01 add $0x1,%eax
8048d74: 83 f8 06 cmp $0x6,%eax
8048d77: 75 e6 jne 8048d5f <phase_5+0x2c>
循环6次
8048d79: c6 44 24 0b 00 movb $0x0,0xb(%esp)
8048d7e: 83 ec 08 sub $0x8,%esp
8048d81: 68 4e a0 04 08 push $0x804a04e
将地址存储的数据压栈
8048d86: 8d 44 24 11 lea 0x11(%esp),%eax
8048d8a: 50 push %eax
8048d8b: e8 68 02 00 00 call 8048ff8 <strings_not_equal>
比较两字符串
8048d90: 83 c4 10 add $0x10,%esp
8048d93: 85 c0 test %eax,%eax
8048d95: 74 05 je 8048d9c <phase_5+0x69>
若不等则引爆炸弹
8048d97: e8 53 03 00 00 call 80490ef <explode_bomb>

分析可以知道，具体操作是将输入的每个字符的ASCII码的低4位作为偏移量，在0x804a078存储的字符串中进行偏移，获取新的字符串，然后将新的字符串与$0x804a04e中的字符串进行比较，相等则通过，不等则爆炸。通过x/s 0x804a078得到：flames；通过x/s 0x804a078得到：maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you? 而flames在此字符串中的位置为：9 15 1 0 5 7；故取ASCII码的低4位分别为这六个数的字符即可。其中一个答案为：ioa@eg

7、08048db3 <phase_6>:

注意到函数<read_six_numbers>可知第六关也是输入6个数字。

8048dda: 8b 44 b4 0c mov 0xc(%esp,%esi,4),%eax
8048dde: 83 e8 01 sub $0x1,%eax
8048de1: 83 f8 05 cmp $0x5,%eax
8048de4: 76 05 jbe 8048deb <phase_6+0x38>
8048de6: e8 04 03 00 00 call 80490ef <explode_bomb>

注意到cmp $0x5,%eax、jbe ，可知%eax要<=5，而前面有个sub-1操作，故真正的输入范围应该是1~6 。
分析以下代码：

8048deb: 83 c6 01 add $0x1,%esi
8048dee: 83 fe 06 cmp $0x6,%esi
8048df1: 74 1b je 8048e0e <phase_6+0x5b>
循环6次
8048df3: 89 f3 mov %esi,%ebx
8048df5: 8b 44 9c 0c mov 0xc(%esp,%ebx,4),%eax
8048df9: 39 44 b4 08 cmp %eax,0x8(%esp,%esi,4)
8048dfd: 75 05 jne 8048e04 <phase_6+0x51>
8048dff: e8 eb 02 00 00 call 80490ef <explode_bomb>
8048e04: 83 c3 01 add $0x1,%ebx
8048e07: 83 fb 05 cmp $0x5,%ebx
8048e0a: 7e e9 jle 8048df5 <phase_6+0x42>
以上代码将每个数字和其他数字比较，如果相等则引爆炸弹
8048e0c: eb cc jmp 8048dda <phase_6+0x27>
8048e0e: 8d 44 24 0c lea 0xc(%esp),%eax
8048e12: 8d 5c 24 24 lea 0x24(%esp),%ebx
8048e16: b9 07 00 00 00 mov $0x7,%ecx
8048e1b: 89 ca mov %ecx,%edx
8048e1d: 2b 10 sub (%eax),%edx
8048e1f: 89 10 mov %edx,(%eax)
将输入数据偏置为7-input
8048e21: 83 c0 04 add $0x4,%eax
8048e24: 39 c3 cmp %eax,%ebx
8048e26: 75 f3 jne 8048e1b <phase_6+0x68>
分析可知，输入的6个数字必须都不同，且存储的地址内的数据会偏置为7-input 。
分析以下代码：
8048e28: bb 00 00 00 00 mov $0x0,%ebx
8048e2d: eb 16 jmp 8048e45 <phase_6+0x92>
8048e2f: 8b 52 08 mov 0x8(%edx),%edx
8048e32: 83 c0 01 add $0x1,%eax
8048e35: 39 c8 cmp %ecx,%eax
8048e37: 75 f6 jne 8048e2f <phase_6+0x7c>
类似get函数，找到索引的值
8048e39: 89 54 b4 24 mov %edx,0x24(%esp,%esi,4)
8048e3d: 83 c3 01 add $0x1,%ebx
8048e40: 83 fb 06 cmp $0x6,%ebx
8048e43: 74 17 je 8048e5c <phase_6+0xa9>
8048e45: 89 de mov %ebx,%esi
8048e47: 8b 4c 9c 0c mov 0xc(%esp,%ebx,4),%ecx
将偏置后的数字给ecx
8048e4b: b8 01 00 00 00 mov $0x1,%eax
8048e50: ba 3c c1 04 08 mov $0x804c13c,%edx
8048e55: 83 f9 01 cmp $0x1,%ecx
8048e58: 7f d5 jg 8048e2f <phase_6+0x7c>
8048e5a: eb dd jmp 8048e39 <phase_6+0x86>

分析知道以上代码是将6个数字当作索引，在0x804c13c首地址的数组中找到对应的值mov到数字对应的位置；例如：4 3 5 6 1 2执行后为a[3] a[2] a[4] a[5] a[0] a[1]
用p/x *(0x804c13c)得到节点值，p/x *(0x804c13c+8)得到下一节点指针
索引指针值下一节点指针
1 0x804c13c 0xfa 0x804c148
2 0x804c148 0x281 0x804c154
3 0x804c154 0x2fe 0x804c160
4 0x804c160 0x23e 0x804c16c
5 0x804c16c 0x1ce 0x804c178
6 0x804c178 0x1a5 0x0

8048e5c: 8b 5c 24 24 mov 0x24(%esp),%ebx
8048e60: 8d 44 24 24 lea 0x24(%esp),%eax
8048e64: 8d 74 24 38 lea 0x38(%esp),%esi
8048e68: 89 d9 mov %ebx,%ecx
8048e6a: 8b 50 04 mov 0x4(%eax),%edx
8048e6d: 89 51 08 mov %edx,0x8(%ecx)
8048e70: 83 c0 04 add $0x4,%eax
8048e73: 89 d1 mov %edx,%ecx
8048e75: 39 c6 cmp %eax,%esi
8048e77: 75 f1 jne 8048e6a <phase_6+0xb7>

构建新链表

8048e79: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
8048e80: be 05 00 00 00 mov $0x5,%esi
8048e85: 8b 43 08 mov 0x8(%ebx),%eax
8048e88: 8b 00 mov (%eax),%eax

获取下一节点的值

8048e8a: 39 03 cmp %eax,(%ebx)
8048e8c: 7d 05 jge 8048e93 <phase_6+0xe0>
8048e8e: e8 5c 02 00 00 call 80490ef <explode_bomb>

分析可以知道新的链表必须降序排列！故偏置后的顺序应该为 3 2 4 5 6 1 ，因此输入的6个数字应该为：4 5 3 2 1 6 ！

8、08048f04 <secret_phase>:

首先在main函数中发现，在6个关卡函数都运行后都还运行了<phase_defused>函数，分析<phase_defused>代码发现操作push $0x804a1f1 ，用x/s 0x804a1f1后得到：%d %d %s 。而输入的是两个数字的关卡有<phase_3> 、 <phase_4>
同时发现：

804928c: 68 fa a1 04 08 push $0x804a1fa
8049291: 8d 44 24 18 lea 0x18(%esp),%eax
8049295: 50 push %eax
8049296: e8 5d fd ff ff call 8048ff8 <strings_not_equal>

因此，易知输入的字符串%s是与0x804a1fa中的数据比较，用x/s 0x804a1fa得到：DrEvil 。因此，输入的字符串便是DrEvil ！
在输入第三关的答案时，再输入DrEvil虽然不会引爆炸弹但是也不会进入隐藏关卡，在输入第四关的答案时加上DrEvil才会进入隐藏关卡。
分析<secret_phase>代码发现：cmp $0x3e8,%eax 、jbe ，因此可知输入的数字需<=1000 。
同时发现：

8048f31: 53 push %ebx
8048f32: 68 88 c0 04 08 push $0x804c088
8048f37: e8 77 ff ff ff call 8048eb3
8048f3c: 83 c4 10 add $0x10,%esp
8048f3f: 83 f8 06 cmp $0x6,%eax
8048f42: 74 05 je 8048f49 <secret_phase+0x45>
8048f44: e8 a6 01 00 00 call 80490ef <explode_bomb>

可见函数有两个参数，一个是输入的数据input，一个是地址0x804c088，且返回值必须是6才行！
而代码如下：

08048eb3 :
8048eb3: 53 push %ebx
8048eb4: 83 ec 08 sub $0x8,%esp
8048eb7: 8b 54 24 10 mov 0x10(%esp),%edx
8048ebb: 8b 4c 24 14 mov 0x14(%esp),%ecx
8048ebf: 85 d2 test %edx,%edx
8048ec1: 74 37 je 8048efa <fun7+0x47>
指针不为NULL，否则返回-1
8048ec3: 8b 1a mov (%edx),%ebx
8048ec5: 39 cb cmp %ecx,%ebx
8048ec7: 7e 13 jle 8048edc <fun7+0x29>
input>§那么就调用右子树，小于则调用左子树
8048ec9: 83 ec 08 sub $0x8,%esp
8048ecc: 51 push %ecx
8048ecd: ff 72 04 pushl 0x4(%edx)
8048ed0: e8 de ff ff ff call 8048eb3
8048ed5: 83 c4 10 add $0x10,%esp
8048ed8: 01 c0 add %eax,%eax
返回值2
8048eda: eb 23 jmp 8048eff <fun7+0x4c>
8048edc: b8 00 00 00 00 mov $0x0,%eax
8048ee1: 39 cb cmp %ecx,%ebx
8048ee3: 74 1a je 8048eff <fun7+0x4c>
==则返回0
8048ee5: 83 ec 08 sub $0x8,%esp
8048ee8: 51 push %ecx
8048ee9: ff 72 08 pushl 0x8(%edx)
8048eec: e8 c2 ff ff ff call 8048eb3
8048ef1: 83 c4 10 add $0x10,%esp
8048ef4: 8d 44 00 01 lea 0x1(%eax,%eax,1),%eax
返回值*2+1
8048ef8: eb 05 jmp 8048eff <fun7+0x4c>
8048efa: b8 ff ff ff ff mov $0xffffffff,%eax
8048eff: 83 c4 08 add $0x8,%esp
8048f02: 5b pop %ebx
8048f03: c3 ret