ANGR簡介
簡介
angr 是一個多架構的二進位制分析平臺，具備對二進位制檔案的動態符號執行能力和多種靜態分析能力。在近幾年的 CTF 中也大有用途。
安裝
在 Ubuntu 上，首先我們應該安裝所有的編譯所需要的依賴環境：
$ sudo apt install python-dev libffi-dev build-essential virtualenvwrapper
強烈建議在虛擬環境中安裝 angr，因為有幾個 angr 的依賴（比如z3）是從他們的原始庫中 fork 而來，如果你已經安裝了 z3,那麼肯定不希望 angr 的依賴覆蓋掉官方的共享庫，開一個隔離的環境就好了：
$ mkvirtualenv angr
$ sudo pip install angr
如果這樣安裝失敗的話，那麼你可以按照下面的順序從 angr 的官方倉庫安裝：
1. claripy
2. archinfo
3. pyvex
4. cle
5. angr
例如下面這樣：
$ 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 的第一步是新建一個工程，幾乎所有的操作都是圍繞這個工程展開的：
>>> 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.
這樣就得到了二進位制檔案的各種資訊，如：
>>> proj.filename # 檔名
'/bin/true'
>>> proj.arch # 一個 archinfo.Arch 物件
<Arch AMD64 (LE)>
>>> hex(proj.entry) # 入口點
'0x401370'
程式載入時會將二進位制檔案和共享庫對映到虛擬地址中，CLE 模組就是用來處理這些東西的。
>>> proj.loader
<Loaded true, maps [0x400000:0x5008000]>
所有物件檔案如下，其中二進位制檔案本身是 main_object，然後還可以檢視物件檔案的相關資訊：
>>> 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 載入共享庫：
>>> 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：
>>> block = proj.factory.block(proj.entry) # 從程式頭開始解析一個 basic block
>>> block
<Block for 0x401370, 42 bytes>
>>> block.pp() # 列印
0x401370: xor ebp, ebp
0x401372: mov r9, rdx
0x401375: pop rsi
0x401376: mov rdx, rsp
0x401379: and rsp, 0xfffffffffffffff0
0x40137d: push rax
0x40137e: push rsp
0x40137f: lea r8, qword ptr [rip + 0x32da]
0x401386: lea rcx, qword ptr [rip + 0x3263]
0x40138d: lea rdi, qword ptr [rip - 0xe4]
0x401394: call qword ptr [rip + 0x205b76]
>>> block.instructions # 指令數量
11
>>> block.instruction_addrs # 指令地址
[4199280L, 4199282L, 4199285L, 4199286L, 4199289L, 4199293L, 4199294L, 4199295L, 4199302L, 4199309L, 4199316L]
另外，還可以將 Block 物件轉換成其他形式：
>>> block.capstone
<CapstoneBlock for 0x401370>
>>> block.capstone.pp()
>>> block.vex
IRSB <0x2a bytes, 11 ins., <Arch AMD64 (LE)>> at 0x401370
>>> block.vex.pp()
程式的執行需要初始化一個模擬程式狀態的 SimState 物件：
>>> state = proj.factory.entry_state()
>>> state
<SimState @ 0x401370>
該物件包含了程式的記憶體、暫存器、檔案系統資料等等模擬執行時動態變化的資料，例如：
>>> state.regs # 暫存器名物件
<angr.state_plugins.view.SimRegNameView object at 0x7f126fdfe810>
>>> state.regs.rip # BV64 物件
<BV64 0x401370>
>>> state.regs.rsp
<BV64 0x7fffffffffeff98>
>>> 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 0x8949ed31>
這裡的 BV，即 bitvectors，可以理解為一個位元串，用於在 angr 裡表示 CPU 資料。看到在這裡 rdi 有點特殊，它沒有具體的數值，而是在符號執行中所使用的符號變數，我們會在稍後再做講解。
下面是 Python int 和 bitvectors 之間的轉換：
>>> bv = state.solver.BVV(0x1234, 32) # 建立值 0x1234 的 BV32 物件
>>> bv
<BV32 0x1234>
>>> hex(state.solver.eval(bv)) # 將 BV32 物件轉換為 Python int
'0x1234'
>>> bv = state.solver.BVV(0x1234, 64)
>>> bv
<BV64 0x1234>
>>> hex(state.solver.eval(bv))
'0x1234L'
於是 bitvectors 可以進行數學運算：
>>> one = state.solver.BVV(1, 64)
>>> one_hundred = state.solver.BVV(100, 64)
>>> one_hundred + one # 位數相同時可以直接運算
<BV64 0x65>
>>> one_hundred + one + 0x100
<BV64 0x165>
>>> state.solver.BVV(-1, 64) # 預設為無符號數
<BV64 0xffffffffffffffff>
>>> five = state.solver.BVV(5, 27)
>>> five
<BV27 0x5>
>>> one + five.zero_extend(64 - 27) # 位數不同時需要進行擴充套件
<BV64 0x6>
>>> one + five.sign_extend(64 - 27) # 或者有符號擴充套件
<BV64 0x6>
使用 bitvectors 可以直接來設定暫存器和記憶體的值，當傳入的是 Python int 時，angr 會自動將其轉換成 bitvectors：
>>> state.regs.rsi = state.solver.BVV(3, 64)
>>> state.regs.rsi
<BV64 0x3>
>>> state.mem[0x1000].long = 4 # 在地址 0x1000 存放一個 long 型別的值 4
>>> state.mem[0x1000].long.resolved # .resolved 獲取 bitvectors
<BV64 0x4>
>>> state.mem[0x1000].long.concrete # .concrete 獲得 Python int
4L
初始化的 state 可以經過模擬執行得到一系列的 states，模擬管理器（Simulation Managers）的作用就是對這些 states 進行管理：
>>> simgr = proj.factory.simulation_manager(state)
>>> simgr
<SimulationManager with 1 active>
>>> simgr.active # 當前 state
[<SimState @ 0x401370>]
>>> simgr.step() # 模擬執行一個 basic block
<SimulationManager with 1 active>
>>> simgr.active # 當前 state 被更新
[<SimState @ 0x1022f80>]
>>> simgr.active[0].regs.rip # active[0] 是當前 state
<BV64 0x1022f80>
>>> state.regs.rip # 但原始的 state 並沒有改變
<BV64 0x401370>
angr 提供了大量函式用於程式分析，在這些函式在 Project.analyses.，例如：
>>> cfg = p.analyses.CFGFast() # 得到 control-flow graph
>>> cfg
<CFGFast Analysis Result at 0x7f1265b62650>
>>> cfg.graph
<networkx.classes.digraph.DiGraph object at 0x7f1265e77310> # 詳情請檢視 networkx
>>> len(cfg.graph.nodes())
934
>>> entry_node = cfg.get_any_node(proj.entry) # 得到給定地址的 CFGNode
>>> entry_node
<CFGNode 0x401370[42]>
>>> len(list(cfg.graph.successors(entry_node)))
2
如果要想畫出圖來，還需要安裝 matplotlib。
>>> 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：指定物件檔案的入口點
舉個例子：
angr.Project(main_opts={'backend': 'ida', 'custom_arch': 'i386'}, lib_opts={'libc.so.6': {'backend': 'elf'}})
載入物件檔案和細分型別如下：
>>> 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：核心物件檔案
通過對這些物件檔案進行操作，可以解析出相關資訊：
>>> obj = proj.loader.main_object
>>> obj
<ELF Object true, maps [0x400000:0x60721f]>
>>> hex(obj.entry) # 入口地址
'0x401370'
>>> hex(obj.min_addr), hex(obj.max_addr) # 起始地址和結束地址
('0x400000', '0x60721f')
>>> for seg in obj.segments: # segments
... print seg
...
<ELFSegment offset=0x0, flags=0x5, filesize=0x5f48, vaddr=0x400000, memsize=0x5f48>
<ELFSegment offset=0x6c30, flags=0x6, filesize=0x450, vaddr=0x606c30, memsize=0x5f0>
>>> for sec in obj.sections: # sections
... print sec
...
<Unnamed | offset 0x0, vaddr 0x400000, size 0x0>
<.interp | offset 0x238, vaddr 0x400238, size 0x1c>
<.note.ABI-tag | offset 0x254, vaddr 0x400254, size 0x20>
<.note.gnu.build-id | offset 0x274, vaddr 0x400274, size 0x24>
...etc
根據地址查詢我們需要的東西：
>>> proj.loader.find_object_containing(0x400000) # 包含指定地址的 object
<ELF Object true, maps [0x400000:0x60721f]>
>>> free = proj.loader.find_symbol('free') # 根據名字或地址在 project 中查詢 symbol
>>> free
<Symbol "free" in libc.so.6 at 0x1083ab0>
>>> free.name # 符號名
u'free'
>>> free.owner_obj # 所屬 object
<ELF Object libc-2.27.so, maps [0x1000000:0x13bb98f]>
>>> 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=0x0, flags=0x5, filesize=0x5f48, vaddr=0x400000, memsize=0x5f48>
>>> obj.find_section_containing(obj.entry) # 包含指定地址的 section
<.text | offset 0x12b0, vaddr 0x4012b0, size 0x33d9>
>>> 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 0x1083ab0>
>>> hex(obj.linked_base) # 預連結的基址
'0x0'
>>> hex(obj.mapped_base) # 實際對映的基址
'0x400000'
通過 obj.relocs 可以檢視所有的重定位符號資訊，或者通過 obj.imports 可以得到一個符號資訊的字典：
>>> for imp in obj.imports:
... print imp, obj.imports[imp]
...
strncmp <cle.backends.elf.relocation.amd64.R_X86_64_GLOB_DAT object at 0x7faf8301b110>
lseek <cle.backends.elf.relocation.amd64.R_X86_64_GLOB_DAT object at 0x7faf8301b7d0>
malloc <cle.backends.elf.relocation.amd64.R_X86_64_GLOB_DAT object at 0x7faf8301be10>
>>> obj.imports['free'].symbol # 從重定向資訊得到匯入符號
<Symbol "free" in true (import)>
>>> obj.imports['free'].owner_obj # 從重定向資訊得到所屬的 object
<ELF Object true, maps [0x400000:0x60721f]>
這一部分還有個 hooking 機制，用於將共享庫中的程式碼替換為其他的操作。使用函式 proj.hook(addr, hook) 和 proj.hook_symbol(name, hook) 來做到這一點，其中 hook 是一個 SimProcedure 的例項。通過 .is_hooked、.unhook 和 .hooked_by 來進行管理：
>>> stub_func = angr.SIM_PROCEDURES['stubs']['ReturnUnconstrained'] # 獲得一個類
>>> stub_func
<class 'angr.procedures.stubs.ReturnUnconstrained.ReturnUnconstrained'>
>>> proj.hook(0x10000, stub_func()) # 使用類的一個例項來 hook
>>> proj.is_hooked(0x10000)
True
>>> proj.hooked_by(0x10000)
<SimProcedure ReturnUnconstrained>
>>> proj.hook_symbol('free', stub_func())
17316528
>>> proj.is_symbol_hooked('free')
True
>>> proj.is_hooked(17316528)
True
當然也可以利用裝飾器編寫自己的 hook 函式：
>>> @proj.hook(0x20000, length=5) # length 引數可選，表示程式執行完 hook 後跳過幾個位元組
... def my_hook(state):
... state.regs.rax = 1
...
>>> proj.is_hooked(0x20000)
True
求解器引擎
angr 是一個符號執行工具，它通過符號表示式來模擬程式的執行，將程式的輸出表示成包含這些符號的邏輯或數學表示式，然後利用約束求解器進行求解。
從前面的內容中我們已經知道 bitvectors 是一個位元串，並且看到了 bitvectors 做的一些具體的數學運算。其實 bitvectors 不僅可以表示具體的數值，還可以表示虛擬的數值，即符號變數。
>>> 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：
>>> x + 0x10
<BV64 x_0_64 + 0x10>
>>> (x + 0x10) / 2
<BV64 (x_0_64 + 0x10) / 0x2>
>>> x - y
<BV64 x_0_64 - y_1_64>
每個 AST 都有一個 .op 和一個 .args 屬性：
>>> tree = (x + 1) / (y + 2)
>>> tree
<BV64 (x_0_64 + 0x1) / (y_1_64 + 0x2)>
>>> tree.op # op 是表示操作符的字串
'__floordiv__'
>>> tree.args # args 是運算元
(<BV64 x_0_64 + 0x1>, <BV64 y_1_64 + 0x2>)
>>> tree.args[0].op
'__add__'
>>> tree.args[0].args
(<BV64 x_0_64>, <BV64 0x1>)
>>> tree.args[0].args[1].op
'BVV'
>>> tree.args[0].args[1].args
(1L, 64)
知道了符號變數的表示，接下來看符號約束：
>>> x == 1 # AST 比較會得到一個符號化的布林值
<Bool x_0_64 == 0x1>
>>> x + y > 100
<Bool (x_0_64 + y_1_64) > 0x64>
>>> state.solver.BVV(1, 64) > 0 # 無符號數 1
<Bool True>
>>> state.solver.BVV(-1, 64) > 0 # 無符號數 0xffffffffffffffff
<Bool True>
正因為布林值是符號化的，所以在需要做 if 或者 while 判斷的時候，不要直接使用比較作為條件，而應該使用 .is_true 和 .is_false 來進行判斷：
>>> 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 中，作為限制條件，當然如果新增了無法滿足的限制條件，將無法求解：
>>> state.solver.add(x > y) # 新增限制條件
[<Bool x_0_64 > y_1_64>]
>>> state.solver.add(y > 2)
[<Bool y_1_64 > 0x2>]
>>> state.solver.add(10 > x)
[<Bool x_0_64 < 0xa>]
>>> state.satisfiable() # 可以求解
True
>>> state.solver.eval(x + y) # eval 求解得到任意一個符合條件的值
15L
>> state.solver.eval_one(x + y) # 求解得到結果，如果有不止一個結果則丟擲異常
>>> state.solver.eval_upto(x + y, 5) # 給出最多 5 個結果
[16L, 13L, 8L, 9L, 17L]
>>> state.solver.eval_atleast(x + y, 5) # 給出至少 5 個結果，否則丟擲異常
[16L, 13L, 8L, 9L, 17L]
>>> state.solver.eval_exact(x + y, 5) # 有正好 5 個結果，否則丟擲異常
>>> state.solver.min(x + y) # 給出最小的結果
7L
>>> state.solver.max(x + y) # 給出最大的結果
17L
>>> state.solver.eval(x + y, extra_constraints=[x + y < 10, x + y > 5]) # 額外新增臨時限制條件
8L
>>> 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) > 0xa>]
>>> state.satisfiable() # 無法求解
False
angr 使用 z3 作為約束求解器，而 z3 支援 IEEE754 浮點數的理論，所以我們也可以使用浮點數。使用 FPV 和 FPS 即可建立浮點數值和浮點符號：
>>> 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：
>>> a.raw_to_bv()
<BV64 0x400999999999999a>
>>> 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：
>>> a
<FP64 FPV(3.2, DOUBLE)>
>>> a.val_to_bv(12)
<BV12 0x3>
>>> 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。
下面對這些方法的引數做一些說明：
- 所有方法都可以傳入引數
addr來指定開始地址 - 可以通過
args傳入引數列表，env傳入環境變數。型別可以是字串，也可以是 bitvectors - 通過傳入一個符號 bitvector 作為
argc，可以將argc符號化 - 對於
.call_state(addr, arg1, arg2, ...)，addr是希望呼叫的函式地址，argN是傳遞給函式的 N 個引數，如果希望分配一個記憶體空間並傳遞指標，則需要使用angr.PointerWrapper()；如果需要指定呼叫約定，可以傳遞一個 SimCC 物件作為cc引數
建立的 state 可以很方便地複製和合並：
>>> s = proj.factory.blank_state()
>>> s1 = s.copy() # 複製 state
>>> s2 = s.copy()
>>> s1.mem[0x1000].uint32_t = 0x41414141
>>> s2.mem[0x1000].uint32_t = 0x42424242
>>> (s_merged, m, anything_merged) = s1.merge(s2) # 合併將返回一個元組
>>> s_merged # 表示合併後的 state
<SimState @ 0x405000>
>>> m # 描述 state flag 的符號變數
[<Bool state_merge_1_14_16 == 0x0>, <Bool state_merge_1_14_16 == 0x1>]
>>> anything_merged # 描述是否全部合併的布林值
True
>>> aaaa_or_bbbb = s_merged.mem[0x1000].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)：
>>> s = proj.factory.blank_state()
>>> s.memory.store(0x4000, s.solver.BVV(0x0123456789abcdef, 128)) # 預設大端序
>>> s.memory.load(0x4008, 8) # 預設大端序
<BV64 0x123456789abcdef>
>>> s.memory.load(0x4008, 8, endness=angr.archinfo.Endness.LE) # 小端序
<BV64 0xefcdab8967452301>
>>> s.mem[0x4008].uint64_t.resolved # 與 mem 對比
<BV64 0xefcdab8967452301>
>>> s.memory.store(0x4000, s.solver.BVV(0x0123456789abcdef, 128), endness=angr.archinfo.Endness.LE) # 小端序
>>> s.memory.load(0x4000, 8) # 預設大端序
<BV64 0xefcdab8967452301>
>>> s.memory.load(0x4000, 8, endness=angr.archinfo.Endness.LE) # 小端序
<BV64 0x123456789abcdef>
>>> s.mem[0x4000].uint64_t.resolved # 與 mem 對比
<BV64 0x123456789abcdef>
可以看到預設情況下 store 和 load 都使用大端序的方式，但可以通過指定引數 endness 來使用小端序。
通過 state.options 可以對 angr 的行為做特定的優化。我們既可以在建立 state 時將 option 作為引數傳遞進去，也可以對已經存在的 state 進行修改。例如：
>>> 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 條路徑：
#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() 方法可以直接執行到程式結束：
>>> 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 @ 0x400640>]
>>> 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 @ 0x40078f>, <SimState @ 0x400763>]
>>> simgr.step() # 同時推進 2 個 state
<SimulationManager with 3 active>
>>> simgr.active # 得到 3 個 state
[<SimState @ 0x400600>, <SimState @ 0x40076b>, <SimState @ 0x400779>]
>>> simgr.run() # 一直執行到程式結束
<SimulationManager with 3 deadended>
>>> simgr.deadended # deadended stash
[<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 都會被放到prunedstash 中。unconstrained：如果在 SimulationManager 建立時啟用了save_unconstrained，則那些沒有約束條件的 state 會被放到unconstrainedstash 中。unsat：如果在 SimulationManager 建立時啟用了save_unsat，則那些被認為不可滿足的 state 會被放到unsatstash 中。
另外還有一個叫做 errored 的列表，它不是一個 stash。如果 state 在執行過程中發生錯誤，則該 state 會被包裝在一個 ErrorRecord 物件中，該物件包含 state 和引發的錯誤，然後這個物件被插入到 errored 中。
可以使用 .move()，將 filter_func 篩選出來的 state 從 from_stash 移動到 to_stash：
>>> 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：
>>> for s in simgr.deadended + simgr.more_then_50:
... print hex(s.addr)
...
0x1000068L
0x1000020L
0x1000068L
>>> simgr.one_more_then_50
<SimState @ 0x1000020>
>>> simgr.mp_more_then_50
MP([<SimState @ 0x1000020>, <SimState @ 0x1000068>])
>>> 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：深度優先搜尋，每次只探索一條路徑，其它路徑會放到deferredstash 中。直到當前路徑探索結束，再從deferred中取出最長的一條繼續探索。LoopLimiter：限制路徑的迴圈次數，超出限制的路徑將被放到discardstash 中。LengthLimiter：限制路徑的最大長度ManualMergepoint：將程式中的某個地址標記為合併點，將在一定時間範圍內到達的所有 state 合併在一起。Veritesting：是這篇論文的實現，試圖識別出有用的合併點來解決路徑爆炸問題。在建立 SimulationManager 時通過veritesting=True來開啟。Tracer：記錄在某個具體輸入下的執行路徑，結果是執行完最後一個 basic block 的 state，存放在tracedstash 中。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 做了一些修改，使其更加適用於程式分析。
一些用法如下：
>>> import pyvex, archinfo
>>> bb = pyvex.IRSB('\xc3', 0x400400, 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(0x400400, 1, 0) ------
01 | t0 = GET:I64(rsp)
02 | t1 = LDle:I64(t0)
03 | t2 = Add64(t0,0x0000000000000008)
04 | PUT(rsp) = t2
05 | t3 = Sub64(t2,0x0000000000000080)
06 | ====== AbiHint(0xt3, 128, t1) ======
NEXT: PUT(rip) = t1; Ijk_Ret
}
>>> bb.statements[3] # 表示式
<pyvex.stmt.WrTmp object at 0x7f38f1ef84b0>
>>> bb.statements[3].pp()
t2 = Add64(t0,0x0000000000000008)
>>> bb.statements[3].data # 資料
<pyvex.expr.Binop object at 0x7f38f1ef8460>
>>> bb.statements[3].data.pp()
Add64(t0,0x0000000000000008)
>>> bb.statements[3].data.op # 操作符
'Iop_Add64'
>>> bb.statements[3].data.args # 引數
[<pyvex.expr.RdTmp object at 0x7f38f1f77cb0>, <pyvex.expr.Const object at 0x7f38f1f77098>]
>>> bb.statements[3].data.args[0]
<pyvex.expr.RdTmp object at 0x7f38f1f77cb0>
>>> bb.statements[3].data.args[0].pp()
t0
>>> bb.next # 基本塊末尾無條件跳轉的目標
<pyvex.expr.RdTmp object at 0x7f38f3cb6f38>
>>> bb.next.pp()
t1
>>> bb.jumpkind # 無條件跳轉的型別
'Ijk_Ret'
到這裡 angr 的核心概念就介紹得差不多了，更多更詳細的內容還是推薦檢視官方教程和 API 文件。另外在我的部落格裡有 angr 原始碼分析的筆記。
擴充套件工具
由於 angr 強大的靜態分析和符號執行能力，我們可以在 angr 之上開發其他的一些工：
CTF 例項
檢視章節 6.2.3、6.2.8。
參考資料
相關文章
- angr初探
- angr使用記錄
- Angr學習（5）
- Angr-Learn-0x01
- angr原理與實踐（一）——原理
- 簡介
- Jira使用簡介 HP ALM使用簡介
- BookKeeper 介紹(1)--簡介
- ggml 簡介
- PCIe簡介
- valgrind簡介
- SpringMVC簡介SpringMVC
- HTML 簡介HTML
- 核心簡介
- DPDK簡介
- Docker簡介Docker
- SpotBugs 簡介
- webservice簡介Web
- OME 簡介
- Spring 簡介Spring
- pytorch簡介PyTorch
- 【QCustomPlot】簡介
- DuckDB簡介
- SDL簡介
- swagger簡介Swagger
- MongoDb簡介MongoDB
- RabbitMQ簡介MQ
- JetCache 簡介
- JavaParser 簡介Java
- SSHJ 簡介
- Redpanda簡介
- Swoole 簡介
- jQuery 簡介jQuery
- SQLite簡介SQLite
- NGINX簡介Nginx
- Electron簡介
- cookie 簡介Cookie
- Session 簡介Session