Execution Engines

原文

当你要求在angr中执行一个步骤时，有些东西必须实际执行这个步骤。angr使用一系列引擎(SimEngine类的子类)来模拟给定代码段对输入状态的影响。angr的执行核心只是按顺序尝试所有可用的引擎，选择第一个能够处理该步骤的引擎。以下是引擎的默认列表，顺序如下:

• 当前一个步骤将我们带到某些不可持续的状态时，故障引擎就会启动
• 当上一步在系统调用中结束时，系统调用引擎就会启动
• hook引擎在hook住当前地址时启动
• 当unicorn状态选项被启用，并且状态中没有符号数据时，unicorn引擎就启动了
• VEX引擎作为最后的后备。

SimSuccessors

实际上依次尝试所有引擎的代码是project.factory.successors(state， **kwargs)，它将自己的参数传递给每个引擎。这个函数位于state.step()和simulation_manager.step()的核心。它返回一个sim对象，我们在前面简要讨论过。sim的目的是对存储在各种列表属性中的后续状态执行简单的分类。它们是:

Attribute	Guard Condition	Instruction Pointer	Description
successors	True(可以是符号化的，但限制为真的)	可以是符号的(但是256个或更少的解;见unconstrained_successors)。	引擎处理状态的一种正常的、可满足的后续状态。该状态的指令指针可以是符号的(即，基于用户输入的计算跳转)，因此该状态实际上可能表示几个潜在的执行继续。
unsat_successors	False(可以是符号化的，但限制为False)	可以是符号的	不可满足的继任者。这些后继者的守卫条件只能为假(例如，不能执行的跳跃，或者必须执行的跳跃的默认分支)。
flat_successors	True(可以是符号化的，但限制为真的)	具体的值。	如上所述，继任者名单中的状态可以有符号指令指针。这是相当令人困惑的，在代码的其他地方(如SimEngineVEX.process，当该状态向前步进时)，我们假设单个程序状态只表示代码中单个点的执行。为了缓解这种情况，当我们遇到带有符号指令指针的后续状态时，我们为它们计算所有可能的具体解决方案(最高可达256个任意阈值)，并为每个这样的解决方案创建状态副本。我们称这个过程为“扁平化”。这些flat_successors是状态，每个状态都有一个不同的、具体的指令指针。举个例子,如果一个状态的指令指针在successors 是X + 5,其中X有 X > 0x800000约束和X < = 0x800010,扁平成16个不同flat_successors状态,指令指针是0x800006,0x800007,直到0 x800015。
unconstrained_successors	True(可以是符号化的，但限制为真的)	符号(超过256个解决方案)。	在上述扁平化过程中，如果指令指针有超过256种可能的解决方案，我们假设指令指针被非约束数据覆盖(即用户数据的堆栈溢出)。这种假设一般来说是不合理的。这种国家被置于不受限制的继承人手中，而不是置于继承人手中。
all_successors	anything	可以是象征性的	是successors + unsat_successors + unconstrained_successors.

断点

待办事项:重写这个以修正叙述
像任何像样的执行引擎一样，angr支持断点。这太酷了!设置一个点的方法如下:

>>> import angr
>>> b = angr.Project('examples/fauxware/fauxware')

# get our state
>>> s = b.factory.entry_state()

# add a breakpoint. This breakpoint will drop into ipdb right before a memory write happens.
>>> s.inspect.b('mem_write')

# on the other hand, we can have a breakpoint trigger right *after* a memory write happens. 
# we can also have a callback function run instead of opening ipdb.
>>> def debug_func(state):
...     print("State %s is about to do a memory write!")

>>> s.inspect.b('mem_write', when=angr.BP_AFTER, action=debug_func)

# or, you can have it drop you in an embedded IPython!
>>> s.inspect.b('mem_write', when=angr.BP_AFTER, action=angr.BP_IPYTHON)

除了内存写，还有许多其他地方可以断点。这是清单。对于每个事件，您可以在BP_BEFORE或BP_AFTER处中断。

Event type	Event meaning
mem_read	Memory is being read.
mem_write	Memory is being written.
address_concretization	A symbolic memory access is being resolved.
reg_read	A register is being read.
reg_write	A register is being written.
tmp_read	A temp is being read.
tmp_write	A temp is being written.
expr	An expression is being created (i.e., a result of an arithmetic operation or a constant in the IR).
statement	An IR statement is being translated.
instruction	A new (native) instruction is being translated.
irsb	A new basic block is being translated.
constraints	New constraints are being added to the state.
exit	A successor is being generated from execution.
fork	A symbolic execution state has forked into multiple states.
symbolic_variable	A new symbolic variable is being created.
call	A call instruction is hit.
return	A ret instruction is hit.
simprocedure	A simprocedure (or syscall) is executed.
dirty	A dirty IR callback is executed.
syscall	A syscall is executed (called in addition to the simprocedure event).
engine_process	A SimEngine is about to process some code.

这些事件暴露了不同的属性:
见原文。

这些属性可以作为状态的成员访问。在适当的断点回调期间进行检查，以访问适当的值。您甚至可以修改这些值以修改这些值的进一步使用!

>>> def track_reads(state):
...     print('Read', state.inspect.mem_read_expr, 'from', state.inspect.mem_read_address)
...
>>> s.inspect.b('mem_read', when=angr.BP_AFTER, action=track_reads)

此外，这些属性中的每一个都可以用作要检查的关键字参数。B使断点具有条件:

# This will break before a memory write if 0x1000 is a possible value of its target expression
>>> s.inspect.b('mem_write', mem_write_address=0x1000)

# This will break before a memory write if 0x1000 is the *only* value of its target expression
>>> s.inspect.b('mem_write', mem_write_address=0x1000, mem_write_address_unique=True)

# This will break after instruction 0x8000, but only 0x1000 is a possible value of the last expression that was read from memory
>>> s.inspect.b('instruction', when=angr.BP_AFTER, instruction=0x8000, mem_read_expr=0x1000)

酷炫的东西!事实上，我们甚至可以将函数指定为条件:

# this is a complex condition that could do anything! In this case, it makes sure that RAX is 0x41414141 and
# that the basic block starting at 0x8004 was executed sometime in this path's history
>>> def cond(state):
...     return state.eval(state.regs.rax, cast_to=str) == 'AAAA' and 0x8004 in state.inspect.backtrace

>>> s.inspect.b('mem_write', condition=cond)

这是一些很酷的东西!

注意mem_read断点

每当执行程序或二进制分析进行内存读取时，都会触发mem_read断点。如果你在mem_read上使用断点，同时也使用state.mem从内存地址加载数据，然后知道断点将被触发，因为您正在技术上读取内存。
因此，如果你想从内存加载数据，而不触发任何你已经设置的mem_read断点，使用state.memory.load关键字参数disable_actions=True和inspect=False。
状态也是如此。Find和您可以使用相同的关键字参数来防止触发mem_read断点。