简介
angr 是一个多架构的二进制分析平台,具备对二进制文件的动态符号执行能力和多种静态分析能力。在近几年的 CTF 中也大有用途。
安装
在 Ubuntu 上,首先我们应该安装所有的编译所需要的依赖环境:
Copy $ sudo apt install python-dev libffi-dev build-essential virtualenvwrapper
强烈建议在虚拟环境中安装 angr,因为有几个 angr 的依赖(比如z3)是从他们的原始库中 fork 而来,如果你已经安装了 z3,那么肯定不希望 angr 的依赖覆盖掉官方的共享库,开一个隔离的环境就好了:
Copy $ mkvirtualenv angr
$ sudo pip install angr
如果这样安装失败的话,那么你可以按照下面的顺序从 angr 的官方仓库安装:
Copy 1. claripy
2. archinfo
3. pyvex
4. cle
5. angr
例如下面这样:
Copy $ git clone https://github.com/angr/claripy
$ cd claripy
$ sudo pip install -r requirements.txt
$ sudo python setup.py build
$ sudo python setup.py install
安装过程中可能会有一些奇怪的错误,可以到官方文档中查看。
另外 angr 还有一个 GUI 可以用,查看 angr Management 。
使用方法
快速入门
使用 angr 的第一步是新建一个工程,几乎所有的操作都是围绕这个工程展开的:
Copy >>> import angr
>>> proj = angr . Project ( '/bin/true' )
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.
这样就得到了二进制文件的各种信息,如:
Copy >>> proj . filename # 文件名
'/bin/true'
>>> proj . arch # 一个 archinfo.Arch 对象
< Arch AMD64 (LE) >
>>> hex (proj.entry) # 入口点
'0x401370'
程序加载时会将二进制文件和共享库映射到虚拟地址中,CLE 模块就是用来处理这些东西的。
Copy >>> proj . loader
< Loaded true , maps [ 0x 400000 : 0x 5008000 ] >
所有对象文件如下,其中二进制文件本身是 main_object,然后还可以查看对象文件的相关信息:
Copy >>> for obj in proj.loader.all_objects:
... print obj
...
<ELF Object true, maps [0x400000:0x60721f]>
<ELF Object libc-2.27.so, maps [0x1000000:0x13bb98f]>
<ELF Object ld-2.27.so, maps [0x2000000:0x22260f7]>
<ELFTLSObject Object cle##tls, maps [0x3000000:0x300d010]>
<ExternObject Object cle##externs, maps [0x4000000:0x4008000]>
<KernelObject Object cle##kernel, maps [0x5000000:0x5008000]>
>>> proj.loader.main_object
<ELF Object true, maps [0x400000:0x60721f]>
>>> hex(proj.loader.main_object.min_addr)
'0x400000'
>>> hex(proj.loader.main_object.max_addr)
'0x60721f'
>>> proj.loader.main_object.execstack
False
通常我们在创建工程时选择关闭 auto_load_libs
以避免 angr 加载共享库:
Copy >>> p = angr.Project('/bin/true', auto_load_libs=False)
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.
>>> p.loader.all_objects
[<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:
Copy >>> block = proj . factory . block (proj.entry) # 从程序头开始解析一个 basic block
>>> block
< Block for 0x 401370 , 42 bytes >
>>> block . pp () # 打印
0x 401370 : xor ebp , ebp
0x 401372 : mov r9 , rdx
0x 401375 : pop rsi
0x 401376 : mov rdx , rsp
0x 401379 : and rsp , 0x fffffffffffffff0
0x 40137d : push rax
0x 40137e : push rsp
0x 40137f : lea r8 , qword ptr [ rip + 0x 32da ]
0x 401386 : lea rcx , qword ptr [ rip + 0x 3263 ]
0x 40138d : lea rdi , qword ptr [ rip - 0x e4 ]
0x 401394 : call qword ptr [ rip + 0x 205b76 ]
>>> block . instructions # 指令数量
11
>>> block . instruction_addrs # 指令地址
[ 4199280 L , 4199282 L , 4199285 L , 4199286 L , 4199289 L , 4199293 L , 4199294 L , 4199295 L , 4199302 L , 4199309 L , 4199316 L ]
另外,还可以将 Block 对象转换成其他形式:
Copy >>> block . capstone
< CapstoneBlock for 0x 401370 >
>>> block . capstone . pp ()
>>> block . vex
IRSB <0x 2a bytes , 11 ins ., < Arch AMD64 (LE) >> at 0x 401370
>>> block . vex . pp ()
程序的执行需要初始化一个模拟程序状态的 SimState
对象:
Copy >>> state = proj . factory . entry_state ()
>>> state
< SimState @ 0x 401370 >
该对象包含了程序的内存、寄存器、文件系统数据等等模拟运行时动态变化的数据,例如:
Copy >>> state . regs # 寄存器名对象
< angr . state_plugins . view . SimRegNameView object at 0x 7f126fdfe810 >
>>> state . regs . rip # BV64 对象
< BV64 0x 401370 >
>>> state . regs . rsp
< BV64 0x 7fffffffffeff98 >
>>> state . regs . rsp . length # BV 对象都有 .length 属性
64
>>> state . regs . rdi
< BV64 reg_48_0_64 { UNINITIALIZED } > # BV64 对象,符号变量
>>> state . mem [ proj . entry ]. int . resolved # 将入口点的内存解释为 C 语言的 int 类型
< BV32 0x 8949ed31 >
这里的 BV,即 bitvectors,可以理解为一个比特串,用于在 angr 里表示 CPU 数据。看到在这里 rdi 有点特殊,它没有具体的数值,而是在符号执行中所使用的符号变量,我们会在稍后再做讲解。
下面是 Python int 和 bitvectors 之间的转换:
Copy >>> bv = state . solver . BVV ( 0x 1234 , 32 ) # 创建值 0x1234 的 BV32 对象
>>> bv
< BV32 0x 1234 >
>>> hex (state.solver. eval (bv)) # 将 BV32 对象转换为 Python int
'0x1234'
>>> bv = state . solver . BVV ( 0x 1234 , 64 )
>>> bv
< BV64 0x 1234 >
>>> hex (state.solver. eval (bv))
'0x1234L'
于是 bitvectors 可以进行数学运算:
Copy >>> one = state . solver . BVV ( 1 , 64 )
>>> one_hundred = state . solver . BVV ( 100 , 64 )
>>> one_hundred + one # 位数相同时可以直接运算
< BV64 0x 65 >
>>> one_hundred + one + 0x 100
< BV64 0x 165 >
>>> state . solver . BVV ( - 1 , 64 ) # 默认为无符号数
< BV64 0x ffffffffffffffff >
>>> five = state . solver . BVV ( 5 , 27 )
>>> five
< BV27 0x 5 >
>>> one + five . zero_extend ( 64 - 27 ) # 位数不同时需要进行扩展
< BV64 0x 6 >
>>> one + five . sign_extend ( 64 - 27 ) # 或者有符号扩展
< BV64 0x 6 >
使用 bitvectors 可以直接来设置寄存器和内存的值,当传入的是 Python int 时,angr 会自动将其转换成 bitvectors:
Copy >>> state . regs . rsi = state . solver . BVV ( 3 , 64 )
>>> state . regs . rsi
< BV64 0x 3 >
>>> state . mem [ 0x 1000 ]. long = 4 # 在地址 0x1000 存放一个 long 类型的值 4
>>> state . mem [ 0x 1000 ]. long . resolved # .resolved 获取 bitvectors
< BV64 0x 4 >
>>> state . mem [ 0x 1000 ]. long . concrete # .concrete 获得 Python int
4 L
初始化的 state 可以经过模拟执行得到一系列的 states,模拟管理器(Simulation Managers)的作用就是对这些 states 进行管理:
Copy >>> simgr = proj . factory . simulation_manager (state)
>>> simgr
< SimulationManager with 1 active >
>>> simgr . active # 当前 state
[ < SimState @ 0x 401370 > ]
>>> simgr . step () # 模拟执行一个 basic block
< SimulationManager with 1 active >
>>> simgr . active # 当前 state 被更新
[ < SimState @ 0x 1022f80 > ]
>>> simgr . active [ 0 ]. regs . rip # active[0] 是当前 state
< BV64 0x 1022f80 >
>>> state . regs . rip # 但原始的 state 并没有改变
< BV64 0x 401370 >
angr 提供了大量函数用于程序分析,在这些函数在 Project.analyses.
,例如:
Copy >>> cfg = p . analyses . CFGFast () # 得到 control-flow graph
>>> cfg
< CFGFast Analysis Result at 0x 7f1265b62650 >
>>> cfg . graph
< networkx . classes . digraph . DiGraph object at 0x 7f1265e77310 > # 详情请查看 networkx
>>> len (cfg.graph. nodes ())
934
>>> entry_node = cfg . get_any_node (proj.entry) # 得到给定地址的 CFGNode
>>> entry_node
< CFGNode 0x 401370 [ 42 ] >
>>> len ( list (cfg.graph. successors (entry_node)))
2
如果要想画出图来,还需要安装 matplotlib。
Copy >>> import networkx as nx
>>> import matplotlib
>>> matplotlib . use ( 'Agg' )
>>> import matplotlib . pyplot as plt
>>> nx . draw (cfg.graph) # 画图
>>> plt . savefig ( 'temp.png' ) # 保存
二进制文件加载器
我们知道 angr 是高度模块化的,接下来我们就分别来看看这些组成模块,其中用于二进制加载模块称为 CLE。主类为 cle.loader.Loader
,它导入所有的对象文件并导出一个进程内存的抽象。类 cle.backends
是加载器的后端,根据二进制文件类型区分为 cle.backends.elf
、cle.backends.pe
、cle.backends.macho
等。
首先我们来看加载器的一些常用参数:
auto_load_libs
:是否自动加载主对象文件所依赖的共享库
except_missing_libs
:当有共享库没有找到时抛出异常
force_load_libs
:强制加载列表指定的共享库,不论其是否被依赖
skip_libs
:不加载列表指定的共享库,即使其被依赖
custom_ld_path
:可以到列表指定的路径查找共享库
如果希望对某个对象文件单独指定加载参数,可以使用 main_ops
和 lib_opts
以字典的形式指定参数。一些通用的参数如下:
backend
:使用的加载器后端,如:"elf", "pe", "mach-o", "ida", "blob" 等
custom_arch
:使用的 archinfo.Arch 对象
custom_base_addr
:指定对象文件的基址
custom_entry_point
:指定对象文件的入口点
举个例子:
Copy angr . Project (main_opts = { 'backend' : 'ida' , 'custom_arch' : 'i386' }, lib_opts = { 'libc.so.6' : { 'backend' : 'elf' }})
加载对象文件和细分类型如下:
Copy >>> for obj in proj.loader.all_objects:
... print obj
...
<ELF Object true, maps [0x400000:0x60721f]>
<ELF Object libc-2.27.so, maps [0x1000000:0x13bb98f]>
<ELF Object ld-2.27.so, maps [0x2000000:0x22260f7]>
<ELFTLSObject Object cle##tls, maps [0x3000000:0x300d010]>
<ExternObject Object cle##externs, maps [0x4000000:0x4008000]>
<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
:内核对象文件
通过对这些对象文件进行操作,可以解析出相关信息:
Copy >>> obj = proj . loader . main_object
>>> obj
< ELF Object true , maps [ 0x 400000 : 0x 60721f ] >
>>> hex (obj.entry) # 入口地址
'0x401370'
>>> hex (obj.min_addr), hex (obj.max_addr) # 起始地址和结束地址
( '0x400000' , '0x60721f' )
>>> for seg in obj . segments : # segments
... print seg
...
< ELFSegment offset =0x 0 , flags =0x 5 , filesize =0x 5f48 , vaddr =0x 400000 , memsize =0x 5f48 >
< ELFSegment offset =0x 6c30 , flags =0x 6 , filesize =0x 450 , vaddr =0x 606c30 , memsize =0x 5f0 >
>>> for sec in obj . sections : # sections
... print sec
...
< Unnamed | offset 0x 0 , vaddr 0x 400000 , size 0x 0 >
< . interp | offset 0x 238 , vaddr 0x 400238 , size 0x 1c >
< . note . ABI - tag | offset 0x 254 , vaddr 0x 400254 , size 0x 20 >
< . note . gnu . build - id | offset 0x 274 , vaddr 0x 400274 , size 0x 24 >
...etc
根据地址查找我们需要的东西:
Copy >>> proj . loader . find_object_containing ( 0x 400000 ) # 包含指定地址的 object
< ELF Object true , maps [ 0x 400000 : 0x 60721f ] >
>>> free = proj . loader . find_symbol ( 'free' ) # 根据名字或地址在 project 中查找 symbol
>>> free
< Symbol "free" in libc . so . 6 at 0x 1083ab0 >
>>> free . name # 符号名
u 'free'
>>> free . owner_obj # 所属 object
< ELF Object libc - 2.27 . so , maps [ 0x 1000000 : 0x 13bb98f ] >
>>> hex (free.rebased_addr) # 全局地址空间中的地址
'0x1083ab0'
>>> hex (free.linked_addr) # 相对于预链接基址的地址
'0x83ab0'
>>> hex (free.relative_addr) # 相对于对象基址的地址
'0x83ab0'
>>> free . is_export # 是否为导出符号
True
>>> free . is_import # 是否为导入符号
False
>>> obj . find_segment_containing (obj.entry) # 包含指定地址的 segment
< ELFSegment offset =0x 0 , flags =0x 5 , filesize =0x 5f48 , vaddr =0x 400000 , memsize =0x 5f48 >
>>> obj . find_section_containing (obj.entry) # 包含指定地址的 section
< . text | offset 0x 12b0 , vaddr 0x 4012b0 , size 0x 33d9 >
>>> main_free = obj . get_symbol ( 'free' ) # 根据名字在当前 object 中查找 symbol
>>> main_free
< Symbol "free" in true ( import ) >
>>> main_free . is_export
False
>>> main_free . is_import
True
>>> main_free . resolvedby # 从哪个 object 获得解析
< Symbol "free" in libc . so . 6 at 0x 1083ab0 >
>>> hex (obj.linked_base) # 预链接的基址
'0x0'
>>> hex (obj.mapped_base) # 实际映射的基址
'0x400000'
通过 obj.relocs
可以查看所有的重定位符号信息,或者通过 obj.imports
可以得到一个符号信息的字典:
Copy >>> for imp in obj . imports :
... print imp , obj . imports [ imp ]
...
strncmp < cle . backends . elf . relocation . amd64 . R_X86_64_GLOB_DAT object at 0x 7faf8301b110 >
lseek < cle . backends . elf . relocation . amd64 . R_X86_64_GLOB_DAT object at 0x 7faf8301b7d0 >
malloc < cle . backends . elf . relocation . amd64 . R_X86_64_GLOB_DAT object at 0x 7faf8301be10 >
>>> obj . imports [ 'free' ]. symbol # 从重定向信息得到导入符号
< Symbol "free" in true ( import ) >
>>> obj . imports [ 'free' ]. owner_obj # 从重定向信息得到所属的 object
< ELF Object true , maps [ 0x 400000 : 0x 60721f ] >
这一部分还有个 hooking 机制,用于将共享库中的代码替换为其他的操作。使用函数 proj.hook(addr, hook)
和 proj.hook_symbol(name, hook)
来做到这一点,其中 hook
是一个 SimProcedure 的实例。通过 .is_hooked
、.unhook
和 .hooked_by
来进行管理:
Copy >>> stub_func = angr . SIM_PROCEDURES[ 'stubs' ][ 'ReturnUnconstrained' ] # 获得一个类
>>> stub_func
<class 'angr.procedures.stubs.ReturnUnconstrained.ReturnUnconstrained' >
>>> proj . hook ( 0x 10000 , stub_func ()) # 使用类的一个实例来 hook
>>> proj . is_hooked ( 0x 10000 )
True
>>> proj . hooked_by ( 0x 10000 )
< SimProcedure ReturnUnconstrained >
>>> proj . hook_symbol ( 'free' , stub_func ())
17316528
>>> proj . is_symbol_hooked ( 'free' )
True
>>> proj . is_hooked ( 17316528 )
True
当然也可以利用装饰器编写自己的 hook 函数:
Copy >>> @ proj . hook ( 0x 20000 , length = 5 ) # length 参数可选,表示程序执行完 hook 后跳过几个字节
... def my_hook ( state ):
... state . regs . rax = 1
...
>>> proj . is_hooked ( 0x 20000 )
True
求解器引擎
angr 是一个符号执行工具,它通过符号表达式来模拟程序的执行,将程序的输出表示成包含这些符号的逻辑或数学表达式,然后利用约束求解器进行求解。
从前面的内容中我们已经知道 bitvectors 是一个比特串,并且看到了 bitvectors 做的一些具体的数学运算。其实 bitvectors 不仅可以表示具体的数值,还可以表示虚拟的数值,即符号变量。
Copy >>> x = state . solver . BVS ( "x" , 64 )
>>> x
< BV64 x_0_64 >
>>> y = state . solver . BVS ( "y" , 64 )
>>> y
< BV64 y_1_64 >
而符号变量之间的运算同样不会时具体的数值,而是一个 AST,所以我们接下来同样使用 bitvector 来指代 AST:
Copy >>> x + 0x 10
< BV64 x_0_64 + 0x 10 >
>>> (x + 0x 10 ) / 2
< BV64 (x_0_64 + 0x 10 ) / 0x 2 >
>>> x - y
< BV64 x_0_64 - y_1_64 >
每个 AST 都有一个 .op
和一个 .args
属性:
Copy >>> tree = (x + 1 ) / (y + 2 )
>>> tree
< BV64 (x_0_64 + 0x 1 ) / (y_1_64 + 0x 2 ) >
>>> tree . op # op 是表示操作符的字符串
'__floordiv__'
>>> tree . args # args 是操作数
( < BV64 x_0_64 + 0x 1 > , < BV64 y_1_64 + 0x 2 > )
>>> tree . args [ 0 ]. op
'__add__'
>>> tree . args [ 0 ]. args
( < BV64 x_0_64 > , < BV64 0x 1 > )
>>> tree . args [ 0 ]. args [ 1 ]. op
'BVV'
>>> tree . args [ 0 ]. args [ 1 ]. args
( 1 L , 64 )
知道了符号变量的表示,接下来看符号约束:
Copy >>> x == 1 # AST 比较会得到一个符号化的布尔值
< Bool x_0_64 == 0x 1 >
>>> x + y > 100
< Bool (x_0_64 + y_1_64) > 0x 64 >
>>> state . solver . BVV ( 1 , 64 ) > 0 # 无符号数 1
< Bool True >
>>> state . solver . BVV ( - 1 , 64 ) > 0 # 无符号数 0xffffffffffffffff
< Bool True >
正因为布尔值是符号化的,所以在需要做 if 或者 while 判断的时候,不要直接使用比较作为条件,而应该使用 .is_true
和 .is_false
来进行判断:
Copy >>> yes = state . solver . BVV ( 1 , 64 ) > 0
>>> yes
< Bool True >
>>> state . solver . is_true (yes)
True
>>> state . solver . is_false (yes)
False
>>> maybe = x == y
>>> maybe
< Bool x_0_64 == y_1_64 >
>>> state . solver . is_true (maybe)
False
>>> state . solver . is_false (maybe)
False
为了进行符号求解,首先要将符号化布尔值作为符号变量有效值的断言加入到 state 中,作为限制条件,当然如果添加了无法满足的限制条件,将无法求解:
Copy >>> state . solver . add (x > y) # 添加限制条件
[ < Bool x_0_64 > y_1_64 > ]
>>> state . solver . add (y > 2 )
[ < Bool y_1_64 > 0x 2 > ]
>>> state . solver . add ( 10 > x)
[ < Bool x_0_64 < 0x a > ]
>>> state . satisfiable () # 可以求解
True
>>> state . solver . eval (x + y) # eval 求解得到任意一个符合条件的值
15 L
>> state . solver . eval_one (x + y) # 求解得到结果,如果有不止一个结果则抛出异常
>>> state . solver . eval_upto (x + y, 5 ) # 给出最多 5 个结果
[ 16 L , 13 L , 8 L , 9 L , 17 L ]
>>> state . solver . eval_atleast (x + y, 5 ) # 给出至少 5 个结果,否则抛出异常
[ 16 L , 13 L , 8 L , 9 L , 17 L ]
>>> state . solver . eval_exact (x + y, 5 ) # 有正好 5 个结果,否则抛出异常
>>> state . solver . min (x + y) # 给出最小的结果
7 L
>>> state . solver . max (x + y) # 给出最大的结果
17 L
>>> state . solver . eval (x + y, extra_constraints = [x + y < 10 , x + y > 5 ]) # 额外添加临时限制条件
8 L
>>> state . solver . eval (x + y, cast_to = str ) # 指定输出格式
'\x00\x00\x00\x00\x00\x00\x00\x08'
>>> state . solver . add (x - y > 10 ) # 添加不可满足的限制条件
[ < Bool (x_0_64 - y_1_64) > 0x a > ]
>>> state . satisfiable () # 无法求解
False
angr 使用 z3 作为约束求解器,而 z3 支持 IEEE754 浮点数的理论,所以我们也可以使用浮点数。使用 FPV
和 FPS
即可创建浮点数值和浮点符号:
Copy >>> state = proj . factory . entry_state () # 刷新状态
>>> a = state . solver . FPV ( 3.2 , state.solver.fp.FSORT_DOUBLE) # 浮点数值
>>> a
< FP64 FPV ( 3.2 , DOUBLE) >
>>> b = state . solver . FPS ( 'b' , state.solver.fp.FSORT_DOUBLE) # 浮点符号
>>> b
< FP64 FPS ( 'FP_b_2_64' , DOUBLE) >
>>> a + b
< FP64 fpAdd ( 'RNE' , FPV ( 3.2 , DOUBLE), FPS ( 'FP_b_2_64' , DOUBLE)) >
>>> a + 1.1
< FP64 FPV ( 4.300000000000001 , DOUBLE) >
>>> a + 1.1 > 0
< Bool True >
>>> b + 1.1 > 0
< Bool fpGT ( fpAdd ( 'RNE' , FPS ( 'FP_b_2_64' , DOUBLE), FPV ( 1.1 , DOUBLE)), FPV ( 0.0 , DOUBLE)) >
>>> state . solver . add (b + 2 < 0 )
[ < Bool fpLT ( fpAdd ( 'RNE' , FPS ( 'FP_b_2_64' , DOUBLE), FPV ( 2.0 , DOUBLE)), FPV ( 0.0 , DOUBLE)) > ]
>>> state . solver . add (b + 2 > - 1 )
[ < Bool fpGT ( fpAdd ( 'RNE' , FPS ( 'FP_b_2_64' , DOUBLE), FPV ( 2.0 , DOUBLE)), FPV ( - 1.0 , DOUBLE)) > ]
>>> state . solver . eval (b)
- 2.4999999999999996
bitvectors 和浮点数的转换使用 raw_to_bv
和 raw_to_fp
:
Copy >>> a . raw_to_bv ()
< BV64 0x 400999999999999a >
>>> b . raw_to_bv ()
< BV64 fpToIEEEBV ( FPS ( 'FP_b_2_64' , DOUBLE)) >
>>> state . solver . BVV ( 0 , 64 ). raw_to_fp ()
< FP64 FPV ( 0.0 , DOUBLE) >
>>> state . solver . BVS ( 'x' , 64 ). raw_to_fp ()
< FP64 fpToFP (x_3_64, DOUBLE) >
或者如果我们需要指定宽度的 bitvectors,可以使用 val_to_bv
和 val_to_fp
:
Copy >>> a
< FP64 FPV ( 3.2 , DOUBLE) >
>>> a . val_to_bv ( 12 )
< BV12 0x 3 >
>>> a . val_to_bv ( 12 ). val_to_fp (state.solver.fp.FSORT_FLOAT)
< 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。
下面对这些方法的参数做一些说明:
可以通过 args
传入参数列表,env
传入环境变量。类型可以是字符串,也可以是 bitvectors
通过传入一个符号 bitvector 作为 argc
,可以将 argc
符号化
对于 .call_state(addr, arg1, arg2, ...)
,addr
是希望调用的函数地址,argN
是传递给函数的 N 个参数,如果希望分配一个内存空间并传递指针,则需要使用 angr.PointerWrapper()
;如果需要指定调用约定,可以传递一个 SimCC 对象作为 cc
参数
创建的 state 可以很方便地复制和合并:
Copy >>> s = proj . factory . blank_state ()
>>> s1 = s . copy () # 复制 state
>>> s2 = s . copy ()
>>> s1 . mem [ 0x 1000 ]. uint32_t = 0x 41414141
>>> s2 . mem [ 0x 1000 ]. uint32_t = 0x 42424242
>>> (s_merged , m , anything_merged) = s1 . merge (s2) # 合并将返回一个元组
>>> s_merged # 表示合并后的 state
< SimState @ 0x 405000 >
>>> m # 描述 state flag 的符号变量
[ < Bool state_merge_1_14_16 == 0x 0 > , < Bool state_merge_1_14_16 == 0x 1 > ]
>>> anything_merged # 描述是否全部合并的布尔值
True
>>> aaaa_or_bbbb = s_merged . mem [ 0x 1000 ]. uint32_t # 此时的值需要根据 state flag 来判断
>>> aaaa_or_bbbb
<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)
:
Copy >>> s = proj . factory . blank_state ()
>>> s . memory . store ( 0x 4000 , s.solver. BVV ( 0x 0123456789abcdef , 128 )) # 默认大端序
>>> s . memory . load ( 0x 4008 , 8 ) # 默认大端序
< BV64 0x 123456789abcdef >
>>> s . memory . load ( 0x 4008 , 8 , endness = angr.archinfo.Endness.LE) # 小端序
< BV64 0x efcdab8967452301 >
>>> s . mem [ 0x 4008 ]. uint64_t . resolved # 与 mem 对比
< BV64 0x efcdab8967452301 >
>>> s . memory . store ( 0x 4000 , s.solver. BVV ( 0x 0123456789abcdef , 128 ), endness = angr.archinfo.Endness.LE) # 小端序
>>> s . memory . load ( 0x 4000 , 8 ) # 默认大端序
< BV64 0x efcdab8967452301 >
>>> s . memory . load ( 0x 4000 , 8 , endness = angr.archinfo.Endness.LE) # 小端序
< BV64 0x 123456789abcdef >
>>> s . mem [ 0x 4000 ]. uint64_t . resolved # 与 mem 对比
< BV64 0x 123456789abcdef >
可以看到默认情况下 store 和 load 都使用大端序的方式,但可以通过指定参数 endness
来使用小端序。
通过 state.options
可以对 angr 的行为做特定的优化。我们既可以在创建 state 时将 option 作为参数传递进去,也可以对已经存在的 state 进行修改。例如:
Copy >>> s = proj . factory . blank_state (add_options = {angr.options.LAZY_SOLVES}) # 启用 options
>>> s = proj . factory . blank_state (remove_options = {angr.options.LAZY_SOLVES}) # 禁用 options
>>> s . options . add (angr.options.LAZY_SOLVES) # 启用 option
>>> s . options . remove (angr.options.LAZY_SOLVES) # 禁用 option
SimState 对象的所有内容(包括memory
、registers
、mem
等)都是以插件的形式存储的,这样做的好处是将代码模块化,如果我们想要在 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 条路径:
Copy #include <stdio.h>
#include <stdlib.h>
int main () {
int num = 0 ;
scanf( " %d " , & num) ;
if (num > 50 ) {
if (num <= 100 ) {
printf( "50 < num <= 100\n" ) ;
} else {
printf( "100 < num\n" ) ;
exit( 1 ) ;
}
} else {
printf( "num <= 50\n" ) ;
}
}
// gcc example.c
模拟管理器最基本的功能是将一个 stash 里所有的 states 向前推进一个 basic block,利用 .step()
来实现,而 .run()
方法可以直接执行到程序结束:
Copy >>> proj = angr . Project ( 'a.out' , auto_load_libs = False )
>>> state = proj . factory . entry_state ()
>>> simgr = proj . factory . simgr (state) # 创建 SimulationManager
>>> simgr
< SimulationManager with 1 active >
>>> simgr . active # active stash
[ < SimState @ 0x 400640 > ]
>>> while len (simgr.active) == 1 : # 一直执行到 active stash 中有不止一个 state
... simgr . step ()
...
< SimulationManager with 1 active >
...
< SimulationManager with 1 active >
< SimulationManager with 2 active >
>>> simgr . active # 有 2 个 active state
[ < SimState @ 0x 40078f > , < SimState @ 0x 400763 > ]
>>> simgr . step () # 同时推进 2 个 state
< SimulationManager with 3 active >
>>> simgr . active # 得到 3 个 state
[ < SimState @ 0x 400600 > , < SimState @ 0x 40076b > , < SimState @ 0x 400779 > ]
>>> simgr . run () # 一直执行到程序结束
< SimulationManager with 3 deadended >
>>> simgr . deadended # deadended stash
[ < SimState @ 0x 1000068 > , < SimState @ 0x 1000020 > , < SimState @ 0x 1000068 > ]
于是我们得到了 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
:
Copy >>> simgr . move (from_stash = 'deadended' , to_stash = 'more_then_50' , filter_func =lambda s : '100' in s.posix. dumps ( 1 ))
< SimulationManager with 1 deadended , 2 more_then_50 >
每个 stash 都是一个列表,可以用列表的操作来遍历它,同时 angr 也提供了一些高级的方法,例如在 stash 名称前面加上 one_
,表示该 stash 的第一个 state;在名称前加上 mp_
,将得到一个 mulpyplexed 版本的 stash:
Copy >>> for s in simgr . deadended + simgr . more_then_50 :
... print hex (s.addr)
...
0x1000068L
0x1000020L
0x1000068L
>>> simgr . one_more_then_50
< SimState @ 0x 1000020 >
>>> simgr . mp_more_then_50
MP ([ < SimState @ 0x 1000020 > , < SimState @ 0x 1000068 > ])
>>> simgr . mp_more_then_50 . posix . dumps ( 0 )
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 中。
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 做了一些修改,使其更加适用于程序分析。
一些用法如下:
Copy >>> import pyvex , archinfo
>>> bb = pyvex . IRSB ( '\xc3' , 0x 400400 , archinfo. ArchAMD64 ()) # 将一个位于 0x400400 的 AMD64 基本块(\xc3,即ret)转成 VEX
>>> bb . pp () # 打印 IRSB(Intermediate Representation Super Block)
IRSB {
t0 : Ity_I64 t1 : Ity_I64 t2 : Ity_I64 t3 : Ity_I64
00 | ------ IMark ( 0x 400400 , 1 , 0 ) ------
01 | t0 = GET : I64 (rsp)
02 | t1 = LDle : I64 (t0)
03 | t2 = Add64 (t0, 0x 0000000000000008 )
04 | PUT (rsp) = t2
05 | t3 = Sub64 (t2, 0x 0000000000000080 )
06 | ====== AbiHint (0xt3, 128 , t1) ======
NEXT : PUT (rip) = t1; Ijk_Ret
}
>>> bb . statements [ 3 ] # 表达式
< pyvex . stmt . WrTmp object at 0x 7f38f1ef84b0 >
>>> bb . statements [ 3 ]. pp ()
t2 = Add64 (t0, 0x 0000000000000008 )
>>> bb . statements [ 3 ]. data # 数据
< pyvex . expr . Binop object at 0x 7f38f1ef8460 >
>>> bb . statements [ 3 ]. data . pp ()
Add64 (t0, 0x 0000000000000008 )
>>> bb . statements [ 3 ]. data . op # 操作符
'Iop_Add64'
>>> bb . statements [ 3 ]. data . args # 参数
[ < pyvex . expr . RdTmp object at 0x 7f38f1f77cb0 > , < pyvex . expr . Const object at 0x 7f38f1f77098 > ]
>>> bb . statements [ 3 ]. data . args [ 0 ]
< pyvex . expr . RdTmp object at 0x 7f38f1f77cb0 >
>>> bb . statements [ 3 ]. data . args [ 0 ]. pp ()
t0
>>> bb . next # 基本块末尾无条件跳转的目标
< pyvex . expr . RdTmp object at 0x 7f38f3cb6f38 >
>>> bb . next . pp ()
t1
>>> bb . jumpkind # 无条件跳转的类型
'Ijk_Ret'
到这里 angr 的核心概念就介绍得差不多了,更多更详细的内容还是推荐查看官方教程和 API 文档。另外在我的博客里有 angr 源码分析的笔记。
扩展工具
由于 angr 强大的静态分析和符号执行能力,我们可以在 angr 之上开发其他的一些工:
CTF 实例
查看章节 6.2.3、6.2.8。
参考资料