5.3.1 angr

简介

angr 是一个多架构的二进制分析平台,具备对二进制文件的动态符号执行能力和多种静态分析能力。在近几年的 CTF 中也大有用途。

安装

在 Ubuntu 上,首先我们应该安装所有的编译所需要的依赖环境:

  1. $ sudo apt install python-dev libffi-dev build-essential virtualenvwrapper

强烈建议在虚拟环境中安装 angr,因为有几个 angr 的依赖(比如z3)是从他们的原始库中 fork 而来,如果你已经安装了 z3,那么肯定不希望 angr 的依赖覆盖掉官方的共享库,开一个隔离的环境就好了:

  1. $ mkvirtualenv angr
  2. $ sudo pip install angr

如果这样安装失败的话,那么你可以按照下面的顺序从 angr 的官方仓库安装:

  1. 1. claripy
  2. 2. archinfo
  3. 3. pyvex
  4. 4. cle
  5. 5. angr

例如下面这样:

  1. $ git clone https://github.com/angr/claripy
  2. $ cd claripy
  3. $ sudo pip install -r requirements.txt
  4. $ sudo python setup.py build
  5. $ sudo python setup.py install

安装过程中可能会有一些奇怪的错误,可以到官方文档中查看。

另外 angr 还有一个 GUI 可以用,查看 angr Management

使用方法

快速入门

使用 angr 的第一步是新建一个工程,几乎所有的操作都是围绕这个工程展开的:

  1. >>> import angr
  2. >>> proj = angr.Project('/bin/true')
  3. WARNING | 2017-12-08 10:46:58,836 | cle.loader | The main binary is a position-independent executable. It is being loaded with a base address of 0x400000.

这样就得到了二进制文件的各种信息,如:

  1. >>> proj.filename # 文件名
  2. '/bin/true'
  3. >>> proj.arch # 一个 archinfo.Arch 对象
  4. <Arch AMD64 (LE)>
  5. >>> hex(proj.entry) # 入口点
  6. '0x401370'

程序加载时会将二进制文件和共享库映射到虚拟地址中,CLE 模块就是用来处理这些东西的。

  1. >>> proj.loader
  2. <Loaded true, maps [0x400000:0x5008000]>

所有对象文件如下,其中二进制文件本身是 main_object,然后还可以查看对象文件的相关信息:

  1. >>> for obj in proj.loader.all_objects:
  2. ... print obj
  3. ...
  4. <ELF Object true, maps [0x400000:0x60721f]>
  5. <ELF Object libc-2.27.so, maps [0x1000000:0x13bb98f]>
  6. <ELF Object ld-2.27.so, maps [0x2000000:0x22260f7]>
  7. <ELFTLSObject Object cle##tls, maps [0x3000000:0x300d010]>
  8. <ExternObject Object cle##externs, maps [0x4000000:0x4008000]>
  9. <KernelObject Object cle##kernel, maps [0x5000000:0x5008000]>
  10. >>> proj.loader.main_object
  11. <ELF Object true, maps [0x400000:0x60721f]>
  12. >>> hex(proj.loader.main_object.min_addr)
  13. '0x400000'
  14. >>> hex(proj.loader.main_object.max_addr)
  15. '0x60721f'
  16. >>> proj.loader.main_object.execstack
  17. False

通常我们在创建工程时选择关闭 auto_load_libs 以避免 angr 加载共享库:

  1. >>> p = angr.Project('/bin/true', auto_load_libs=False)
  2. WARNING | 2017-12-08 11:09:28,629 | cle.loader | The main binary is a position-independent executable. It is being loaded with a base address of 0x400000.
  3. >>> p.loader.all_objects
  4. [<ELF Object true, maps [0x400000:0x60721f]>, <ExternObject Object cle##externs, maps [0x1000000:0x1008000]>, <KernelObject Object cle##kernel, maps [0x2000000:0x2008000]>, <ELFTLSObject Object cle##tls, maps [0x3000000:0x300d010]>]

project.factory 提供了很多类对二进制文件进行分析,它提供了几个方便的构造函数。

project.factory.block() 用于从给定地址解析一个 basic block,对象类型为 Block:

  1. >>> block = proj.factory.block(proj.entry) # 从程序头开始解析一个 basic block
  2. >>> block
  3. <Block for 0x401370, 42 bytes>
  4. >>> block.pp() # 打印
  5. 0x401370: xor ebp, ebp
  6. 0x401372: mov r9, rdx
  7. 0x401375: pop rsi
  8. 0x401376: mov rdx, rsp
  9. 0x401379: and rsp, 0xfffffffffffffff0
  10. 0x40137d: push rax
  11. 0x40137e: push rsp
  12. 0x40137f: lea r8, qword ptr [rip + 0x32da]
  13. 0x401386: lea rcx, qword ptr [rip + 0x3263]
  14. 0x40138d: lea rdi, qword ptr [rip - 0xe4]
  15. 0x401394: call qword ptr [rip + 0x205b76]
  16. >>> block.instructions # 指令数量
  17. 11
  18. >>> block.instruction_addrs # 指令地址
  19. [4199280L, 4199282L, 4199285L, 4199286L, 4199289L, 4199293L, 4199294L, 4199295L, 4199302L, 4199309L, 4199316L]

另外,还可以将 Block 对象转换成其他形式:

  1. >>> block.capstone
  2. <CapstoneBlock for 0x401370>
  3. >>> block.capstone.pp()
  4. >>> block.vex
  5. IRSB <0x2a bytes, 11 ins., <Arch AMD64 (LE)>> at 0x401370
  6. >>> block.vex.pp()

程序的执行需要初始化一个模拟程序状态的 SimState 对象:

  1. >>> state = proj.factory.entry_state()
  2. >>> state
  3. <SimState @ 0x401370>

该对象包含了程序的内存、寄存器、文件系统数据等等模拟运行时动态变化的数据,例如:

  1. >>> state.regs # 寄存器名对象
  2. <angr.state_plugins.view.SimRegNameView object at 0x7f126fdfe810>
  3. >>> state.regs.rip # BV64 对象
  4. <BV64 0x401370>
  5. >>> state.regs.rsp
  6. <BV64 0x7fffffffffeff98>
  7. >>> state.regs.rsp.length # BV 对象都有 .length 属性
  8. 64
  9. >>> state.regs.rdi
  10. <BV64 reg_48_0_64{UNINITIALIZED}> # BV64 对象,符号变量
  11. >>> state.mem[proj.entry].int.resolved # 将入口点的内存解释为 C 语言的 int 类型
  12. <BV32 0x8949ed31>

这里的 BV,即 bitvectors,可以理解为一个比特串,用于在 angr 里表示 CPU 数据。看到在这里 rdi 有点特殊,它没有具体的数值,而是在符号执行中所使用的符号变量,我们会在稍后再做讲解。

下面是 Python int 和 bitvectors 之间的转换:

  1. >>> bv = state.solver.BVV(0x1234, 32) # 创建值 0x1234 的 BV32 对象
  2. >>> bv
  3. <BV32 0x1234>
  4. >>> hex(state.solver.eval(bv)) # 将 BV32 对象转换为 Python int
  5. '0x1234'
  6. >>> bv = state.solver.BVV(0x1234, 64)
  7. >>> bv
  8. <BV64 0x1234>
  9. >>> hex(state.solver.eval(bv))
  10. '0x1234L'

于是 bitvectors 可以进行数学运算:

  1. >>> one = state.solver.BVV(1, 64)
  2. >>> one_hundred = state.solver.BVV(100, 64)
  3. >>> one_hundred + one # 位数相同时可以直接运算
  4. <BV64 0x65>
  5. >>> one_hundred + one + 0x100
  6. <BV64 0x165>
  7. >>> state.solver.BVV(-1, 64) # 默认为无符号数
  8. <BV64 0xffffffffffffffff>
  9. >>> five = state.solver.BVV(5, 27)
  10. >>> five
  11. <BV27 0x5>
  12. >>> one + five.zero_extend(64 - 27) # 位数不同时需要进行扩展
  13. <BV64 0x6>
  14. >>> one + five.sign_extend(64 - 27) # 或者有符号扩展
  15. <BV64 0x6>

使用 bitvectors 可以直接来设置寄存器和内存的值,当传入的是 Python int 时,angr 会自动将其转换成 bitvectors:

  1. >>> state.regs.rsi = state.solver.BVV(3, 64)
  2. >>> state.regs.rsi
  3. <BV64 0x3>
  4. >>> state.mem[0x1000].long = 4 # 在地址 0x1000 存放一个 long 类型的值 4
  5. >>> state.mem[0x1000].long.resolved # .resolved 获取 bitvectors
  6. <BV64 0x4>
  7. >>> state.mem[0x1000].long.concrete # .concrete 获得 Python int
  8. 4L

初始化的 state 可以经过模拟执行得到一系列的 states,模拟管理器(Simulation Managers)的作用就是对这些 states 进行管理:

  1. >>> simgr = proj.factory.simulation_manager(state)
  2. >>> simgr
  3. <SimulationManager with 1 active>
  4. >>> simgr.active # 当前 state
  5. [<SimState @ 0x401370>]
  6. >>> simgr.step() # 模拟执行一个 basic block
  7. <SimulationManager with 1 active>
  8. >>> simgr.active # 当前 state 被更新
  9. [<SimState @ 0x1022f80>]
  10. >>> simgr.active[0].regs.rip # active[0] 是当前 state
  11. <BV64 0x1022f80>
  12. >>> state.regs.rip # 但原始的 state 并没有改变
  13. <BV64 0x401370>

angr 提供了大量函数用于程序分析,在这些函数在 Project.analyses.,例如:

  1. >>> cfg = p.analyses.CFGFast() # 得到 control-flow graph
  2. >>> cfg
  3. <CFGFast Analysis Result at 0x7f1265b62650>
  4. >>> cfg.graph
  5. <networkx.classes.digraph.DiGraph object at 0x7f1265e77310> # 详情请查看 networkx
  6. >>> len(cfg.graph.nodes())
  7. 934
  8. >>> entry_node = cfg.get_any_node(proj.entry) # 得到给定地址的 CFGNode
  9. >>> entry_node
  10. <CFGNode 0x401370[42]>
  11. >>> len(list(cfg.graph.successors(entry_node)))
  12. 2

如果要想画出图来,还需要安装 matplotlib。

  1. >>> import networkx as nx
  2. >>> import matplotlib
  3. >>> matplotlib.use('Agg')
  4. >>> import matplotlib.pyplot as plt
  5. >>> nx.draw(cfg.graph) # 画图
  6. >>> plt.savefig('temp.png') # 保存

二进制文件加载器

我们知道 angr 是高度模块化的,接下来我们就分别来看看这些组成模块,其中用于二进制加载模块称为 CLE。主类为 cle.loader.Loader,它导入所有的对象文件并导出一个进程内存的抽象。类 cle.backends 是加载器的后端,根据二进制文件类型区分为 cle.backends.elfcle.backends.pecle.backends.macho 等。

首先我们来看加载器的一些常用参数:

  • auto_load_libs:是否自动加载主对象文件所依赖的共享库
  • except_missing_libs:当有共享库没有找到时抛出异常
  • force_load_libs:强制加载列表指定的共享库,不论其是否被依赖
  • skip_libs:不加载列表指定的共享库,即使其被依赖
  • custom_ld_path:可以到列表指定的路径查找共享库

如果希望对某个对象文件单独指定加载参数,可以使用 main_opslib_opts 以字典的形式指定参数。一些通用的参数如下:

  • backend:使用的加载器后端,如:”elf”, “pe”, “mach-o”, “ida”, “blob” 等
  • custom_arch:使用的 archinfo.Arch 对象
  • custom_base_addr:指定对象文件的基址
  • custom_entry_point:指定对象文件的入口点

举个例子:

  1. angr.Project(main_opts={'backend': 'ida', 'custom_arch': 'i386'}, lib_opts={'libc.so.6': {'backend': 'elf'}})

加载对象文件和细分类型如下:

  1. >>> for obj in proj.loader.all_objects:
  2. ... print obj
  3. ...
  4. <ELF Object true, maps [0x400000:0x60721f]>
  5. <ELF Object libc-2.27.so, maps [0x1000000:0x13bb98f]>
  6. <ELF Object ld-2.27.so, maps [0x2000000:0x22260f7]>
  7. <ELFTLSObject Object cle##tls, maps [0x3000000:0x300d010]>
  8. <ExternObject Object cle##externs, maps [0x4000000:0x4008000]>
  9. <KernelObject Object cle##kernel, maps [0x5000000:0x5008000]>
  • proj.loader.main_object:主对象文件
  • proj.loader.shared_objects:共享对象文件
  • proj.loader.extern_object:外部对象文件
  • proj.loader.all_elf_object:所有 elf 对象文件
  • proj.loader.kernel_object:内核对象文件

通过对这些对象文件进行操作,可以解析出相关信息:

  1. >>> obj = proj.loader.main_object
  2. >>> obj
  3. <ELF Object true, maps [0x400000:0x60721f]>
  4. >>> hex(obj.entry) # 入口地址
  5. '0x401370'
  6. >>> hex(obj.min_addr), hex(obj.max_addr) # 起始地址和结束地址
  7. ('0x400000', '0x60721f')
  8. >>> for seg in obj.segments: # segments
  9. ... print seg
  10. ...
  11. <ELFSegment offset=0x0, flags=0x5, filesize=0x5f48, vaddr=0x400000, memsize=0x5f48>
  12. <ELFSegment offset=0x6c30, flags=0x6, filesize=0x450, vaddr=0x606c30, memsize=0x5f0>
  13. >>> for sec in obj.sections: # sections
  14. ... print sec
  15. ...
  16. <Unnamed | offset 0x0, vaddr 0x400000, size 0x0>
  17. <.interp | offset 0x238, vaddr 0x400238, size 0x1c>
  18. <.note.ABI-tag | offset 0x254, vaddr 0x400254, size 0x20>
  19. <.note.gnu.build-id | offset 0x274, vaddr 0x400274, size 0x24>
  20. ...etc

根据地址查找我们需要的东西:

  1. >>> proj.loader.find_object_containing(0x400000) # 包含指定地址的 object
  2. <ELF Object true, maps [0x400000:0x60721f]>
  3. >>> free = proj.loader.find_symbol('free') # 根据名字或地址在 project 中查找 symbol
  4. >>> free
  5. <Symbol "free" in libc.so.6 at 0x1083ab0>
  6. >>> free.name # 符号名
  7. u'free'
  8. >>> free.owner_obj # 所属 object
  9. <ELF Object libc-2.27.so, maps [0x1000000:0x13bb98f]>
  10. >>> hex(free.rebased_addr) # 全局地址空间中的地址
  11. '0x1083ab0'
  12. >>> hex(free.linked_addr) # 相对于预链接基址的地址
  13. '0x83ab0'
  14. >>> hex(free.relative_addr) # 相对于对象基址的地址
  15. '0x83ab0'
  16. >>> free.is_export # 是否为导出符号
  17. True
  18. >>> free.is_import # 是否为导入符号
  19. False
  20. >>> obj.find_segment_containing(obj.entry) # 包含指定地址的 segment
  21. <ELFSegment offset=0x0, flags=0x5, filesize=0x5f48, vaddr=0x400000, memsize=0x5f48>
  22. >>> obj.find_section_containing(obj.entry) # 包含指定地址的 section
  23. <.text | offset 0x12b0, vaddr 0x4012b0, size 0x33d9>
  24. >>> main_free = obj.get_symbol('free') # 根据名字在当前 object 中查找 symbol
  25. >>> main_free
  26. <Symbol "free" in true (import)>
  27. >>> main_free.is_export
  28. False
  29. >>> main_free.is_import
  30. True
  31. >>> main_free.resolvedby # 从哪个 object 获得解析
  32. <Symbol "free" in libc.so.6 at 0x1083ab0>
  33. >>> hex(obj.linked_base) # 预链接的基址
  34. '0x0'
  35. >>> hex(obj.mapped_base) # 实际映射的基址
  36. '0x400000'

通过 obj.relocs 可以查看所有的重定位符号信息,或者通过 obj.imports 可以得到一个符号信息的字典:

  1. >>> for imp in obj.imports:
  2. ... print imp, obj.imports[imp]
  3. ...
  4. strncmp <cle.backends.elf.relocation.amd64.R_X86_64_GLOB_DAT object at 0x7faf8301b110>
  5. lseek <cle.backends.elf.relocation.amd64.R_X86_64_GLOB_DAT object at 0x7faf8301b7d0>
  6. malloc <cle.backends.elf.relocation.amd64.R_X86_64_GLOB_DAT object at 0x7faf8301be10>
  7. >>> obj.imports['free'].symbol # 从重定向信息得到导入符号
  8. <Symbol "free" in true (import)>
  9. >>> obj.imports['free'].owner_obj # 从重定向信息得到所属的 object
  10. <ELF Object true, maps [0x400000:0x60721f]>

这一部分还有个 hooking 机制,用于将共享库中的代码替换为其他的操作。使用函数 proj.hook(addr, hook)proj.hook_symbol(name, hook) 来做到这一点,其中 hook 是一个 SimProcedure 的实例。通过 .is_hooked.unhook.hooked_by 来进行管理:

  1. >>> stub_func = angr.SIM_PROCEDURES['stubs']['ReturnUnconstrained'] # 获得一个类
  2. >>> stub_func
  3. <class 'angr.procedures.stubs.ReturnUnconstrained.ReturnUnconstrained'>
  4. >>> proj.hook(0x10000, stub_func()) # 使用类的一个实例来 hook
  5. >>> proj.is_hooked(0x10000)
  6. True
  7. >>> proj.hooked_by(0x10000)
  8. <SimProcedure ReturnUnconstrained>
  9. >>> proj.hook_symbol('free', stub_func())
  10. 17316528
  11. >>> proj.is_symbol_hooked('free')
  12. True
  13. >>> proj.is_hooked(17316528)
  14. True

当然也可以利用装饰器编写自己的 hook 函数:

  1. >>> @proj.hook(0x20000, length=5) # length 参数可选,表示程序执行完 hook 后跳过几个字节
  2. ... def my_hook(state):
  3. ... state.regs.rax = 1
  4. ...
  5. >>> proj.is_hooked(0x20000)
  6. True

求解器引擎

angr 是一个符号执行工具,它通过符号表达式来模拟程序的执行,将程序的输出表示成包含这些符号的逻辑或数学表达式,然后利用约束求解器进行求解。

从前面的内容中我们已经知道 bitvectors 是一个比特串,并且看到了 bitvectors 做的一些具体的数学运算。其实 bitvectors 不仅可以表示具体的数值,还可以表示虚拟的数值,即符号变量。

  1. >>> x = state.solver.BVS("x", 64)
  2. >>> x
  3. <BV64 x_0_64>
  4. >>> y = state.solver.BVS("y", 64)
  5. >>> y
  6. <BV64 y_1_64>

而符号变量之间的运算同样不会时具体的数值,而是一个 AST,所以我们接下来同样使用 bitvector 来指代 AST:

  1. >>> x + 0x10
  2. <BV64 x_0_64 + 0x10>
  3. >>> (x + 0x10) / 2
  4. <BV64 (x_0_64 + 0x10) / 0x2>
  5. >>> x - y
  6. <BV64 x_0_64 - y_1_64>

每个 AST 都有一个 .op 和一个 .args 属性:

  1. >>> tree = (x + 1) / (y + 2)
  2. >>> tree
  3. <BV64 (x_0_64 + 0x1) / (y_1_64 + 0x2)>
  4. >>> tree.op # op 是表示操作符的字符串
  5. '__floordiv__'
  6. >>> tree.args # args 是操作数
  7. (<BV64 x_0_64 + 0x1>, <BV64 y_1_64 + 0x2>)
  8. >>> tree.args[0].op
  9. '__add__'
  10. >>> tree.args[0].args
  11. (<BV64 x_0_64>, <BV64 0x1>)
  12. >>> tree.args[0].args[1].op
  13. 'BVV'
  14. >>> tree.args[0].args[1].args
  15. (1L, 64)

知道了符号变量的表示,接下来看符号约束:

  1. >>> x == 1 # AST 比较会得到一个符号化的布尔值
  2. <Bool x_0_64 == 0x1>
  3. >>> x + y > 100
  4. <Bool (x_0_64 + y_1_64) > 0x64>
  5. >>> state.solver.BVV(1, 64) > 0 # 无符号数 1
  6. <Bool True>
  7. >>> state.solver.BVV(-1, 64) > 0 # 无符号数 0xffffffffffffffff
  8. <Bool True>

正因为布尔值是符号化的,所以在需要做 if 或者 while 判断的时候,不要直接使用比较作为条件,而应该使用 .is_true.is_false 来进行判断:

  1. >>> yes = state.solver.BVV(1, 64) > 0
  2. >>> yes
  3. <Bool True>
  4. >>> state.solver.is_true(yes)
  5. True
  6. >>> state.solver.is_false(yes)
  7. False
  8. >>> maybe = x == y
  9. >>> maybe
  10. <Bool x_0_64 == y_1_64>
  11. >>> state.solver.is_true(maybe)
  12. False
  13. >>> state.solver.is_false(maybe)
  14. False

为了进行符号求解,首先要将符号化布尔值作为符号变量有效值的断言加入到 state 中,作为限制条件,当然如果添加了无法满足的限制条件,将无法求解:

  1. >>> state.solver.add(x > y) # 添加限制条件
  2. [<Bool x_0_64 > y_1_64>]
  3. >>> state.solver.add(y > 2)
  4. [<Bool y_1_64 > 0x2>]
  5. >>> state.solver.add(10 > x)
  6. [<Bool x_0_64 < 0xa>]
  7. >>> state.satisfiable() # 可以求解
  8. True
  9. >>> state.solver.eval(x + y) # eval 求解得到任意一个符合条件的值
  10. 15L
  11. >> state.solver.eval_one(x + y) # 求解得到结果,如果有不止一个结果则抛出异常
  12. >>> state.solver.eval_upto(x + y, 5) # 给出最多 5 个结果
  13. [16L, 13L, 8L, 9L, 17L]
  14. >>> state.solver.eval_atleast(x + y, 5) # 给出至少 5 个结果,否则抛出异常
  15. [16L, 13L, 8L, 9L, 17L]
  16. >>> state.solver.eval_exact(x + y, 5) # 有正好 5 个结果,否则抛出异常
  17. >>> state.solver.min(x + y) # 给出最小的结果
  18. 7L
  19. >>> state.solver.max(x + y) # 给出最大的结果
  20. 17L
  21. >>> state.solver.eval(x + y, extra_constraints=[x + y < 10, x + y > 5]) # 额外添加临时限制条件
  22. 8L
  23. >>> state.solver.eval(x + y, cast_to=str) # 指定输出格式
  24. '\x00\x00\x00\x00\x00\x00\x00\x08'
  25. >>> state.solver.add(x - y > 10) # 添加不可满足的限制条件
  26. [<Bool (x_0_64 - y_1_64) > 0xa>]
  27. >>> state.satisfiable() # 无法求解
  28. False

angr 使用 z3 作为约束求解器,而 z3 支持 IEEE754 浮点数的理论,所以我们也可以使用浮点数。使用 FPVFPS 即可创建浮点数值和浮点符号:

  1. >>> state = proj.factory.entry_state() # 刷新状态
  2. >>> a = state.solver.FPV(3.2, state.solver.fp.FSORT_DOUBLE) # 浮点数值
  3. >>> a
  4. <FP64 FPV(3.2, DOUBLE)>
  5. >>> b = state.solver.FPS('b', state.solver.fp.FSORT_DOUBLE) # 浮点符号
  6. >>> b
  7. <FP64 FPS('FP_b_2_64', DOUBLE)>
  8. >>> a + b
  9. <FP64 fpAdd('RNE', FPV(3.2, DOUBLE), FPS('FP_b_2_64', DOUBLE))>
  10. >>> a + 1.1
  11. <FP64 FPV(4.300000000000001, DOUBLE)>
  12. >>> a + 1.1 > 0
  13. <Bool True>
  14. >>> b + 1.1 > 0
  15. <Bool fpGT(fpAdd('RNE', FPS('FP_b_2_64', DOUBLE), FPV(1.1, DOUBLE)), FPV(0.0, DOUBLE))>
  16. >>> state.solver.add(b + 2 < 0)
  17. [<Bool fpLT(fpAdd('RNE', FPS('FP_b_2_64', DOUBLE), FPV(2.0, DOUBLE)), FPV(0.0, DOUBLE))>]
  18. >>> state.solver.add(b + 2 > -1)
  19. [<Bool fpGT(fpAdd('RNE', FPS('FP_b_2_64', DOUBLE), FPV(2.0, DOUBLE)), FPV(-1.0, DOUBLE))>]
  20. >>> state.solver.eval(b)
  21. -2.4999999999999996

bitvectors 和浮点数的转换使用 raw_to_bvraw_to_fp

  1. >>> a.raw_to_bv()
  2. <BV64 0x400999999999999a>
  3. >>> b.raw_to_bv()
  4. <BV64 fpToIEEEBV(FPS('FP_b_2_64', DOUBLE))>
  5. >>> state.solver.BVV(0, 64).raw_to_fp()
  6. <FP64 FPV(0.0, DOUBLE)>
  7. >>> state.solver.BVS('x', 64).raw_to_fp()
  8. <FP64 fpToFP(x_3_64, DOUBLE)>

或者如果我们需要指定宽度的 bitvectors,可以使用 val_to_bvval_to_fp

  1. >>> a
  2. <FP64 FPV(3.2, DOUBLE)>
  3. >>> a.val_to_bv(12)
  4. <BV12 0x3>
  5. >>> a.val_to_bv(12).val_to_fp(state.solver.fp.FSORT_FLOAT)
  6. <FP32 FPV(3.0, FLOAT)>

程序状态

state.step() 用于模拟执行的一个 basic block 并返回一个 SimSuccessors 类型的对象,由于符号执行可能产生多个 state,所以该对象的 .successors 属性是一个列表,包含了所有可能的 state。

程序状态 state 是一个 SimState 类型的对象,angr.factory.AngrObjectFactory 类提供了创建 state 对象的方法:

  • .blank_state():返回一个几乎没有初始化的 state 对象,当访问未初始化的数据时,将返回一个没有约束条件的符号值。
  • .entry_state():从主对象文件的入口点创建一个 state。
  • .full_init_state():与 entry_state() 类似,但执行不是从入口点开始,而是从一个特殊的 SimProcedure 开始,在执行到入口点之前调用必要的初始化函数。
  • .call_state():创建一个准备执行给定函数的 state。

下面对这些方法的参数做一些说明:

  • 所有方法都可以传入参数 addr 来指定开始地址
  • 可以通过 args 传入参数列表,env 传入环境变量。类型可以是字符串,也可以是 bitvectors
  • 通过传入一个符号 bitvector 作为 argc,可以将 argc 符号化
  • 对于 .call_state(addr, arg1, arg2, ...)addr 是希望调用的函数地址,argN 是传递给函数的 N 个参数,如果希望分配一个内存空间并传递指针,则需要使用 angr.PointerWrapper();如果需要指定调用约定,可以传递一个 SimCC 对象作为 cc 参数

创建的 state 可以很方便地复制和合并:

  1. >>> s = proj.factory.blank_state()
  2. >>> s1 = s.copy() # 复制 state
  3. >>> s2 = s.copy()
  4. >>> s1.mem[0x1000].uint32_t = 0x41414141
  5. >>> s2.mem[0x1000].uint32_t = 0x42424242
  6. >>> (s_merged, m, anything_merged) = s1.merge(s2) # 合并将返回一个元组
  7. >>> s_merged # 表示合并后的 state
  8. <SimState @ 0x405000>
  9. >>> m # 描述 state flag 的符号变量
  10. [<Bool state_merge_1_14_16 == 0x0>, <Bool state_merge_1_14_16 == 0x1>]
  11. >>> anything_merged # 描述是否全部合并的布尔值
  12. True
  13. >>> aaaa_or_bbbb = s_merged.mem[0x1000].uint32_t # 此时的值需要根据 state flag 来判断
  14. >>> aaaa_or_bbbb
  15. <uint32_t <BV32 Reverse((if (state_merge_1_14_16 == 0x1) then 0x42424242 else (if (state_merge_1_14_16 == 0x0) then 0x41414141 else 0x0)))> at 0x1000>

我们已经知道使用 state.mem 可以很方便的操作内存,但如果你想要对内存进行原始的操作时,可以使用 state.memory.load(addr, size).store(addr, val)

  1. >>> s = proj.factory.blank_state()
  2. >>> s.memory.store(0x4000, s.solver.BVV(0x0123456789abcdef, 128)) # 默认大端序
  3. >>> s.memory.load(0x4008, 8) # 默认大端序
  4. <BV64 0x123456789abcdef>
  5. >>> s.memory.load(0x4008, 8, endness=angr.archinfo.Endness.LE) # 小端序
  6. <BV64 0xefcdab8967452301>
  7. >>> s.mem[0x4008].uint64_t.resolved # 与 mem 对比
  8. <BV64 0xefcdab8967452301>
  9. >>> s.memory.store(0x4000, s.solver.BVV(0x0123456789abcdef, 128), endness=angr.archinfo.Endness.LE) # 小端序
  10. >>> s.memory.load(0x4000, 8) # 默认大端序
  11. <BV64 0xefcdab8967452301>
  12. >>> s.memory.load(0x4000, 8, endness=angr.archinfo.Endness.LE) # 小端序
  13. <BV64 0x123456789abcdef>
  14. >>> s.mem[0x4000].uint64_t.resolved # 与 mem 对比
  15. <BV64 0x123456789abcdef>

可以看到默认情况下 store 和 load 都使用大端序的方式,但可以通过指定参数 endness 来使用小端序。

通过 state.options 可以对 angr 的行为做特定的优化。我们既可以在创建 state 时将 option 作为参数传递进去,也可以对已经存在的 state 进行修改。例如:

  1. >>> s = proj.factory.blank_state(add_options={angr.options.LAZY_SOLVES}) # 启用 options
  2. >>> s = proj.factory.blank_state(remove_options={angr.options.LAZY_SOLVES}) # 禁用 options
  3. >>> s.options.add(angr.options.LAZY_SOLVES) # 启用 option
  4. >>> s.options.remove(angr.options.LAZY_SOLVES) # 禁用 option

SimState 对象的所有内容(包括memoryregistersmem等)都是以插件的形式存储的,这样做的好处是将代码模块化,如果我们想要在 state 中存储其他的数据,那么直接实现一个插件就可以了。

  • state.globals:实现了一个标准的 Python dict 的接口,通过它可以在一个 state 上存储任意的数据。
  • state.history:存储了一个 state 在执行过程中的路径历史数据,它是一个链表,每个节点表示一个执行,通过像 history.parent.parent 这样的方式进行遍历。为了得到 history 中某个具体的值,可以使用迭代器 history.NAME,这样的值保存在 history.recent_NAME。如果想要快速得到这些值的一个列表,可以查看 .hardcopy
    • history.descriptions:对 state 每次执行的描述的列表。
    • history.bbl_addrs:state 每次执行的 basic block 的地址的列表,每次执行可能多于一个地址,也可能是被 hook 的 SimProcedures 的地址。
    • history.jumpkinds:state 每次执行时改变控制流的操作的列表。
    • history.guards:state 执行中遇到的每个分支的条件的列表。
    • history.events:state 执行中遇到的可能有用的事件的列表。
    • history.actions:通常是空的,但如果启用了 options.refs,则会记录程序执行时访问的所有内存、寄存器和临时变量。
  • state.callstack:用于记录函数调用堆栈,它是一个链表,可以直接遍历 state.callstack 获得每个调用的 frame。
    • callstack.func_addr:当前正在执行的函数的地址。
    • callstack.call_site_addr:调用当前函数的 basic block 的地址。
    • callstack.stack_ptr:从当前函数开头开始计算的堆栈指针的值。
    • callstack.ret_addr:当前函数的返回地址。

模拟管理器

模拟管理器(Simulation Managers)是 angr 最重要的控制接口,它允许同时对各组状态的符号执行进行控制,同时应用搜索策略来探索程序的状态空间。states 会被整理到 stashes 里,从而进行各种操作。

我们用一个小程序来作例子,它有 3 种可能性,也就是 3 条路径:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. int main() {
  4. int num = 0;
  5. scanf("%d", &num);
  6. if (num > 50) {
  7. if (num <= 100) {
  8. printf("50 < num <= 100\n");
  9. } else {
  10. printf("100 < num\n");
  11. exit(1);
  12. }
  13. } else {
  14. printf("num <= 50\n");
  15. }
  16. }
  17. // gcc example.c

模拟管理器最基本的功能是将一个 stash 里所有的 states 向前推进一个 basic block,利用 .step() 来实现,而 .run() 方法可以直接执行到程序结束:

  1. >>> proj = angr.Project('a.out', auto_load_libs=False)
  2. >>> state = proj.factory.entry_state()
  3. >>> simgr = proj.factory.simgr(state) # 创建 SimulationManager
  4. >>> simgr
  5. <SimulationManager with 1 active>
  6. >>> simgr.active # active stash
  7. [<SimState @ 0x400640>]
  8. >>> while len(simgr.active) == 1: # 一直执行到 active stash 中有不止一个 state
  9. ... simgr.step()
  10. ...
  11. <SimulationManager with 1 active>
  12. ...
  13. <SimulationManager with 1 active>
  14. <SimulationManager with 2 active>
  15. >>> simgr.active # 有 2 个 active state
  16. [<SimState @ 0x40078f>, <SimState @ 0x400763>]
  17. >>> simgr.step() # 同时推进 2 个 state
  18. <SimulationManager with 3 active>
  19. >>> simgr.active # 得到 3 个 state
  20. [<SimState @ 0x400600>, <SimState @ 0x40076b>, <SimState @ 0x400779>]
  21. >>> simgr.run() # 一直执行到程序结束
  22. <SimulationManager with 3 deadended>
  23. >>> simgr.deadended # deadended stash
  24. [<SimState @ 0x1000068>, <SimState @ 0x1000020>, <SimState @ 0x1000068>]

于是我们得到了 3 个 deadended 状态的 state。这一状态表示一个 state 一直执行到没有后继者了,那么就将它从 active stash 中移除,放到 deadended stash 中。

stash 默认的类型有下面几种,当然你也可以定义自己的 stash:

  • active:默认情况下存储可以执行的 state。
  • deadended:当 state 无法继续执行时会被放到这里,包括没有更多的有效指令,没有可满足的后继状态,或者指令指针无效等。
  • pruned:当启用 LAZY_SOLVES 时,除非绝对必要,否则是不会在执行中检查 state 的可满足性的。当某个 state 被发现是不可满足的,则 state 会被回溯上去,以确定最早是哪个 state 不可满足。然后这之后所有的 state 都会被放到 pruned stash 中。
  • unconstrained:如果在 SimulationManager 创建时启用了 save_unconstrained,则那些没有约束条件的 state 会被放到 unconstrained stash 中。
  • unsat:如果在 SimulationManager 创建时启用了 save_unsat,则那些被认为不可满足的 state 会被放到 unsat stash 中。

另外还有一个叫做 errored 的列表,它不是一个 stash。如果 state 在执行过程中发生错误,则该 state 会被包装在一个 ErrorRecord 对象中,该对象包含 state 和引发的错误,然后这个对象被插入到 errored 中。

可以使用 .move(),将 filter_func 筛选出来的 state 从 from_stash 移动到 to_stash

  1. >>> simgr.move(from_stash='deadended', to_stash='more_then_50', filter_func=lambda s: '100' in s.posix.dumps(1))
  2. <SimulationManager with 1 deadended, 2 more_then_50>

每个 stash 都是一个列表,可以用列表的操作来遍历它,同时 angr 也提供了一些高级的方法,例如在 stash 名称前面加上 one_,表示该 stash 的第一个 state;在名称前加上 mp_,将得到一个 mulpyplexed 版本的 stash:

  1. >>> for s in simgr.deadended + simgr.more_then_50:
  2. ... print hex(s.addr)
  3. ...
  4. 0x1000068L
  5. 0x1000020L
  6. 0x1000068L
  7. >>> simgr.one_more_then_50
  8. <SimState @ 0x1000020>
  9. >>> simgr.mp_more_then_50
  10. MP([<SimState @ 0x1000020>, <SimState @ 0x1000068>])
  11. >>> simgr.mp_more_then_50.posix.dumps(0)
  12. MP(['-2424202024@', '+0000000060\x00'])

最后再介绍一下模拟管理器所使用的探索技术(exploration techniques)。默认策略是广度优先搜索,但根据目标程序或者需要达到的目的不同,我们可能需要使用不同的探索技术,通过调用 simgr.use_technique(tech) 来实现,其中 tech 是一个 ExplorationTechnique 子类的实例。angr 内置的探索技术在 angr.exploration_techniques 下:

  • Explorer:该技术实现了 .explore() 功能,允许在探索时查找或避免某些地址。
  • DFS:深度优先搜索,每次只探索一条路径,其它路径会放到 deferred stash 中。直到当前路径探索结束,再从 deferred 中取出最长的一条继续探索。
  • LoopLimiter:限制路径的循环次数,超出限制的路径将被放到 discard stash 中。
  • LengthLimiter:限制路径的最大长度
  • ManualMergepoint:将程序中的某个地址标记为合并点,将在一定时间范围内到达的所有 state 合并在一起。
  • Veritesting:是这篇论文的实现,试图识别出有用的合并点来解决路径爆炸问题。在创建 SimulationManager 时通过 veritesting=True 来开启。
  • Tracer:记录在某个具体输入下的执行路径,结果是执行完最后一个 basic block 的 state,存放在 traced stash 中。
  • Oppologist:当遇到某个不支持的指令时,它将具体化该指令的所有输入并使用 unicorn engine 继续执行。
  • Threading:将线程级并行添加到探索过程中。
  • Spiller:当处于 active 的 state 过多时,将其中一些转存到磁盘上以保持较低的内存消耗。

VEX IR 翻译器

angr 使用了 VEX 作为二进制分析的中间表示。VEX IR 是由 Valgrind 项目开发和使用的中间表示,后来这一部分被分离出去作为 libVEX,libVEX 用于将机器码转换成 VEX IR(更多内容参考章节5.2.3)。在 angr 项目中,开发了模块 PyVEX 作为 libVEX 的 Python 包装。当然也对 libVEX 做了一些修改,使其更加适用于程序分析。

一些用法如下:

  1. >>> import pyvex, archinfo
  2. >>> bb = pyvex.IRSB('\xc3', 0x400400, archinfo.ArchAMD64()) # 将一个位于 0x400400 的 AMD64 基本块(\xc3,即ret)转成 VEX
  3. >>> bb.pp() # 打印 IRSB(Intermediate Representation Super Block)
  4. IRSB {
  5. t0:Ity_I64 t1:Ity_I64 t2:Ity_I64 t3:Ity_I64
  6. 00 | ------ IMark(0x400400, 1, 0) ------
  7. 01 | t0 = GET:I64(rsp)
  8. 02 | t1 = LDle:I64(t0)
  9. 03 | t2 = Add64(t0,0x0000000000000008)
  10. 04 | PUT(rsp) = t2
  11. 05 | t3 = Sub64(t2,0x0000000000000080)
  12. 06 | ====== AbiHint(0xt3, 128, t1) ======
  13. NEXT: PUT(rip) = t1; Ijk_Ret
  14. }
  15. >>> bb.statements[3] # 表达式
  16. <pyvex.stmt.WrTmp object at 0x7f38f1ef84b0>
  17. >>> bb.statements[3].pp()
  18. t2 = Add64(t0,0x0000000000000008)
  19. >>> bb.statements[3].data # 数据
  20. <pyvex.expr.Binop object at 0x7f38f1ef8460>
  21. >>> bb.statements[3].data.pp()
  22. Add64(t0,0x0000000000000008)
  23. >>> bb.statements[3].data.op # 操作符
  24. 'Iop_Add64'
  25. >>> bb.statements[3].data.args # 参数
  26. [<pyvex.expr.RdTmp object at 0x7f38f1f77cb0>, <pyvex.expr.Const object at 0x7f38f1f77098>]
  27. >>> bb.statements[3].data.args[0]
  28. <pyvex.expr.RdTmp object at 0x7f38f1f77cb0>
  29. >>> bb.statements[3].data.args[0].pp()
  30. t0
  31. >>> bb.next # 基本块末尾无条件跳转的目标
  32. <pyvex.expr.RdTmp object at 0x7f38f3cb6f38>
  33. >>> bb.next.pp()
  34. t1
  35. >>> bb.jumpkind # 无条件跳转的类型
  36. 'Ijk_Ret'

到这里 angr 的核心概念就介绍得差不多了,更多更详细的内容还是推荐查看官方教程和 API 文档。另外在我的博客里有 angr 源码分析的笔记。

扩展工具

由于 angr 强大的静态分析和符号执行能力,我们可以在 angr 之上开发其他的一些工:

  • angrop:rop 链自动化生成器
  • Patcherex:二进制文件自动化 patch 引擎
  • Driller:用符号执行增强 AFL 的下一代 fuzzer
  • Rex:自动化漏洞利用引擎

CTF 实例

查看章节 6.2.3、6.2.8。

参考资料