Data-Oriented Programming

Data-Oriented Programming: On the Expressiveness of Non-Control Data Attacks

引言

  • 上一代的攻击方式是通过代码注入来劫持程序控制流
  • ROP 和 DOP 都是图灵完整的
  • 在程序的控制执行中执行一些简短的指令序列,使得模拟图灵机的具体操作成为可能,如赋值、运算等

问题

非控制数据攻击(Non-control Data Attacks)

  • 在一些环境上(如现代浏览器),仅仅是几个内存字节的破坏就可能导致远程攻击者的图灵完全攻击
  • printf这样的格式化字符串函数,接受并解释格式化参数的这类函数,对格式化字符串 “语言” 来说,实际上也是图灵完整的解释器
  • 如果非控制数据攻击可以允许攻击者完全控制格式字符串参数,那么攻击者可以构造有效的 payload

数据导向编程的例子

Code1, 带有 DOP Gadgets 的 FTP Server 代码:

1 struct server{ int *cur_max, total, typ;} *srv;
2 int connect_limit = MAXCONN; int *size, *type;
3 char buf[MAXLEN];
4 size = &buf[8]; type = &buf[12];
5 ...
6 while(connect_limit--) {
7     readData(sockfd, buf); // stack bof
8     if(*type == NONE ) break;
9     if(*type == STREAM) // condition
10       *size = *(srv->cur_max); // dereference
11     else {
12       srv->typ = *type; // assignment
13       srv->total += *size; // addition
14     } ... (following code skipped) ...
15 }

上述代码不会在良性控制流中调用任何涉及安全的关键功能,因此漏洞仅破坏局部变量。

Code2, 函数将链接列表的整数字段递增给定值:

1 struct Obj{struct Obj *next; unsigned int prop;}
2 void updateList(struct Obj *list, int addend) {
3     for(; list != NULL; list = list->next)
4         list->prop += addend;
5 }

DOP 编程

MinDOP

最小 DOP 语言:

语义 C 语言 DOP Gadgets
算术 / 逻辑运算 a op b *p op *q
赋值 a = b *p = *q
加载 a = *b *p = **q
储存 *a = b **p = *q
跳转 goto L vpc = &input
条件跳转 if a goto L vpc = &input if *p

注:p - &a; q - &b; op - 算术/逻辑运算; vpc - virtual input pointer

在 MinDOP 中,实现了经精心选择的储存单元(不是硬件寄存器)的虚拟寄存器,在 Gadgets 的控制下下使用。

在概念上,数据导向 Gadgets 模拟了三种逻辑微操作,一是加载微操作,二是预期的虚拟操作语义,三是储存微操作;加载微操作模拟从储存器中读取虚拟寄存器操作数,储存微操作将计算结果写回虚拟寄存器。

每一个 Gadgets 的语义都和彼此不同,许多不同的 x86 指令序列足以模拟虚拟操作,由于 x86 指令集支持好几中寻址模式,只要微操作的顺序是正确的,不同的序列也可以正常工作,如指令add %eax, (%ecx) ,这一条指令就执行了加载、算术和存储三个微操作。

C srv->total += *size;
ASM 1 mov (%esi), %ebx //load
2 mov 0x4(%edi), eax //load
3 add %ebx, %eax //addition
4 mov %eax, 0x4(%edi) //store

数据导向 Gadgets 和代码导向中的 Gadgets 有两点不同,一是数据导向 Gadgets 需要使用内存传递操作结果,而代码导向 Gadgets 既可以使用内存,也可以使用寄存器;二是,数据导向 Gadgets 必须在一个合法的控制流中执行,且没有必要立即执行。

  • 模拟算术运算:

    如果语言支持条件跳转指令,那么可以更有效的模拟乘法运算 (?)。MinDOP 支持条件跳转,那么就可以做到检查一个值大于或小于一个常数。

  • 模拟赋值运算:

    在 MinDOP 中,赋值 Gadgets 从一个储存单元读取数据并直接存储到另一个储存单元,在这种情况下,我们可以直接跳过立即数的加载操作。

C srv->typ = *type;
ASM 1 mov (%esi), %ebx // load
2 mov %ebx, %eax // move
3 mov %eax, 0x8(%edi) // store
  • 模拟加载 / 存储操作:

    加载和存储在 C 语言中需要内存的反引用,将一个寄存器作为地址并访问内存位置进行读取或写入。由于在 DOP 中,寄存器是内存模拟的,因此反引用操作通过两个内存反引用来模拟:第一个内存反引用模拟寄存器的访问,第二个内存反引用第一个反引用的结果(寄存器值)作为地址。

C 1 LOAD1: *size = *(srv->cur_max);
2 LOAD2: memcpy(dst, *src_p, size);
3 STORE: memcpy(*dst_p, src, size);
ASM(LOAD1) 1 mov (%esi), %ebx // load
2 mov (%ebx), %eax // load
3 mov %eax, (%edi) //store
  • Gadgets 的调度程序

    Gadgets 的调度程序也是 x86 的指令序列,攻击者可以重复调用 Gadgets,可以模拟 Gadgets 调度程序的 x86 指令的一个常见序列是一个循环,它对模拟小工具的计算进行迭代,并且有一个选择器。每次迭代使用前一次迭代中 Gadgets 的输出执行 Gadgets 的子集,为了将迭代 i 中的 Gadgets 的输出引导至第 i+1 中的 Gadgets 的输入,选择器将第 i+1 的加载地址更改为第 i 次迭代的存储地址。

    选择器的行为由攻击者通过内存错误来控制 (?)

  • 另一类 DOP 攻击是非交互的。

    攻击者提供整个恶意输入,作为一个单个的数据传输。

  • 模拟跳转操作:

    1 void cmd_loop(server_rec *server, conn_t *c) {
    2     while (TRUE) {
    3         pr_netio_telnet_gets(buf, ..);
    4         cmd = make_ftp_cmd(buf, ...);
    5         pr_cmd_dispatch(cmd); // dispatcher
    6     }
    7 }
    8 char *pr_netio_telnet_gets(char * buf, ...) {
    9     while(*pbuf->current!=’\n’ && toread>0)
    10         *buf++ = *pbuf->current++;
    11     }
    

    这里的关键是找到一个合适的变量,可以在每次循环迭代中被破坏的虚拟 PC 指针,如上述代码,有一个内存指针pubf -> current,指向了恶意网络输入的缓冲区。在每一次循环迭代中,代码从该缓冲区读取一行,然后在循环体中处理它,因此这个指针可以用来模拟虚拟 PC 指针。对于模拟非条件跳转,攻击者只需要配置好内存,来触发另一个操作 Gadgets(如加法、赋值)来改变虚拟 PC 指针的值。

    有两种方式模拟条件跳转,一种情况是使用虚拟 PC 指针读取内存配置是有条件的,攻击者只需使用操作 k 将合适的变量设置为读取条件;另一种情况是操作 k 的执行条件依赖于数据变量。

    DOP 攻击

    与 ROP 不同,DOP 受限于应用的源控制流。

    数据导向 Gadgets 的定义

    Input: G:- the vulnerable program
    Output: S:- data-oriented gadget set
    1 S = ;;
    2 FuncSet = getFuncSet(G)
    3 foreach f 2 FuncSet do
    4     cfg = getCFG(f)
    5     for instr = getNextInstr(cfg) do
    6         if isMemStore(instr) then
    7             gadget = getBackwardSlice(instr, f)
    8             input = getInput(gadget)
    9             if isMemLoad(input) then
    10                S = S [ fgadgetg
    

    LLVM IR 提供了比二进制程序更多的语义,也避免了解析程序源代码,它还允许以任何具有 LLVM 前端的语言编写的源代码的语言不可知分析。

    相同语义的 Gadgets 功能上等同于同一个 MinDOP 操作,赋值 Gadgets 可以用来准备其他 Gadgets 的立即数,有条件的 Gadgets 有助于简单 Gadgets 实现高级计算。因为不改变控制流,所以 DOP 中没有函数调用 Gadgets。

    我们将 Gadgets 分为三类:一类是全局的,一类是函数参数,另外一类是局部 Gadgets。全局 Gadgets 操作全局变量,内��错误可以在任意地址改变这些变量;函数参数 Gadgets 操作被传递给函数的参数,内存错误可以控制函数的参数;局部 Gadgets 在局部变量中产生,在函数内部出现的内存错误可以激发他们。

    Gadgets 调度程序的定义

    Input: G:- the vulnerable program
    Output: D:- gadget dispatcher set
    1 D = ;;
    2 FuncSet = getFuncSet(G)
    3 foreach f 2 FuncSet do
    4     foreach loop = getLoop(f) do
    5         loop.gadgets = ;
    6         foreach instr = getNextInstr(loop) do
    7             if isMemStore(instr) then
    8                 loop.gadgets [= getGadget(instr)
    9             else if isCall(instr) then
    10                 target = getTarget(instr)
    11                 loop.gadgets [= getGadget(target)
    12         if loop.gadgets != ; then
    13             D = D [ floopg
    

    攻击的构造

    1) 准备 Gadgets(自动)

    发现一个内存错误,从程序代码中定位到该函数,然后,我们确定是否包含易受攻击代码,并收集数据导向Gadgets的Gadgets调度程序。
    

    2) 构造攻击链
    ​ 我们将预期的恶意 MinDOP 程序为输入,每一个 MinDOP 操作由相同功能的数据导向 Gadgets 实现,并根据优先级选择合适的 Gadgets。

    3) 可协作的验证

    一旦我们获得一系列数据导向Gadgets来完成我们想要的功能,我们将验证每一个围绕它们的调度程序完成拼接是否可能。向程序提供构造好的输入来触发内存错误,来连接相应的Gadgets,如果攻击不起作用,回滚步骤2来选择不同的Gadgets并再次尝试。
    

    DOP 的潜在防御

    内存安全

    内存安全首先通过检测恶意内存损坏来防止出现内存错误。DOP 利用大量的内存错误来粘合各种数据导向 Gadgets,因此,内存安全执行将防止所有可能的漏洞攻击,包括 DOP。但是,为了达到内存安全需要大量的开销。

    见参考文献:

    L. Szekeres, M. Payer, T. Wei, and D. Song, “SoK: Eternal War in Memory,” in Proceedings of the 34th IEEE Symposium on Security and Privacy, 2013.
    

    数据流完整性 (DFI)

    在程序执行之前,DFI 生成数据流图 (DFG),DFG 是关于定义 - 使用关系的数据库,DFI 在程序的检测之前检查每个存储单元是否有合法的指令定义。通过这种方式,DFI 可以防止破坏程序内存的恶意行为。然而完整的 DFI 保护依然需要很大的开销。

    参考文献使用 DFI 保护内核安全数据:

    C. Song, B. Lee, K. Lu, W. R. Harris, T. Kim, and W. Lee, “Enforcing Kernel Security Invariants with Data Flow Integrity,” in Proceedings of the 23th Annual Network and Distributed System Security Symposium, 2016.
    

    细粒度的数据面随机化

    细粒度的数据面随机化可以缓解 DOP 攻击,因为 DOP 仍然需要获取某些非控制数据指针的地址。然而,数据面上的细粒度随机化可能会导致高性能开销,因为所有数据(包括控制数据和非控制数据)应该常被随机化。
    高性能和强安全性保证的数据面随机化仍然是一个悬而未决的问题。

    硬件错误和软件错误隔离

    内存隔离被广泛用于防止未经授权访问高权限资源,只有合法的代码区域才能访问特定的资源,这样可以防止一些直接的数据破坏攻击,但是,DOP 不依赖于安全关键数据的可用性 - 它可能会损坏指针,只能针对数据导向 Gadgets。为了防止这种攻击,内存隔离必须保护所有指针不受纯数据影响。

    然而,精确识别二进制代码中的指针是一个挑战,此外,一个程序中有成千上万的指针,保护所有的指针将带来很大的开销,因此,当程序被指针隔离正确保护时,隔离只能防止部分 DOP 攻击。

留下你的脚步
推荐阅读