雪城大学信息安全讲义 4.3~4.4

3 对抗措施

3.1 应用安全工程原则

  • 使用强类型语言,例如 Java、C#,以及其他。使用这些语言,可以避免缓冲区溢出。

  • 使用安全的库函数

    • 可能拥有缓冲区溢出问题的函数:getsstrcpystrcatsprintf
    • 这些函数更加安全:fgetsstrncpystrncat以及snprintf

3.2 系统化代码修改

  • StackShield:分离控制(返回地址)和数据。

    • 它是保护返回地址的 GCC 编译器扩展。
    • 当函数调用时,StackShield 将返回地址复制到不能覆盖的区域。
    • 从函数返回时,返回地址被存储。因此,即使栈上的返回地址发生改变,也没有效果,因为原始的返回地址在返回地址用于跳转之前复制了回来。
  • StackGuard:标记缓冲区的边界

    • 观察:一个人需要覆盖返回地址之前的内存,来覆盖返回地址。换句话说,攻击者很难治修改返回地址,而不修改返回地址之前的栈内存。
    • 无论函数什么时候调用,都可以将一个哨兵值放在返回地址的旁边。
    • 如果函数返回值,哨兵值发生改变,就代表发生了缓冲区溢出。
    • StackGuard 也内建于 GCC。
    • 我们可以理解 StackGuard 如何工作,通过下面的程序(我们模拟了编译器,手动将保护代码添加到函数中)。处于明显的原因,我们在这个例子中使用整数作为哨兵值,它还不够强大。我们可以使用多个整数作为哨兵值。
    /* This program has a buffer overflow vulnerability. */ 
    /* However, it is protected by StackGuard */ 
    
    #include <stdlib.h> 
    
    
    #include <stdio.h> 
    
    
    #include <string.h>
    
    int func (char *str) {
        int canaryWord = secret; 
        char buffer[12];
        /* The following statement has a buffer overflow problem */ 
        strcpy(buffer, str);
        if (canaryWord == secret) // Return address is not modified 
            return 1; 
        else { // Return address is potentially modified 
            ... error handling ... 
        }
    }
    static int secret; // a global variable
    int main(int argc, char **argv) { 
        // getRandomNumber will return a random number 
        secret = getRandomNumber();
        char str[517]; 
        FILE *badfile;
        badfile = fopen("badfile", "r"); 
        fread(str, sizeof(char), 517, badfile); 
        func (str); 
        printf("Returned Properly\n"); 
        return 1;
    }

3.3 操作系统方法

  • 地址空间随机化(ASLR):猜测恶意代码的地址空间是一个缓冲区溢出的关键步骤。如果我们可以使恶意代码的地址难以预测,攻击就能变得更困难。多种 Linux 发行版都已经使用了 ASLR 来随机化堆和栈的起始地址。这使得猜测准确地址变得困难。下面的命令(只能由 Root 运行)开启或禁用 ASLR:

    
    # sysctl -w kernel.randomize_va_space=2 // Enable Randomization 
    
    
    # sysctl -w kernel.randomize_va_space=0 // Disable Randomization
    

    不幸的是,在 32 位机器上,即使地址空间随即化了,熵依然不是非常大,来放置猜测。实际上,如果你尝试多次,你的成功率就会非常高。我们的经验表明,几分钟的尝试足以成功利用 Intel 2GHz 的机器。

  • 不可执行栈:从攻击中,我们可以观察到,攻击者将恶意代码放置在栈上,并跳转到它。由于栈是数据而不是代码的地方,我们可以将栈配置为不可执行,因此防止了恶意代码的执行。

    这个保护机制叫做 ExecShield,多种 Linux 发行版已经实现了该机制。ExecShield 本质上禁止了储存在栈上的任意代码的执行。下面的代码(只能由 Root 执行)开启或禁用了 ExecShield。

    
    # sysctl -w kernel.exec-shield=1 // Enable ExecShield 
    
    
    # sysctl -w kernel.exec-shield=0 // Disable ExecShield
    

    在下一节中,我们可以看到,这种保护模式并没有解决缓冲区溢出问题,因为另一种类型的攻击,叫做 Return-to-Libc 攻击不需要可执行的栈。

4 不可执行栈和 Return-to-Libc 攻击

为了利用基于栈的缓冲区溢出漏洞,攻击者需要将代码段注入到用户的栈上,之后执行栈上的代码。如果我们使栈的内存段不可执行,即使代码注入到了栈中,代码也不能够执行。这样,我们就可以放置缓冲区溢出攻击。严格来说,这易于实现,因为现代 CPU 架构(例如 x86)的确允许操作系统来将一块内存变为不可执行。但是,还是没有那么简单:许多操作系统,例如 Linux,将代码保存到栈中,因此需要可执行的栈。例如,Linux 为了处理信号,需要在用户栈中放置代码序列。这个序列会在处理信号时执行。

新版本的 Linux 已经使栈只存放数据了。因此,栈可以配置成不可执行。在 Fedora 中,我们可以执行下列命令来使栈不可执行:

# /sbin/sysctl -w kernel.exec-shield=1

不幸的是,使栈不可执行不能完全放置缓冲区溢出。它使运行栈上的代码变得不可能,但是还有其它方法来利用缓冲区溢出漏洞,不需要执行栈上的任意代码。Return-to-Libc 攻击就是这种攻击。

为了理解这种新型攻击,让我们回忆从栈中执行恶意代码的主要目的。我们知道它为了调用 Shell。问题就是,我们是否能够不实用输入的代码来调用 Shell?这实际上是可行的:我们可以使用操作系统自身的代码来调用 Shell。更加具体来讲,我们可以使用操作系统的库函数来完成我们的目标。在类 Unix 系统中,叫做 Libc 的共享库提供了 C 运行时。这个库是多数 C 程序的基础,因为它定义了系统调用,以及其他基本的设施,例如openmallocprintfsystem,以及其他。Libc 的代码已经作为共享运行时库在内存中了,并且他可以被所有应用访问。

函数system是 Libc 中的函数之一。如果我们可以使用参数/bin/sh调用这个函数,我们就可以获得 Shell。这是 Return-to-Libc 攻击的基本原理。攻击的第一部分类似于使用 Shellcode 的攻击,它溢出了缓冲区,并修改了栈上的返回地址。第二部分所有不同。不像 Shellcode 方式,返回地址不指向任何注入的代码。它指向 Libc 中函数system的入口。如果我们执行正确,我们就可以强迫目标程序执行system("/bin/sh"),它会加载 Shell。

挑战:为了完成 Return-to-Libc 攻击,我们需要客服如下困难:

  • 如何寻找system的位置?
  • 如何寻找字符串/bin/sh的位置?
  • 如何将字符串/bin/sh的地址传递给system函数?

4.1 寻找system函数的位置

在多数 Unix 操作系统中, Libc 库始终加载到固定内存地址中。为了寻找 Libc 函数的地址,我们可以使用下面的 GDB 命令(假设a.out是任意程序):

$ gdb a.out 
(gdb) b main 
(gdb) r 
(gdb) p system 
    $1 = {<text variable, no debug info>} 0x9b4550 <system> 
(gdb) p exit 
    $2 = {<text variable, no debug info>} 0x9a9b70 <exit>

从上面的 GDB 命令,我们可以发现,system函数的地址是0x9b4550,函数exit的返回地址是0x9a9b70。你系统中的实际地址可能不同。

我们也可以调用函数dlopendlsym来寻找 Libc 中函数的地址。

#include <dlfcn.h>

#define LIBCPATH "/lib/libc.so.6" /* on Fedora */

void *libh, *sys;

if ((libh = dlopen(LIBCPATH, RTLD_NOW)) == NULL){ 
    // report error 
}

if (( sys = dlsym (libh, "system")) == NULL){ 
    // report error 
} 
printf("system @ %p\n", sys);

4.2 寻找/bin/sh的地址

有几种方式来寻找这种字符串的地址:

  • 使用缓冲区溢出问题,直接将地址插入栈中,之后猜测它的地址。

  • 在执行漏洞程序之前,创建环境变量,值为/bin/sh。当 C 程序从 Shell 执行时,它就会从 Shell 继承所有环境变量。下面,我们定义了新的 Shell 变量MYSHELL,并使它的值为/bin/sh

    $ export MYSHELL=/bin/sh
  • 我们使用这个变量的地址作为system调用的参数。这个变量在内存中的位置可以使用下面的程序轻易在内存中找到:

    void main() { 
        char* shell = getenv("MYSHELL"); 
        if (shell) 
            printf("%x\n", shell); 
    }

    如果站地址没有随机化,我们会发现打印出了相同地址。但是,当我们运行另一个程序时,环境变量的地址可能和你刚刚运行的程序不一样。这种地址在你修改程序名称时就可能改变(因为文件名称的字符数量不同了)。好消息是,Shell 的地址会很接近你是用上一个程序打印出来的东西。因此,你可能需要尝试几次直到成功。

  • 我们也知道,函数system在自己的代码中使用/bin/sh。因此,字符串必然存在于 Libc。如果我们能够寻找字符串的位置,我们就可以直接使用这个字符串。你可以在 LIBC 库文件(/lib/libc.so.6)中搜索字符串rodata

    $ readelf -S /lib/lib.so.6 | egrep ’rodata’ 
    [15] .rodata PROGBITS 009320e0 124030 ......

    上面命令的结果表明,.rodata段起始于0x009320e0.rodata段用于储存不变数据,字符串常量/bin/sh应该储存在这一段内。你可以编写程序来在起始于0x00932030的内存中搜索字符串。

4.3 将/bin/sh的地址传给system

为了让system执行命令/bin/sh,我们需要将命令字符串的地址作为参数传给system。就像调用任何函数那样,我们需要通过栈传递参数。因此,我们需要将参数放到栈上的正确位置。为了执行正确,我们需要清晰理解调用函数的时候,函数的栈帧如何构建。我们使用小型的 C 程序来理解函数调用在栈上的影响:

/* foobar.c */ 
#include<stdio.h> 
void foo(int x) { 
    printf("Hello world: %d\n", x);
}
int main() { 
    foo(1); 
    return 0; 
}

我们可以使用gcc -S foobar.c来将这个程序编译为汇编代码。产生的文件foobar.s像这样:

   ...... 
 8 foo: 
 9 pushl %ebp 
10 movl %esp, %ebp 
11 subl $8, %esp 
12 movl 8(%ebp), %eax 
13 movl %eax, 4(%esp) 
14 movl $.LC0, (%esp) : string "Hello world: %d\n" 
15 call printf 
16 leave 
17 ret 
   ...... 
21 main: 
22 leal 4(%esp), %ecx 
23 andl $-16, %esp 
24 pushl -4(%ecx) 
25 pushl %ebp 
26 movl %esp, %ebp 
27 pushl %ecx 
28 subl $4, %esp 
29 movl $1, (%esp) 
30 call foo 
31 movl $0, %eax 
32 addl $4, %esp 
33 popl %ecx 
34 popl %ebp 
35 leal -4(%ecx), %esp 
36 ret

调用和进入foo。让我们专注于调用foo时的栈。我们可以忽略之前的栈。要注意,行号而不是指令地址用于解释。

  • 28~29 行:两个语句将值 1,也就是foo的参数压入栈。这个操作使%esp增加了 4。两个豫剧之后的栈由图 3(a) 描述:

    图 3:foo的进入的返回

  • 30 行:call foo:这个语句将call语句的下一条语句的地址压入了栈(也就是返回地址),并跳到foo的代码。当前的栈由图 3(b) 描述。

  • 9~10 行:函数foo的第一行将%ebp压入了栈,来保存上一个帧指针。第二行让%ebp指向当前的帧。当前的栈由图 3(c) 描述。

  • 11 行:subl $8, %esp:栈指针发生改变,来为局部变量和两个传给printf的参数分配空间(8 个字节)。所以函数foo中没有局部变量,8 字节全部用于参数。请见图 3(d)。

离开foo:现在控制流传给了函数foo。让我们看看当函数返回时,栈上发生了什么。

  • 16 行:leave:这个指令隐式执行两条指令(在早期 x86 发行版中它是一个宏,但是后来做成了一个指令):

    mov %ebp, %esp 
    pop %ebp

    第一条语句释放了为函数分配的栈空间,之后跳到了返回地址。当前的栈由图 3(e) 描述。

  • 17 行:ret:这个指令只是弹出栈的返回地址,之后跳到返回地址,当前的栈图 3(f) 描述。

4.4 /bin/bash中的保护

如果/bin/sh指向了/bin/bash,即使我们可以在权限的 Set-UID 程序中调用 Shell,我们也不能获得 Root 权限。这是因为 Bash 会自动降低它的权限,如果它执行在 Set-UID Root 上下文中。

但是,有几种方式来绕过这个保护模式。虽然/bin/bash限制了 Set-UID 程序的运行,它的确允许以真实的 Root 权限运行 Shell。所以,如果我们可以将当前的 Set-UID 进程转换为真实的 Root 进程,在我们调用/bin/bash之前,我们就可以绕过这个 Bash 的限制。setuid(0)系统调用可以帮助你实现它。因此,我们首先需要调用setuid(0),之后调用system("/bin/sh")。所有这些可以使用 Return-to-Libc 机制来实现。

基本上,我们需要两次 Return-to-Libc。我们首先让目标程序返回到 Libc 的setuid函数。当这个函数返回时,它会从栈上抓取返回地址,并跳到该地址。如果我们可以让这个返回地址指向system,我们就可以让函数setuid强制返回到system的入口。在执行这个过程时,我们需要十分小心,因为我们需要将合理的参数放到栈的正确位置。

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

抵扣说明:

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

余额充值