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 语言：

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

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

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

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

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

• 模拟算术运算：

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

• 模拟赋值运算：

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

• 模拟加载/存储操作：

  加载和存储在 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 攻击。