【实验报告NO.000002】MIT 6.858 Computer System Security - Lab 3

0x03.Lab 3: Symbolic execution

本 lab 将教大家使用 符号执行 （symbolic execution） 这一强大的技术来寻找软件中的漏洞，在 lab 的最后我们将建立一个可以在 zoobar web 应用中寻找触发多种漏洞的符号执行系统（准确的说是一个混合执行（concolic execution）系统）

关于什么是 concolic execution，可以看这张图

在 EXE paper 中描述了一个用于 C 程序的符号执行系统，为了简单化，该 lab 将通过修改 Python 对象与重载特定方法来为 Python 程序建立一个符号/混合执行系统，类似于 EXE，我们将使用一个 SMT （ Satisfiability Modulo Theories，可满足性模理论）求解器来检查可满足的约束，这意味着我们的求解器可以检查同时包含传统布尔可满足性表达式与涉及其他“理论”的约束如整型、位向量、字符串等

本 lab 初始我们首先要通过计算 32 位有/无符号数的平均值来熟悉 Z3——一个流行的 SMT 求解器，接下来我们将为 Python 整型操作创建 wrappers（类似 EXE 提供了符号变量上的操作置换），并应用调用 Z3 的核心逻辑来探索可能的不同执行路径；最终我们将探索如何将其应用在 web 应用程序上，以对字符串进行求解，我们将为 Python 的字符串操作套一层 wrapper，在 SQLalchemy 数据库接口上应用对符号化友好的（symbolic-friendly）wrapper，并使用这个系统寻找 Zoobar 中的漏洞

上面两段都是抄实验手册的

接下来首先还是惯例地切换到 lab 3 的分支：

$ git commit -am 'lab2 completed'
$ git pull
$ git checkout -b lab3 origin/lab3

这里注意不要将 lab 2 的代码合并到 lab 3 里边，因为我们的符号执行系统无法通过 RPC 追踪多进程间的符号约束，所以我们在一个没有进行权限分离的 Zoobar 上进行符号执行

接下来是检查代码可用性：

$ make check

结果如下就🆗，需要注意的是符号执行系统是 CPU 密集型的，因此对于不开启 KVM 支持的 QEMU 而言会非常慢：

、

Using an SMT solver

符号执行的核心是 可满足性模理论求解器（Satisfiability Modulo Theory solver， 即 SMT solver），在本 lab 中我们将使用微软开发的 Z3 solver 的 Python-based API（参见 z3py tutorial & documentation for Z3’s Python API），并使用 Z3’s support for strings；本 Lab 带有一个构建自 Z3 github repo 的 Z3

实验提供了 int-avg.py 作为使用 Z3 的例子： 计算两个 32 位整型的平均值 ，一个最简单的算法是 (x + y) / 2 ，但这可能会发生整型上溢，从而得到 模 2³² 上的值（想了解更多，参见 KINT paper ）——Z3 可以帮我们检查这个错误：予其一个布尔表达式，Z3 可以告诉我们其是否为真（即可以被满足）；若表达式可以为真且包含一些变量，Z3 可以给我们一些使表达式为真的🌰变量

现在我们来看这份代码（这里不会仔细讲 Z3 的用法，不懂的 自行查文档），其首先会使用 Z3 创建两个 32 位的位向量 a 与 b：

#!/usr/bin/env python3

import z3

## Construct two 32-bit integer values.  Do not change this code.
a = z3.BitVec('a', 32)
b = z3.BitVec('b', 32)

接下来分别计算有/无符号除法下两数的平均值，注意这里并没有实际进行计算，而仅是保存了符号变量表达式：

## Compute the average of a and b.  The initial computation we provided
## naively adds them and divides by two, but that is not correct.  Modify
## these lines to implement your solution for both unsigned (u_avg) and
## signed (s_avg) division.
##
## Watch out for the difference between signed and unsigned integer
## operations.  For example, the Z3 expression (x/2) performs signed
## division, meaning it treats the 32-bit value as a signed integer.
## Similarly, (x>>16) shifts x by 16 bits to the right, treating it
## as a signed integer.
##
## Use z3.UDiv(x, y) for unsigned division of x by y.
## Use z3.LShR(x, y) for unsigned (logical) right shift of x by y bits.
u_avg = z3.UDiv(a + b, 2)
s_avg = (a + b) / 2

由于 32 位整数加法可能存在溢出，故这里为了求得其正确的平均值，我们将其扩展为两个 33 位的位向量，完成计算后再截断回 32 位（不会导致结果错误，因为 32 位的平均值总会在 32 位内）：

## Do not change the code below.

## To compute the reference answers, we extend both a and b by one
## more bit (to 33 bits), add them, divide by two, and shrink back
## down to 32 bits.  You are not allowed to "cheat" in this way in
## your answer.
az33 = z3.ZeroExt(1, a)
bz33 = z3.ZeroExt(1, b)
real_u_avg = z3.Extract(31, 0, z3.UDiv(az33 + bz33, 2))

as33 = z3.SignExt(1, a)
bs33 = z3.SignExt(1, b)
real_s_avg = z3.Extract(31, 0, (as33 + bs33) / 2)

最后就是求解是否存在能够发生整型溢出的约束，即：是否存在这样的两个 32 位整型变量值使得其 32 位下运算结果不与真实计算结果相等：

def printable_val(v, signed):
    if type(v) == z3.BitVecNumRef:
        if signed:
            v = v.as_signed_long()
        else:
            v = v.as_long()
    return v

def printable_model(m, signed):
    vals = {
   }
    for k in m:
        vals[k] = printable_val(m[k], signed)
    return vals

def do_check(msg, signed, avg, real_avg):
    e = (avg != real_avg)
    print("Checking", msg, "using Z3 expression:")
    print("    " + str(e).replace("\n", "\n    "))
    solver = z3.Solver()
    solver.add(e)
    ok = solver.check()
    print("  Answer for %s: %s" % (msg, ok))

    if ok == z3.sat:
        m = solver.model()
        print("  Example:", printable_model(m, signed))
        print("  Your average:", printable_val(m.eval(avg), signed))
        print("  Real average:", printable_val(m.eval(real_avg), signed))

结果如下，Z3 求解器帮助我们找到了这样的值：

接下来是 Exercise 1：通过修改 int-avg.py 中的 u_avg = ... 一行，实现一个正确的函数，以在 32 位运算下正确计算出 a 与 b 的无符号平均值，不能改变操作数的位宽

Exercise 1. Implement a correct function to compute the unsigned average of a and b using only 32-bit arithmetic, by modifying the u_avg = ... line in int-avg.py.

For the purposes of this exercise, you are not allowed to change the bit-widths of your operands. This is meant to represent the real world, where you cannot just add one more bit to your CPU’s register width.

You may find it helpful to search online for correct ways to perform fixed-width integer arithmetic. The book Hacker’s Delight by Henry S. Warren is a particularly good source of such tricks.

Check your averaging function by re-running ./int-avg.py or make check. If your implementation is correct, int-avg.py should produce the message Answer for unsigned avg: unsat.

这里笔者给出一个比较笨的解法（毕竟笔者的脑子: (也想不出啥聪明解法 ）：

• (a / 2) + (b / 2) + ((a % 2) + (b % 2)) / 2

这个算法的思路比较简单，最初的出发点就是两数之和的平均值不会超出 2³²，那么我们只要先将两数分别除以2再相加就不会发生溢出了，但是奇数除以2会丢失 0.5，所以如果两个数都是奇数的话最后的结果会丢掉1，那么这里我们再将其加上即可

这里需要注意的是 Z3 默认为带符号运算，故这里我们应当使用 z3.UDiv() 来进行无符号除法运算：

u_avg = z3.UDiv(a, 2) + z3.UDiv(b, 2) + ((a % 2) + (b % 2)) / 2

运行 make check，成功通过 Exercise 1：

除了这个算法之外，笔者还了解到有一种算法是利用位运算来进行计算：

• (a & b) + ((a ^ b) >> 1)

这个算法的基本原理是先提取出公有部分，再计算私有部分的平均值，最后相加即可得到结果；这个算法也能通过 Exercise 1 ，这里就不重复贴图了

接下来是 Challenge 1：通过修改 int-avg.py 中的 s_avg = ... 一行，实现一个正确的函数，以在 32 位运算下正确计算出 a 与 b 的有符号平均值

Challenge! (optional) For extra credit, figure out how to compute the average of two 32-bit signed values. Modify the s_avg = ... line in int-avg.py, and run ./int-avg.py or make check to check your answer. Keep in mind the direction of rounding: 3/2=1 and -3/2=-1, so so the average of 1 and 2 should be 1, and the average of -2 and -1 should be -1.

As you explore signed arithmetic, you may find it useful to know that Z3 has two different modulo-like operators. The first is signed modulo, which you get by using a % b in the Python Z3 API. Here, the sign of the result follows the sign of the divisor (i.e., b). For example, -5 % 2 = 1. The second is signed remainder, which you get by using z3.SRem(a, b). Here, the sign of the result follows the sign of the dividend (i.e., a). With the same example inputs, z3.SRem(-5, 2) = -1.

对于带符号值的运算而言，限制在 32 位内的正确计算便没有那么简单了，若我们直接用上面的式子进行计算则很容易被 Z3 找到能导致运算结果错误的例子：

为什么在有符号除法下计算出来的结果不一致呢？这是因为在题目中MIT 非常SB地对于正数除法其选择向下取整，对于负数除法的截断，其选择的是向上取整，但我们的算法是正数与负数皆向下取整，因此计算结果就出现了偏差

由于正数部分没有问题，因此这里我们需要对计算结果为负数的情况进行特殊化处理，在结果为负数时将向下取整变为向上取整，因此最后的计算公式如下：

• tmp = (a & b) + ((a ^ b) >> 1)
• res = tmp + ((tmp >> 31) & (a ^ b))

首先按照我们原来的公式计算出向下取整的结果，接下来对其符号位进行判断，若为 1 则再判断其私有部分平均值的计算是否发生截断（即私有部分和是否为奇数），若是则说明结果发生了向下取整，此时变为向上取整即可

由于要对符号位进行判断，所以这里我们使用 z3.LShR() 将初始运算结果作为无符号整型进行右移操作：

tmp = (a & b) + ((a ^ b) >> 1)
s_avg = tmp + (z3.LShR(tmp, 31) & (a ^ b))

运行结果如下，成功通过 Challenge 1：

Interlude: what are symbolic and concolic execution?

正如我们前面在 EXE 的论文中所见，符号执行是一种通过观测程序在不同输入下如何表现来进行程序测试的方法，通常而言其目的是为了获得更高的 代码覆盖率 （code coverage）或是 路径覆盖率 （path coverage），在安全中其比传统代码执行更能触发罕见的可能包含漏洞的代码路径

从更高层次而言，若我们要构建一个符号执行系统，我们需要解决以下几点：

• 由于程序包含基于输入的中间值（例如输入两个整型并计算平均值，并存放在一些变量中），我们需要记住输入与这些中间值间的关系，通常这通过允许变量或内存位置有 具体的 （concrete，例如 114514 这样的实际值） 或 符号的 （symbolic，例如我们在上一小节构建的符号变量） 值
• 我们需要根据输入来确定要执行的控制流分支，这归结于在程序每次发生分支时构建符号约束，在程序选择一些特定分支时描述布尔条件（以程序原有输入的形式）；由于我们持续保存中间值与程序原有输入的间隙，我们并不需要通过原有输入来计算约束，这些约束就像我们在前文中用来寻找整型中漏洞的约束；确定控制流约束非常重要，因为若程序初始时进入了特定分支路径，我们想要知道如何让他走到另一条路径来寻找是否存在漏洞，在 EXE 的论文中使用了一个 C-to-C 的翻译器来在所有的分支上插入他们的代码
• 对于每一条上述分支，我们需要决定是否有一个输入能够让程序在一条分支上执行另一条路径（更准确地说，我们考虑整个控制流路径而非单个路径），这帮助我们在程序中寻找可以让我们通过调整输入来影响的控制流条件，所有的符号执行系统都基于 SMT 求解器来完成这些工作
• 我们需要确定我们在测试中寻找的是什么，这是我们从程序中确保 不变量 （invariant）来考虑的最佳方法，而符号执行寻找改变这些常量的输入（👴也没咋读明白，可以看实验手册原句）；我们可以寻找的事物之一是程序崩溃（crashes，即不变量是 我们的程序不应当崩溃 ），在 C 程序中这非常有意义，因为 crashes 通常指示了代表漏洞的内存损坏，在 Python 这样更高级的语言中在设计上并不存在内存损坏，但我们仍然可以寻找如 Python 代码级的代码注入攻击（例如 eval() ）或是特定于某种应用的影响安全的不变量
• 最终，对于给出程序中所有可能执行的控制流路径，我们需要决定该尝试哪条路径，因为路径数量会随着程序规模的增大而快速增长，我们不可能尝试所有的路径，因此符号执行系统通常包含确定哪一条路径更有希望发现破坏不变量的某种 调度器 （scheduler）或 搜索策略 （search strategy），一个简单的搜索策略例子便是尝试未执行过的路径，这代表着更高的代码覆盖率与未被发现的漏洞的存在的可能性

与符号执行相对的一个选择是 fuzzing （又称 fuzz-testing，模糊测试），其选择了一个随机化方案：不同于关注触发应用中不同代码路径的原因，fuzzing 会创建随机的具体值交给程序执行并检查其行为；虽然这比符号执行更简单，但通常很难构造能满足程序代码中一些特定情况的输入

构建符号执行系统的一个挑战是我们的系统需要知道如何在符号值上执行所有可能的操作（上面的 Step 1 & 2），在本 Lab 中我们将在 Python 对象（更准确地说，整型与字符串）上实践，对于符号执行而言这很有挑战性，因为 Python 对象可以实现的操作有很多

幸运的是我们还有一个更简单的选择—— 混合执行 （concolic execution），介于完全随机的模糊测试与完全的符号执行之间，相较于跟踪纯净的符号值（如 EXE 中所做），其思想是：对于从输入中得到的变量，我们可以同时保存一个具体值与一个符号值，由此：

• 若我们的 concolic system 知道应用的行为，我们可以像符号执行那样运行（除了我们还会同时传播每个值的 concrete 部分）；例如，假设我们有两个 concolic 整型变量 aa 与 bb，其有着具体值 5 与 6 ，并对应符号表达式 a 与 b，此时若应用创建了一个变量 cc = aa + bb，其会同时有着具体值 11 及符号表达式 a + b；类似地，若应用在 cc == 12 的分支上执行，程序可以像分支为假一样执行，并记录对应的符号分支条件 a + b != 12
• 若我们的 concolic system 不知道应用的当前行为，应用将只会得到具体的值；例如若应用将 cc 写入文件中，或者是传递到外部库中，代码仍可以使用具体值 11 如同应用正常运行那样继续执行

对于本 lab 而言，混合执行的好处是我们并不需要完全完成对符号值的操作支持，我们只需要支持足够发现漏洞的操作即可（实际上大部分挖洞系统也是如此），不过若应用执行了我们所不支持的操作，我们将失去对符号部分的跟踪，并无法对这些路径进行符号执行式的（symbolic-execution-style）探索，若想了解更多可以参见 DART paper

Concolic execution for integers

首先我们将为整型值构建一个混合执行系统，本 Lab 为我们的混合执行提供的框架代码位于 symex/fuzzy.py 中，其实现了几个重要的抽象层：

• 抽象语法树（The AST）：与此前我们在 int-avg.py 中使用 Z3 表达式来表示符号值所不同的是，本 Lab 构建了其自己的抽象语法树（abstract syntax tree）来表达符号表达式，一个 AST 节点可以是一个简单的变量（ sym_str 或 sym_int 对象）、一个常量（const_int、const_str 或 const_bool 对象）、或是一些将其他 AST 节点作为参数的函数或操作符（例如 sym_eq(a, b) 表示布尔表达式 a==b，其中 a 与 b 都是 AST 节点，或是 sym_plus(a, b) 表示整型表达式 a + b）

  每个 AST 节点 n 都可以使用 z3expr(n) 转化为 Z3 表达式，这由调用 n._z3expr 完成，即每个 AST 节点都实现了返回对应 Z3 表达式的 _z3expr 方法

  我们使用自己的 AST 层而非使用 Z3 的符号表示的原因是因为我们需要实现一些 Z3 表示难以完成的操作，此外我们需要分出一个独立的进程来调用 Z3 的求解器，以在 Z3 求解器耗时过长时杀死进程——将约束归为不可解（这种情况下我们可能失去这些路径，但至少我们会让程序探索其他路径）；使用我们自己的 AST 能让我们将 Z3 状态完全独立在 fork 出的进程里

• 混合封装（The concolic wrappers）：为了拦截 python-level 的操作并进行混合执行，我们将常规的 int 与 str 对象替换成了混合的子类：concolic_int 继承自 int 而 concolic_str 继承自 str，每一个混合封装都同时存储一个具体值（self.__v ）与一个符号表达式（与 AST 节点，在 self.__sym），当应用在计算混合值表达式（例如 a+1 中的 a 为 concolic_int），我们需要拦截该操作并返回一个同时包含具体值与符号表达式的的混合值

  为了实现这样的拦截操作，我们重载了 concolic_int 与 concolic_str 类中的一些方法，例如 concolic_int.__add__ 在上面的例子 a + 1 中会被调用并返回一个新的混合值表示结果

  原则上我们应该也要有一个 concolic_bool 作为 bool 的子类，不幸的是在 Python 中 bool 不能被继承（参见这里 与 这里），于是我们创建了函数 concolic_bool 作为代替，当我们创建一个混合布尔值时，程序会按其值进行分支，故 concolic_bool 也会为当前路径条件添加一个约束（布尔值的符号表达式与具体值相等的约束），并返回一个具体的布尔值

• 具体输入（The concrete inputs）：在混合执行下被测试的程序输入都存储在 concrete_values 字典中，在该字典中存储了程序输入的字符串名字，并将每个名字映射到对应的输入值（整型变量的值为python整型，字符串变量为python字符串）

  concrete_value 被设为全局变量的原因是应用通过调用 fuzzy.mk_str(name) 或 fuzzy.mk_int(name) 来创建一个混合字符串或混合整型，其返回一个混合值，其中的符号部分为一个新的 AST 节点对应到一个名为 name 的变量，但具体值被在 concrete_values 中查找，若字典中没有与之关联的变量，系统将其设为默认的初始值（整型为0，字符串为空串）

  混合执行框架在一个 InputQueue 对象中维持一个待尝试的不同输入的队列，框架首先会添加一个初始输入（空字典 {}），之后执行代码，若应用进入了分支，混合执行系统将唤醒 Z3 来带来 新的输入以测试代码中的其他分支，将这些输入放到输入队列中，并保持迭代直到没有输入可以尝试

• 可满足性模理论求解器（The SMT solver）： fork_and_check(c) 函数会检查约束 c （一个 AST 节点）是否为可满足的表达式，并返回一对值：可满足性状态 ok 及示例模型（分配给变量的值），若约束可以被满足则 ok 为 z3.sat ，若约束不可被满足则 ok 为 z3.unsat 或 z3.unknown；该函数内部会 fork 一个独立的进程来运行 Z3 求解器，若耗时超过 z3_timeout 则杀死进程并返回 z3.unknown

• 当前路径条件（The current path condition）：当应用执行并基于混合值决定控制流时（参见上面关于 concolic_bool 的讨论），表示该分支的约束会被添加到 cur_path_constr 列表中，为了生成能够沿着一条分支从一个点进行不同选择的输入，所需的约束为路径上该点之前的约束集合，加上该点的反向约束；为了帮助调试与启发式搜索，触发了分支的代码行的信息会被存放在 cur_path_constr_callers 列表中

接下来我们的工作是完成对 concolic_int 的实现，并将代码应用于混合执行循环的核心，本 Lab 提供了两个测试程序： check-concolic-int.py 与 check-symex-int.py

混合执行框架代码浅析 - Part 1

在做 Exercise 之前，我们先看一下这个混合执行框架的代码结构，其核心代码主要位于 symex/fuzzy.py 中

I. AST 节点

首先是 AST 节点，作为所有符号类的父类而存在，定义比较简单：

class sym_ast(object):
  def __str__(self):
    return str(self._z3expr())

II. 符号运算

然后是 sym_func_apply 类，作为所有符号操作的父节点，这里主要重载了 __eq__() 和 __hash__() 方法，用于比较与计算哈希值，比较的方法就是判断是否所有参数相等，哈希值的计算则是所有参数的哈希值进行异或：

class sym_func_apply(sym_ast):
  def __init__(self, *args):
    for a in args:
      if not isinstance(a, sym_ast):
        raise Exception("Passing a non-AST node %s %s as argument to %s" % \
                        (a, type(a), type(self)))
    self.args = args

  def __eq__(self, o):
    if type(self) != type(o):
      return False
    if len(self.args) != len(o.args):
      return False
    return all(sa == oa for (sa, oa) in zip(self.args, o.args))

  def __hash__(self):
    return functools.reduce(operator.xor, [hash(a) for a in self.args])

然后是三个类 sym_unop 、sym_binop 、sym_triop，表示带有1、2、3个操作数的封装，可以使用 a 、b 、c 获得第 1、2、3个操作数：

class sym_unop(sym_func_apply):
  def __init__(self, a):
    super(sym_unop, self).__init__(a)

  @property
  def a(self):
    return self.args[0]

class sym_binop(sym_func_apply):
  def __init__(self, a, b):
    super(sym_binop, self).__init__(a, b)

  @property
  def a(self):
    return self.args[0]

  @property
  def b(self):
    return self.args[1]

class sym_triop(sym_func_apply):
  def __init__(self, a, b, c):
    super(sym_triop, self).__init__(a, b, c)

  @property
  def a(self):
    return self.args[0]

  @property
  def b(self):
    return self.args[