API Reference¶

class angr.BP

Bases: object

A breakpoint.

__init__(when=When.BEFORE, enabled=True, condition=None, action=<function BP_IPDB>, **kwargs)

Parameters:

when (When)
enabled (bool)
condition (Callable[[SimState], bool] | None)
action (Action)
kwargs (dict[str, Any])

check(state, when)

Checks state state to see if the breakpoint should fire.

Parameters:

state (SimState) – The state.
when (When) – Whether the check is happening before or after the event.

Return type:

bool

Returns:

A boolean representing whether the checkpoint should fire.

fire(state)

Trigger the breakpoint.

Parameters:: state (SimState) – The state.

angr.BP_IPDB(state)

Return type:: None
Parameters:: state (SimState)

angr.BP_IPYTHON(state)

Return type:: None
Parameters:: state (SimState)

class angr.Analysis

Bases: object

This class represents an analysis on the program.

Variables:

project – The project for this analysis.
kb (KnowledgeBase) – The knowledgebase object.
_progress_callback – A callback function for receiving the progress of this analysis. It only takes one argument, which is a float number from 0.0 to 100.0 indicating the current progress.
_show_progressbar (bool) – If a progressbar should be shown during the analysis. It’s independent from _progress_callback.
_progressbar (progress.Progress) – The progress bar object.

project: Project

kb: KnowledgeBase

errors: list[AnalysisLogEntry] = []¶

named_errors: defaultdict[str, list[AnalysisLogEntry]] = {}

log: list

property ram_usage: float: Return the current RAM usage of the Python process, in bytes. The value is updated at most once per second.

exception angr.AngrAIError: Bases: AngrError

exception angr.AngrAnalysisError: Bases: AngrError

exception angr.AngrAnnotatedCFGError: Bases: AngrError

exception angr.AngrAssemblyError: Bases: AngrError

exception angr.AngrBackwardSlicingError: Bases: AngrError

exception angr.AngrBladeError: Bases: AngrError

exception angr.AngrBladeSimProcError: Bases: AngrBladeError

exception angr.AngrCFGError: Bases: AngrError

exception angr.AngrCallableError: Bases: AngrSurveyorError

exception angr.AngrCallableMultistateError: Bases: AngrCallableError

exception angr.AngrCorruptDBError: Bases: AngrDBError

exception angr.AngrDBError: Bases: AngrError

exception angr.AngrDDGError: Bases: AngrAnalysisError

exception angr.AngrDataGraphError: Bases: AngrAnalysisError

exception angr.AngrDecompilationError: Bases: AngrError

exception angr.AngrDelayJobNotice: Bases: AngrForwardAnalysisError

exception angr.AngrDirectorError: Bases: AngrExplorationTechniqueError

exception angr.AngrError: Bases: Exception

exception angr.AngrExitError: Bases: AngrError

exception angr.AngrExplorationTechniqueError: Bases: AngrError

exception angr.AngrExplorerError: Bases: AngrExplorationTechniqueError

exception angr.AngrForwardAnalysisError: Bases: AngrError

exception angr.AngrIncompatibleDBError: Bases: AngrDBError

exception angr.AngrIncongruencyError: Bases: AngrAnalysisError

exception angr.AngrInvalidArgumentError: Bases: AngrError

exception angr.AngrJobMergingFailureNotice: Bases: AngrForwardAnalysisError

exception angr.AngrJobWideningFailureNotice: Bases: AngrForwardAnalysisError

exception angr.AngrLifterError: Bases: AngrError

exception angr.AngrLoopAnalysisError: Bases: AngrAnalysisError

exception angr.AngrMissingTypeError: Bases: AngrTypeError

exception angr.AngrNoPluginError: Bases: AngrError

exception angr.AngrPathError: Bases: AngrError

exception angr.AngrRuntimeError: Bases: RuntimeError

exception angr.AngrSimOSError: Bases: AngrError

exception angr.AngrSkipJobNotice: Bases: AngrForwardAnalysisError

exception angr.AngrSurveyorError: Bases: AngrError

exception angr.AngrSyscallError: Bases: AngrError

exception angr.AngrTracerError: Bases: AngrExplorationTechniqueError

exception angr.AngrTypeError: Bases: AngrError, TypeError

exception angr.AngrUnsupportedSyscallError: Bases: AngrSyscallError, SimProcedureError, SimUnsupportedError

exception angr.AngrVFGError: Bases: AngrError

exception angr.AngrVFGRestartAnalysisNotice: Bases: AngrVFGError

exception angr.AngrValueError: Bases: AngrError, ValueError

exception angr.AngrVaultError: Bases: AngrError

class angr.Blade

Bases: object

Blade is a light-weight program slicer that works with networkx DiGraph containing CFGNodes. It is meant to be used in angr for small or on-the-fly analyses.

__init__(graph, dst_run, dst_stmt_idx, direction='backward', project=None, cfg=None, ignore_sp=False, ignore_bp=False, ignored_regs=None, max_level=3, base_state=None, stop_at_calls=False, cross_insn_opt=False, max_predecessors=10, include_imarks=True, control_dependence=True)

Parameters:

graph (DiGraph) – A graph representing the control flow graph. Note that it does not take angr.analyses.CFGEmulated or angr.analyses.CFGFast.
dst_run (int) – An address specifying the target SimRun.
dst_stmt_idx (int) – The target statement index. -1 means executing until the last statement.
direction (str) – ‘backward’ or ‘forward’ slicing. Forward slicing is not yet supported.
project (angr.Project) – The project instance.
cfg (angr.analyses.CFGBase) – the CFG instance. It will be made mandatory later.
ignore_sp (bool) – Whether the stack pointer should be ignored in dependency tracking. Any dependency from/to stack pointers will be ignored if this options is True.
ignore_bp (bool) – Whether the base pointer should be ignored or not.
max_level (int) – The maximum number of blocks that we trace back for.
stop_at_calls (bool) – Limit slicing within a single function. Do not proceed when encounters a call edge.
include_imarks (bool) – Should IMarks (instruction boundaries) be included in the slice.
control_dependence (bool) – Whether to consider control dependencies. If True, the temps controlling conditional exits will be added to the tainting set.
max_predecessors (int)

Returns:

None

property slice

dbg_repr(arch=None)

class angr.Block

Bases: Serializable

Represents a basic block in a binary or a program.

BLOCK_MAX_SIZE = 4096¶

__init__(addr, project=None, arch=None, size=None, max_size=None, byte_string=None, thumb=False, backup_state=None, extra_stop_points=None, opt_level=None, num_inst=None, traceflags=0, strict_block_end=None, collect_data_refs=False, cross_insn_opt=True, load_from_ro_regions=False, const_prop=False, initial_regs=None, skip_stmts=False)

Parameters:: arch (Arch | None)

arch

addr

thumb

size

pp(**kwargs)

set_initial_regs()

static reset_initial_regs()

property vex: IRSB | IRSB

property vex_nostmt

property disassembly: DisassemblerBlock: Provide a disassembly object using whatever disassembler is available

property capstone: CapstoneBlock

property pcode: PCodeBlock

property codenode

property bytes: bytes | None

property instructions: int

property instruction_addrs

class angr.Emulator

Bases: object

Emulator is a utility that adapts an angr SuccessorsEngine to a more user-friendly interface for concrete execution. It only supports concrete execution.

Saftey: This class is not thread-safe. It should only be used in a single-threaded context. It can be safely shared between multiple threads, provided that only one thread is using it at a time.

__init__(engine, init_state)

Parameters:

engine (SuccessorsEngine) – The SuccessorsEngine to use for emulation.
init_state (SimState) – The initial state to use for emulation.

property state: SimState: The current state of the emulator.

property breakpoints: set[int]: The set of currently set breakpoints.

add_breakpoint(addr)

Add a breakpoint at the given address.

Parameters:: addr (int) – The address to set the breakpoint at.
Return type:: None

remove_breakpoint(addr)

Remove a breakpoint at the given address, if present.

Parameters:: addr (int) – The address to remove the breakpoint from.
Return type:: None

run(num_inst=None)

Execute the emulator.

Return type:: EmulatorStopReason
Parameters:: num_inst (int | None)

class angr.EmulatorStopReason

Bases: Enum

Enum representing the reason for stopping the emulator.

INSTRUCTION_LIMIT = 'instruction_limit'¶

BREAKPOINT = 'breakpoint'¶

NO_SUCCESSORS = 'no_successors'¶

MEMORY_ERROR = 'memory_error'¶

FAILURE = 'failure'¶

EXIT = 'exit'¶

class angr.ExplorationTechnique

Bases: object

An ExplorationTechnique is a set of hooks for a simulation manager that assists in the implementation of new techniques in symbolic exploration.

Any number of these methods may be overridden by a subclass. To use an exploration technique, call simgr.use_technique with an instance of the technique.

__init__()

setup(simgr)

Perform any initialization on this manager you might need to do.

Parameters:: simgr (angr.SimulationManager) – The simulation manager to which you have just been added

step(simgr, stash='active', **kwargs)

Hook the process of stepping a stash forward. Should call simgr.step(stash, **kwargs) in order to do the actual processing.

Parameters:

simgr (angr.SimulationManager)
stash (str)

filter(simgr, state, **kwargs)

Perform filtering on which stash a state should be inserted into.

If the state should be filtered, return the name of the stash to move the state to. If you want to modify the state before filtering it, return a tuple of the stash to move the state to and the modified state. To defer to the original categorization procedure, return the result of simgr.filter(state, **kwargs)

If the user provided a filter_func in their step or run command, it will appear here.

Parameters:

simgr (angr.SimulationManager)
state (angr.SimState)

selector(simgr, state, **kwargs)

Determine if a state should participate in the current round of stepping. Return True if the state should be stepped, and False if the state should not be stepped. To defer to the original selection procedure, return the result of simgr.selector(state, **kwargs).

If the user provided a selector_func in their step or run command, it will appear here.

Parameters:

simgr (angr.SimulationManager)
state (angr.SimState)

step_state(simgr, state, **kwargs)

Determine the categorization of state successors into stashes. The result should be a dict mapping stash names to the list of successor states that fall into that stash, or None as a stash name to use the original stash name.

If you would like to directly work with a SimSuccessors object, you can obtain it with simgr.successors(state, **kwargs). This is not recommended, as it denies other hooks the opportunity to look at the successors. Therefore, the usual technique is to call simgr.step_state(state, **kwargs) and then mutate the returned dict before returning it yourself.

..note:: This takes precedence over the filter hook - filter is only applied to states returned from here in the None stash.

Parameters:

simgr (angr.SimulationManager)
state (angr.SimState)

successors(simgr, state, **kwargs)

Perform the process of stepping a state forward, returning a SimSuccessors object.

To defer to the original succession procedure, return the result of simgr.successors(state, **kwargs). Be careful about not calling this method (e.g. calling project.factory.successors manually) as it denies other hooks the opportunity to instrument the step. Instead, you can mutate the kwargs for the step before calling the original, and mutate the result before returning it yourself.

If the user provided a successor_func in their step or run command, it will appear here.

Parameters:

simgr (angr.SimulationManager)
state (angr.SimState)

complete(simgr)

Return whether or not this manager has reached a “completed” state, i.e. SimulationManager.run() should halt.

This is the one hook which is not subject to the nesting rules of hooks. You should not call simgr.complete, you should make your own decision and return True or False. Each of the techniques’ completion checkers will be called and the final result will be compted with simgr.completion_mode.

Parameters:: simgr (angr.SimulationManager)

class angr.KnowledgeBase

Bases: object

Represents a “model” of knowledge about an artifact.

Contains things like a CFG, data references, etc.

functions: FunctionManager

variables: VariableManager

defs: KeyDefinitionManager

cfgs: CFGManager

types: TypesStore

propagations: PropagationManager

xrefs: XRefManager

decompilations: StructuredCodeManager

obfuscations: Obfuscations

rtdb: RuntimeDb

__init__(project, obj=None, name=None)

property callgraph

property unresolved_indirect_jumps

property resolved_indirect_jumps

has_plugin(name)

get_plugin(name)

register_plugin(name, plugin)

release_plugin(name)

get_knowledge(requested_plugin_cls)

Type inference safe method to request a knowledge base plugin Explicitly passing the type of the requested plugin achieves two things: 1. Every location using this plugin can be easily found with an IDE by searching explicit references to the type 2. Basic type inference can deduce the result type and properly type check usages of it

If there isn’t already an instance of this class None will be returned to make it clear to the caller that there is no existing knowledge of this type yet. The code that initially creates this knowledge should use the register_plugin method to register the initial knowledge state :type requested_plugin_cls: type[TypeVar(K, bound= KnowledgeBasePlugin)] :param requested_plugin_cls:

Return type:: Optional[TypeVar(K, bound= KnowledgeBasePlugin)]
Returns:: Instance of the requested plugin class or null if it is not a known plugin
Parameters:: requested_plugin_cls (type[K])

request_knowledge(requested_plugin_cls)

Return type:: TypeVar(K, bound= KnowledgeBasePlugin)
Parameters:: requested_plugin_cls (type[K])

class angr.LLMClient

Bases: object

A client for interacting with LLMs via pydantic-ai. Used by the decompiler to suggest improved variable names, function names, and types.

__init__(model, api_key=None, api_base=None, max_tokens=4096, temperature=0.0)

Parameters:

model (str)
api_key (str | None)
api_base (str | None)
max_tokens (int)
temperature (float)

infer_provider(provider)

Infer the provider from the provider name.

Return type:: Provider[Any]
Parameters:: provider (str)

classmethod from_env()

Create an LLMClient from environment variables.

Uses ANGR_LLM_MODEL (required), ANGR_LLM_API_KEY (optional), and ANGR_LLM_API_BASE (optional). Returns None if ANGR_LLM_MODEL is not set.

Return type:: LLMClient | None

completion(messages, **kwargs)

Call the LLM with the given messages and return the response text.

Return type:: str
Parameters:: messages (list[dict[str, str]])

completion_structured(messages, output_type, raise_exc=False, **kwargs)

Call the LLM with the given messages and return a validated Pydantic model. Returns None if the call fails.

Parameters:

raise_exc (bool) – If True, exceptions are propagated to the caller instead of being caught.
messages (list[dict[str, str]])
output_type (type[T])

Return type:

Optional[TypeVar(T)]

completion_json(messages, raise_exc=False, **kwargs)

Call the LLM and parse the response as JSON. Strips markdown code fences if present. Returns None on parse failure. Kept for backwards compatibility; prefer completion_structured().

Parameters:

raise_exc (bool) – If True, exceptions are propagated to the caller instead of being caught.
messages (list[dict[str, str]])

Return type:

dict | None

class angr.PTChunk

Bases: Chunk

A chunk, inspired by the implementation of chunks in ptmalloc. Provides a representation of a chunk via a view into the memory plugin. For the chunk definitions and docs that this was loosely based off of, see glibc malloc/malloc.c, line 1033, as of commit 5a580643111ef6081be7b4c7bd1997a5447c903f. Alternatively, take the following link. https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=67cdfd0ad2f003964cd0f7dfe3bcd85ca98528a7;hb=5a580643111ef6081be7b4c7bd1997a5447c903f#l1033

Variables:

base – the location of the base of the chunk in memory
state – the program state that the chunk is resident in
heap – the heap plugin that the chunk is managed by

__init__(base, sim_state, heap=None)

set_size(size, is_free=None)

Use this to set the size on a chunk. When the chunk is new (such as when a free chunk is shrunk to form an allocated chunk and a remainder free chunk) it is recommended that the is_free hint be used since setting the size depends on the chunk’s freeness, and vice versa.

Parameters:

size – size of the chunk
is_free – boolean indicating the chunk’s freeness

set_prev_freeness(is_free)

Sets (or unsets) the flag controlling whether the previous chunk is free.

Parameters:: is_free – if True, sets the previous chunk to be free; if False, sets it to be allocated

is_prev_free()

Returns a concrete state of the flag indicating whether the previous chunk is free or not. Issues a warning if that flag is symbolic and has multiple solutions, and then assumes that the previous chunk is free.

Returns:: True if the previous chunk is free; False otherwise

prev_size(): Returns the size of the previous chunk, masking off what would be the flag bits if it were in the actual size field. Performs NO CHECKING to determine whether the previous chunk size is valid (for example, when the previous chunk is not free, its size cannot be determined).

next_chunk()

Returns the chunk immediately following (and adjacent to) this one, if it exists.

Returns:: The following chunk, or None if applicable

prev_chunk()

Returns the chunk immediately prior (and adjacent) to this one, if that chunk is free. If the prior chunk is not free, then its base cannot be located and this method raises an error.

Returns:: If possible, the previous chunk; otherwise, raises an error

fwd_chunk()

Returns the chunk following this chunk in the list of free chunks. If this chunk is not free, then it resides in no such list and this method raises an error.

Returns:: If possible, the forward chunk; otherwise, raises an error

bck_chunk()

Returns the chunk backward from this chunk in the list of free chunks. If this chunk is not free, then it resides in no such list and this method raises an error.

Returns:: If possible, the backward chunk; otherwise, raises an error

exception angr.PathUnreachableError: Bases: AngrPathError

class angr.PointerWrapper

Bases: object

__init__(value, buffer=False)

class angr.Project

Bases: object

This is the main class of the angr module. It is meant to contain a set of binaries and the relationships between them, and perform analyses on them.

Parameters:

thing – The path to the main executable object to analyze, or a CLE Loader object.
default_analysis_mode – The mode of analysis to use by default. Defaults to ‘symbolic’.
ignore_functions – A list of function names that, when imported from shared libraries, should never be stepped into in analysis (calls will return an unconstrained value).
use_sim_procedures – Whether to replace resolved dependencies for which simprocedures are available with said simprocedures.
exclude_sim_procedures_func – A function that, when passed a function name, returns whether or not to wrap it with a simprocedure.
exclude_sim_procedures_list – A list of functions to not wrap with simprocedures.
arch – The target architecture (auto-detected otherwise).
simos – a SimOS class to use for this project.
engine – The SimEngine class to use for this project.
translation_cache (bool) – If True, cache translated basic blocks rather than re-translating them.
selfmodifying_code (bool) – Whether we aggressively support self-modifying code. When enabled, emulation will try to read code from the current state instead of the original memory, regardless of the current memory protections.
store_function – A function that defines how the Project should be stored. Default to pickling.
load_function – A function that defines how the Project should be loaded. Default to unpickling.
analyses_preset (angr.misc.PluginPreset) – The plugin preset for the analyses provider (i.e. Analyses instance).

Any additional keyword arguments passed will be passed onto cle.Loader.

Variables:

analyses – The available analyses.
entry – The program entrypoint.
factory – Provides access to important analysis elements such as path groups and symbolic execution results.
filename – The filename of the executable.
loader – The program loader.
storage – Dictionary of things that should be loaded/stored with the Project.

__init__(thing, default_analysis_mode=None, ignore_functions=None, use_sim_procedures=True, exclude_sim_procedures_func=None, exclude_sim_procedures_list=(), arch=None, simos=None, engine=None, load_options=None, translation_cache=True, selfmodifying_code=False, support_selfmodifying_code=None, store_function=None, load_function=None, analyses_preset=None, concrete_target=None, eager_ifunc_resolution=None, cache_limits=None, rustc_version=None, rustc_optimization_level=None, **kwargs)

Parameters:

load_options (dict[str, Any] | None)
selfmodifying_code (bool)
support_selfmodifying_code (bool | None)
cache_limits (dict[str, int | None] | None)

arch: Arch

property llm_client: The LLM client for this project. Lazy-initialized from environment variables on first access. Set manually via project.llm_client = LLMClient(...) or configure via environment variables ANGR_LLM_MODEL, ANGR_LLM_API_KEY, ANGR_LLM_API_BASE.

property kb

get_kb(name)

property analyses: AnalysesHubWithDefault

hook(addr, hook=None, length=0, kwargs=None, replace=False)

Hook a section of code with a custom function. This is used internally to provide symbolic summaries of library functions, and can be used to instrument execution or to modify control flow.

When hook is not specified, it returns a function decorator that allows easy hooking. Usage:

# Assuming proj is an instance of angr.Project, we will add a custom hook at the entry
# point of the project.
@proj.hook(proj.entry)
def my_hook(state):
    print("Welcome to execution!")

Parameters:

addr – The address to hook.
hook – A angr.project.Hook describing a procedure to run at the given address. You may also pass in a SimProcedure class or a function directly and it will be wrapped in a Hook object for you.
length – If you provide a function for the hook, this is the number of bytes that will be skipped by executing the hook by default.
kwargs – If you provide a SimProcedure for the hook, these are the keyword arguments that will be passed to the procedure’s run method eventually.
replace (bool | None) – Control the behavior on finding that the address is already hooked. If true, silently replace the hook. If false (default), warn and do not replace the hook. If none, warn and replace the hook.

is_hooked(addr)

Returns True if addr is hooked.

Parameters:: addr – An address.
Return type:: bool
Returns:: True if addr is hooked, False otherwise.

hooked_by(addr)

Returns the current hook for addr.

Parameters:: addr – An address.
Return type:: SimProcedure | None
Returns:: None if the address is not hooked.

unhook(addr)

Remove a hook.

Parameters:: addr – The address of the hook.

hook_symbol(symbol_name, simproc, kwargs=None, replace=None)

Resolve a dependency in a binary. Looks up the address of the given symbol, and then hooks that address. If the symbol was not available in the loaded libraries, this address may be provided by the CLE externs object.

Additionally, if instead of a symbol name you provide an address, some secret functionality will kick in and you will probably just hook that address, UNLESS you’re on powerpc64 ABIv1 or some yet-unknown scary ABI that has its function pointers point to something other than the actual functions, in which case it’ll do the right thing.

Parameters:

symbol_name – The name of the dependency to resolve.
simproc – The SimProcedure instance (or function) with which to hook the symbol
kwargs – If you provide a SimProcedure for the hook, these are the keyword arguments that will be passed to the procedure’s run method eventually.
replace (bool | None) – Control the behavior on finding that the address is already hooked. If true, silently replace the hook. If false, warn and do not replace the hook. If none (default), warn and replace the hook.

Returns:

The address of the new symbol.

Return type:

int

symbol_hooked_by(symbol_name)

Return the SimProcedure, if it exists, for the given symbol name.

Parameters:: symbol_name (str) – Name of the symbol.
Return type:: SimProcedure | None
Returns:: None if the address is not hooked.

is_symbol_hooked(symbol_name)

Check if a symbol is already hooked.

Parameters:: symbol_name (str) – Name of the symbol.
Returns:: True if the symbol can be resolved and is hooked, False otherwise.
Return type:: bool

unhook_symbol(symbol_name): Remove the hook on a symbol. This function will fail if the symbol is provided by the extern object, as that would result in a state where analysis would be unable to cope with a call to this symbol.

rehook_symbol(new_address, symbol_name, stubs_on_sync): Move the hook for a symbol to a specific address :type new_address: :param new_address: the new address that will trigger the SimProc execution :type symbol_name: :param symbol_name: the name of the symbol (f.i. strcmp ) :return: None

execute(*args, **kwargs)

This function is a symbolic execution helper in the simple style supported by triton and manticore. It designed to be run after setting up hooks (see Project.hook), in which the symbolic state can be checked.

This function can be run in three different ways:

When run with no parameters, this function begins symbolic execution from the entrypoint.

It can also be run with a “state” parameter specifying a SimState to begin symbolic execution from.

Finally, it can accept any arbitrary keyword arguments, which are all passed to project.factory.full_init_state.

If symbolic execution finishes, this function returns the resulting simulation manager.

terminate_execution(): Terminates a symbolic execution that was started with Project.execute().

languages()

Return type:: list[str]

property is_rust_binary: bool

get_function_cache_limit()

Get the cache limit for function-level caches.

Return type:: int | None
Returns:: The cache limit, or None for disabling the cache.

get_cfg_node_cache_limit()

Get the cache limit for CFG node caches.

Return type:: int | None
Returns:: The cache limit, or None to disable the cache.

get_cfg_edge_cache_limit()

Get the cache limit for CFG edge caches (adjacency data spilling).

Return type:: int | None
Returns:: The cache limit, or None to disable the cache.

class angr.Server

Bases: object

Server implements the analysis server with a series of control interfaces exposed.

Variables:

project – An instance of angr.Project.
spill_yard (str) – A directory to store spilled states.
db (str) – Path of the database that stores information about spilled states.
max_workers (int) – Maximum number of workers. Each worker starts a new process.
max_states (int) – Maximum number of active states for each worker.
staging_max (int) – Maximum number of inactive states that are kept into memory before spilled onto the disk and potentially be picked up by another worker.
bucketizer (bool) – Use the Bucketizer exploration strategy.
_worker_exit_callback – A method that will be called upon the exit of each worker.

__init__(project, spill_yard=None, db=None, max_workers=None, max_states=10, staging_max=10, bucketizer=True, recursion_limit=1000, worker_exit_callback=None, techniques=None, add_options=None, remove_options=None)

inc_active_workers()

dec_active_workers()

stop()

property active_workers

property stopped

on_worker_exit(worker_id, stashes)

run()

exception angr.SimAbstractMemoryError: Bases: SimMemoryError

exception angr.SimActionError: Bases: SimError

class angr.SimCC

Bases: object

A calling convention allows you to extract from a state the data passed from function to function by calls and returns. Most of the methods provided by SimCC that operate on a state assume that the program is just after a call but just before stack frame allocation, though this may be overridden with the stack_base parameter to each individual method.

This is the base class for all calling conventions.

__init__(arch)

Parameters:: arch (Arch) – The Archinfo arch for this CC

ARG_REGS: list[str] = []¶

FP_ARG_REGS: list[str] = []¶

STACKARG_SP_BUFF = 0¶

STACKARG_SP_DIFF = 0¶

CALLER_SAVED_REGS: list[str] = []¶

RETURN_ADDR: SimFunctionArgument | None = None¶

RETURN_VAL: SimFunctionArgument | None = None¶

OVERFLOW_RETURN_VAL: SimFunctionArgument | None = None¶

FP_RETURN_VAL: SimFunctionArgument | None = None¶

ARCH: type[Arch] | None = None¶

EXTRA_ARCHES: tuple[type[Arch], ...] = ()¶

CALLEE_CLEANUP = False¶

STACK_ALIGNMENT = 1¶

property int_args

Iterate through all the possible arg positions that can only be used to store integer or pointer values.

Returns an iterator of SimFunctionArguments

property memory_args

Iterate through all the possible arg positions that can be used to store any kind of argument.

Returns an iterator of SimFunctionArguments

property fp_args

Iterate through all the possible arg positions that can only be used to store floating point values.

Returns an iterator of SimFunctionArguments

is_fp_arg(arg)

This should take a SimFunctionArgument instance and return whether or not that argument is a floating-point argument.

Returns True for MUST be a floating point arg,: False for MUST NOT be a floating point arg, None for when it can be either.

class ArgSession

Bases: object

A class to keep track of the state accumulated in laying parameters out into memory

both_iter

cc

fp_iter

int_iter

__init__(cc)

getstate()

setstate(state)

arg_session(ret_ty)

Return an arg session.

A session provides the control interface necessary to describe how integral and floating-point arguments are laid out into memory. The default behavior is that there are a finite list of int-only and fp-only argument slots, and an infinite number of generic slots, and when an argument of a given type is requested, the most slot available is used. If you need different behavior, subclass ArgSession.

You need to provide the return type of the function in order to kick off an arg layout session.

Return type:: ArgSession
Parameters:: ret_ty (SimType | None)

return_in_implicit_outparam(ty)

Return type:: bool

stack_space(args)

Parameters:: args – A list of SimFunctionArguments
Returns:: The number of bytes that should be allocated on the stack to store all these args, NOT INCLUDING the return address.

return_val(ty, perspective_returned=False): The location the return value is stored, based on its type.

property return_addr: The location the return address is stored.

next_arg(session, arg_type)

Return type:

SimFunctionArgument

Parameters:

session (ArgSession)
arg_type (SimType)

static is_fp_value(val)

static guess_prototype(args, prototype=None)

Come up with a plausible SimTypeFunction for the given args (as would be passed to e.g. setup_callsite).

You can pass a variadic function prototype in the base_type parameter and all its arguments will be used, only guessing types for the variadic arguments.

arg_locs(prototype)

Return type:: list[SimFunctionArgument]

get_args(state, prototype, stack_base=None)

set_return_val(state, val, ty, stack_base=None, perspective_returned=False)

setup_callsite(state, ret_addr, args, prototype, stack_base=None, alloc_base=None, grow_like_stack=True)

This function performs the actions of the caller getting ready to jump into a function.

Parameters:

state – The SimState to operate on
ret_addr – The address to return to when the called function finishes
args – The list of arguments that that the called function will see
prototype – The signature of the call you’re making. Should include variadic args concretely.
stack_base – An optional pointer to use as the top of the stack, circa the function entry point
alloc_base – An optional pointer to use as the place to put excess argument data
grow_like_stack – When allocating data at alloc_base, whether to allocate at decreasing addresses

The idea here is that you can provide almost any kind of python type in args and it’ll be translated to a binary format to be placed into simulated memory. Lists (representing arrays) must be entirely elements of the same type and size, while tuples (representing structs) can be elements of any type and size. If you’d like there to be a pointer to a given value, wrap the value in a PointerWrapper.

If stack_base is not provided, the current stack pointer will be used, and it will be updated. If alloc_base is not provided, the stack base will be used and grow_like_stack will implicitly be True.

grow_like_stack controls the behavior of allocating data at alloc_base. When data from args needs to be wrapped in a pointer, the pointer needs to point somewhere, so that data is dumped into memory at alloc_base. If you set alloc_base to point to somewhere other than the stack, set grow_like_stack to False so that sequential allocations happen at increasing addresses.

teardown_callsite(state, return_val=None, prototype=None, force_callee_cleanup=False)

This function performs the actions of the callee as it’s getting ready to return. It returns the address to return to.

Parameters:

state – The state to mutate
return_val – The value to return
prototype – The prototype of the given function
force_callee_cleanup – If we should clean up the stack allocation for the arguments even if it’s not the callee’s job to do so

TODO: support the stack_base parameter from setup_callsite…? Does that make sense in this context? Maybe it could make sense by saying that you pass it in as something like the “saved base pointer” value?

static find_cc(arch, args, sp_delta, platform='Linux', unused_hint=None, extra_pop=None)

Pinpoint the best-fit calling convention and return the corresponding SimCC instance, or None if no fit is found.

Parameters:

arch (Arch) – An ArchX instance. Can be obtained from archinfo.
args (list[SimRegArg | SimStackArg]) – A list of arguments. It may be updated by the first matched calling convention to remove non-argument arguments.
sp_delta (int) – The change of stack pointer before and after the call is made.
extra_pop (int | None) – The number of bytes that are popped by the callee. This is used to distinguish between callee-cleanup and caller-cleanup conventions.
platform (str | None)
unused_hint (list[SimRegArg] | None)

Return type:

SimCC | None

Returns:

A calling convention instance, or None if none of the SimCC subclasses seems to fit the arguments provided.

classmethod arches()

Return type:: tuple[type[Arch], ...]

get_arg_info(state, prototype): This is just a simple wrapper that collects the information from various locations prototype is as passed to self.arg_locs and self.get_args :type angr.SimState state: :param angr.SimState state: The state to evaluate and extract the values from :return: A list of tuples, where the nth tuple is (type, name, location, value) of the nth argument

exception angr.SimCCError: Bases: SimError

exception angr.SimCCallError: Bases: SimExpressionError

exception angr.SimConcreteBreakpointError: Bases: AngrError

exception angr.SimConcreteMemoryError: Bases: AngrError

exception angr.SimConcreteRegisterError: Bases: AngrError

exception angr.SimEmptyCallStackError: Bases: SimError

exception angr.SimEngineError: Bases: SimError

exception angr.SimError

Bases: Exception

bbl_addr = None¶

stmt_idx = None¶

ins_addr = None¶

executed_instruction_count = None¶

guard = None¶

record_state(state)

exception angr.SimEventError: Bases: SimStateError

exception angr.SimException: Bases: SimError

exception angr.SimExpressionError: Bases: SimError

exception angr.SimFastMemoryError: Bases: SimMemoryError

exception angr.SimFastPathError: Bases: SimEngineError

class angr.SimFile

Bases: SimFileBase, DefaultMemory

The normal SimFile is meant to model files on disk. It subclasses SimSymbolicMemory so loads and stores to/from it are very simple.

Parameters:

name – The name of the file
content – Optional initial content for the file as a string or bitvector
size – Optional size of the file. If content is not specified, it defaults to zero
has_end – Whether the size boundary is treated as the end of the file or a frontier at which new content will be generated. If unspecified, will pick its value based on options.FILES_HAVE_EOF. Another caveat is that if the size is also unspecified this value will default to False.
seekable – Optional bool indicating whether seek operations on this file should succeed, default True.
writable – Whether writing to this file is allowed
concrete – Whether or not this file contains mostly concrete data. Will be used by some SimProcedures to choose how to handle variable-length operations like fgets.

Variables:

has_end – Whether this file has an EOF

__init__(name=None, content=None, size=None, has_end=None, seekable=True, writable=True, ident=None, concrete=None, **kwargs)

property category

reg, mem, or file.

Type:: Return the category of this SimMemory instance. It can be one of the three following categories

property size: The number of data bytes stored by the file at present. May be a symbolic value.

concretize(**kwargs): Return a concretization of the contents of the file, as a flat bytestring.

class angr.SimFileBase

Bases: SimStatePlugin

SimFiles are the storage mechanisms used by SimFileDescriptors.

Different types of SimFiles can have drastically different interfaces, and as a result there’s not much that can be specified on this base class. All the read and write methods take a pos argument, which may have different semantics per-class. 0 will always be a valid position to use, though, and the next position you should use is part of the return tuple.

Some simfiles are “streams”, meaning that the position that reads come from is determined not by the position you pass in (it will in fact be ignored), but by an internal variable. This is stored as .pos if you care to read it. Don’t write to it. The same lack-of-semantics applies to this field as well.

Variables:

name – The name of the file. Purely for cosmetic purposes
ident – The identifier of the file, typically autogenerated from the name and a nonce. Purely for cosmetic purposes, but does appear in symbolic values autogenerated in the file.
seekable – Bool indicating whether seek operations on this file should succeed. If this is True, then pos must be a number of bytes from the start of the file.
writable – Bool indicating whether writing to this file is allowed.
pos – If the file is a stream, this will be the current position. Otherwise, None.
concrete – Whether or not this file contains mostly concrete data. Will be used by some SimProcedures to choose how to handle variable-length operations like fgets.
file_exists – Set to False, if file does not exists, set to a claripy Bool if unknown, default True.

seekable = False¶

pos = None¶

__init__(name=None, writable=True, ident=None, concrete=False, file_exists=True, **kwargs)

static make_ident(name)

concretize(**kwargs): Return a concretization of the contents of the file. The type of the return value of this method will vary depending on which kind of SimFile you’re using.

read(pos, size, **kwargs)

Read some data from the file.

Parameters:

pos – The offset in the file to read from.
size – The size to read. May be symbolic.

Returns:

A tuple of the data read (a bitvector of the length that is the maximum length of the read), the actual size of the read, and the new file position pointer.

write(pos, data, size=None, **kwargs)

Write some data to the file.

Parameters:

pos – The offset in the file to write to. May be ignored if the file is a stream or device.
data – The data to write as a bitvector
size – The optional size of the data to write. If not provided will default to the length of the data. Must be constrained to less than or equal to the size of the data.

Returns:

The new file position pointer.

property size: The number of data bytes stored by the file at present. May be a symbolic value.

class angr.SimFileDescriptor

Bases: SimFileDescriptorBase

A simple file descriptor forwarding reads and writes to a SimFile. Contains information about the current opened state of the file, such as the flags or (if relevant) the current position.

Variables:

file – The SimFile described to by this descriptor
flags – The mode that the file descriptor was opened with, a bitfield of flags

__init__(simfile, flags=0)

concretize(**kwargs): Return a concretization of the underlying file. Returns whatever format is preferred by the file.

property file_exists: This should be True in most cases. Only if we opened an fd of unknown existence, ALL_FILES_EXIST is False and ANY_FILE_MIGHT_EXIST is True, this is a symbolic boolean.

property read_storage: Return the SimFile backing reads from this fd

property write_storage: Return the SimFile backing writes to this fd

property read_pos

Return the current position of the read file pointer.

If the underlying read file is a stream, this will return the position of the stream. Otherwise, will return the position of the file descriptor in the file.

property write_pos

Return the current position of the read file pointer.

If the underlying read file is a stream, this will return the position of the stream. Otherwise, will return the position of the file descriptor in the file.

class angr.SimFileDescriptorDuplex

Bases: SimFileDescriptorBase

A file descriptor that refers to two file storage mechanisms, one to read from and one to write to. As a result, operations like seek, eof, etc no longer make sense.

Parameters:

read_file – The SimFile to read from
write_file – The SimFile to write to

__init__(read_file, write_file)

concretize(**kwargs): Return a concretization of the underlying files, as a tuple of (read file, write file).

property read_storage: Return the SimFile backing reads from this fd

property write_storage: Return the SimFile backing writes to this fd

property read_pos

Return the current position of the read file pointer.

If the underlying read file is a stream, this will return the position of the stream. Otherwise, will return the position of the file descriptor in the file.

property write_pos

Return the current position of the read file pointer.

If the underlying read file is a stream, this will return the position of the stream. Otherwise, will return the position of the file descriptor in the file.

exception angr.SimFileError: Bases: SimMemoryError, SimFilesystemError

class angr.SimFileStream

Bases: SimFile

A specialized SimFile that uses a flat memory backing, but functions as a stream, tracking its position internally.

The pos argument to the read and write methods will be ignored, and will return None. Instead, there is an attribute pos on the file itself, which will give you what you want.

Parameters:

name – The name of the file, for cosmetic purposes
pos – The initial position of the file, default zero
kwargs – Any other keyword arguments will go on to the SimFile constructor.

Variables:

pos – The current position in the file.

__init__(name=None, content=None, pos=0, **kwargs)

exception angr.SimFilesystemError: Bases: SimError

class angr.SimHeapBrk

Bases: SimHeapBase

SimHeapBrk represents a trivial heap implementation based on the Unix brk system call. This type of heap stores virtually no metadata, so it is up to the user to determine when it is safe to release memory. This also means that it does not properly support standard heap operations like realloc.

This heap implementation is a holdover from before any more proper implementations were modelled. At the time, various libc (or win32) SimProcedures handled the heap in the same way that this plugin does now. To make future heap implementations plug-and-playable, they should implement the necessary logic themselves, and dependent SimProcedures should invoke a method by the same name as theirs (prepended with an underscore) upon the heap plugin. Depending on the heap implementation, if the method is not supported, an error should be raised.

Out of consideration for the original way the heap was handled, this plugin implements functionality for all relevant SimProcedures (even those that would not normally be supported together in a single heap implementation).

Variables:: heap_location – the address of the top of the heap, bounding the allocations made starting from heap_base

__init__(heap_base=None, heap_size=None)

allocate(sim_size)

The actual allocation primitive for this heap implementation. Increases the position of the break to allocate space. Has no guards against the heap growing too large.

Parameters:: sim_size – a size specifying how much to increase the break pointer by
Returns:: a pointer to the previous break position, above which there is now allocated space

release(sim_size)

The memory release primitive for this heap implementation. Decreases the position of the break to deallocate space. Guards against releasing beyond the initial heap base.

Parameters:: sim_size – a size specifying how much to decrease the break pointer by (may be symbolic or not)

exception angr.SimHeapError: Bases: SimStateError

class angr.SimHeapPTMalloc

Bases: SimHeapFreelist

A freelist-style heap implementation inspired by ptmalloc. The chunks used by this heap contain heap metadata in addition to user data. While the real-world ptmalloc is implemented using multiple lists of free chunks (corresponding to their different sizes), this more basic model uses a single list of chunks and searches for free chunks using a first-fit algorithm.

NOTE: The plugin must be registered using register_plugin with name heap in order to function properly.

Variables:

heap_base – the address of the base of the heap in memory
heap_size – the total size of the main memory region managed by the heap in memory
mmap_base – the address of the region from which large mmap allocations will be made
free_head_chunk – the head of the linked list of free chunks in the heap

__init__(heap_base=None, heap_size=None)

chunk_from_mem(ptr)

Given a pointer to a user payload, return the base of the chunk associated with that payload (i.e. the chunk pointer). Returns None if ptr is null.

Parameters:: ptr – a pointer to the base of a user payload in the heap
Returns:: a pointer to the base of the associated heap chunk, or None if ptr is null

class angr.SimHostFilesystem

Bases: SimConcreteFilesystem

Simulated mount that makes some piece from the host filesystem available to the guest.

Parameters:

host_path (str) – The path on the host to mount
pathsep (str) – The host path separator character, default os.path.sep

__init__(host_path=None, **kwargs)

exception angr.SimIRSBError: Bases: SimEngineError

exception angr.SimIRSBNoDecodeError: Bases: SimIRSBError

exception angr.SimMemoryAddressError: Bases: SimMemoryError

exception angr.SimMemoryError: Bases: SimStateError

exception angr.SimMemoryLimitError: Bases: SimMemoryError

exception angr.SimMemoryMissingError: Bases: SimMemoryError

exception angr.SimMergeError: Bases: SimStateError

exception angr.SimMissingTempError: Bases: SimValueError, IndexError

class angr.SimMount

Bases: SimStatePlugin

This is the base class for “mount points” in angr’s simulated filesystem. Subclass this class and give it to the filesystem to intercept all file creations and opens below the mountpoint. Since this a SimStatePlugin you may also want to implement set_state, copy, merge, etc.

get(path_elements)

Implement this function to instrument file lookups.

Parameters:: path_elements – A list of path elements traversing from the mountpoint to the file
Returns:: A SimFile, or None

insert(path_elements, simfile)

Implement this function to instrument file creation.

Parameters:

path_elements – A list of path elements traversing from the mountpoint to the file
simfile – The file to insert

Returns:

A bool indicating whether the insert occurred

delete(path_elements)

Implement this function to instrument file deletion.

Parameters:: path_elements – A list of path elements traversing from the mountpoint to the file
Returns:: A bool indicating whether the delete occurred

lookup(sim_file)

Look up the path of a SimFile in the mountpoint

Parameters:: sim_file – A SimFile object needs to be looked up
Returns:: A string representing the path of the file in the mountpoint Or None if the SimFile does not exist in the mountpoint

class angr.SimOS

Bases: object

A class describing OS/arch-level configuration.

__init__(project, name=None)

Parameters:

project (Project)
name (str | None)

name: str | None

configure_project(): Configure the project to set up global settings (like SimProcedures).

state_blank(addr=None, initial_prefix=None, brk=None, stack_end=None, stack_size=8388608, stdin=None, thread_idx=None, permissions_backer=None, **kwargs)

Initialize a blank state.

All parameters are optional.

Parameters:

addr – The execution start address.
initial_prefix
stack_end – The end of the stack (i.e., the byte after the last valid stack address).
stack_size – The number of bytes to allocate for stack space
brk – The address of the process’ break.

Returns:

The initialized SimState.

Any additional arguments will be passed to the SimState constructor

state_entry(**kwargs)

state_full_init(**kwargs)

state_call(addr, *args, **kwargs)

prepare_call_state(calling_state, initial_state=None, preserve_registers=(), preserve_memory=())

This function prepares a state that is executing a call instruction. If given an initial_state, it copies over all of the critical registers to it from the calling_state. Otherwise, it prepares the calling_state for action.

This is mostly used to create minimalistic for CFG generation. Some ABIs, such as MIPS PIE and x86 PIE, require certain information to be maintained in certain registers. For example, for PIE MIPS, this function transfer t9, gp, and ra to the new state.

prepare_function_symbol(symbol_name, basic_addr=None)

Prepare the address space with the data necessary to perform relocations pointing to the given symbol

Returns a 2-tuple. The first item is the address of the function code, the second is the address of the relocation target.

handle_exception(successors, engine, exception)

Perform exception handling. This method will be called when, during execution, a SimException is thrown. Currently, this can only indicate a segfault, but in the future it could indicate any unexpected exceptional behavior that can’t be handled by ordinary control flow.

The method may mutate the provided SimSuccessors object in any way it likes, or re-raise the exception.

Parameters:

successors – The SimSuccessors object currently being executed on
engine – The engine that was processing this step
exception – The actual exception object

syscall(state, allow_unsupported=True)

Return type:

SimProcedure | None

Parameters:

state (SimState)
allow_unsupported (bool)

syscall_abi(state)

Return type:: str | None
Parameters:: state (SimState)

syscall_cc(state)

Return type:: SimCCSyscall | None
Parameters:: state (SimState)

is_syscall_addr(addr)

Return type:: bool

syscall_from_addr(addr, allow_unsupported=True)

Return type:: SimProcedure | None

syscall_from_number(number, allow_unsupported=True, abi=None)

Return type:: SimProcedure | None

setup_gdt(state, gdt)

Write the GlobalDescriptorTable object in the current state memory

Parameters:

state – state in which to write the GDT
gdt – GlobalDescriptorTable object

Returns:

generate_gdt(fs, gs, fs_size=4294967295, gs_size=4294967295)

Generate a GlobalDescriptorTable object and populate it using the value of the gs and fs register

Parameters:

fs – value of the fs segment register
gs – value of the gs segment register
fs_size – size of the fs segment register
gs_size – size of the gs segment register

Returns:

gdt a GlobalDescriptorTable object

exception angr.SimOperationError: Bases: SimError

class angr.SimPackets

Bases: SimFileBase

The SimPackets is meant to model inputs whose content is delivered a series of asynchronous chunks. The data is stored as a list of read or write results. For symbolic sizes, state.libc.max_packet_size will be respected. If the SHORT_READS option is enabled, reads will return a symbolic size constrained to be less than or equal to the requested size.

A SimPackets cannot be used for both reading and writing - for socket objects that can be both read and written to you should use a file descriptor to multiplex the read and write operations into two separate file storage mechanisms.

Parameters:

name – The name of the file, for cosmetic purposes
write_mode – Whether this file is opened in read or write mode. If this is unspecified it will be autodetected.
content – Some initial content to use for the file. Can be a list of bytestrings or a list of tuples of content ASTs and size ASTs.

Variables:

write_mode – See the eponymous parameter
content – A list of packets, as tuples of content ASTs and size ASTs.

__init__(name, write_mode=None, content=None, writable=True, ident=None, **kwargs)

property size: The number of data bytes stored by the file at present. May be a symbolic value.

concretize(**kwargs): Returns a list of the packets read or written as bytestrings.

read(pos, size, **kwargs)

Read a packet from the stream.

Parameters:

pos (int) – The packet number to read from the sequence of the stream. May be None to append to the stream.
size – The size to read. May be symbolic.
short_reads – Whether to replace the size with a symbolic value constrained to less than or equal to the original size. If unspecified, will be chosen based on the state option.

Returns:

A tuple of the data read (a bitvector of the length that is the maximum length of the read) and the actual size of the read.

write(pos, data, size=None, events=True, **kwargs)

Write a packet to the stream.

Parameters:

pos (int) – The packet number to write in the sequence of the stream. May be None to append to the stream.
data – The data to write, as a string or bitvector.
size – The optional size to write. May be symbolic; must be constrained to at most the size of data.

Returns:

The next packet to use after this

class angr.SimPacketsStream

Bases: SimPackets

A specialized SimPackets that tracks its position internally.

The pos argument to the read and write methods will be ignored, and will return None. Instead, there is an attribute pos on the file itself, which will give you what you want.

Parameters:

name – The name of the file, for cosmetic purposes
pos – The initial position of the file, default zero
kwargs – Any other keyword arguments will go on to the SimPackets constructor.

Variables:

pos – The current position in the file.

__init__(name, pos=0, **kwargs)

exception angr.SimPosixError: Bases: SimStateError

class angr.SimProcedure

Bases: object

A SimProcedure is a wonderful object which describes a procedure to run on a state.

You may subclass SimProcedure and override run(), replacing it with mutating self.state however you like, and then either returning a value or jumping away somehow.

A detailed discussion of programming SimProcedures may be found at https://docs.angr.io/extending-angr/simprocedures

Parameters:

arch – The architecture to use for this procedure
symbolic_return – Whether the procedure’s return value should be stubbed into a single symbolic variable constratined to the real return value
returns – Whether the procedure should return to its caller afterwards
is_syscall – Whether this procedure is a syscall
num_args – The number of arguments this procedure should extract
display_name – The name to use when displaying this procedure
library_name – The name of the library from which the function we’re emulating comes
cc (SimCC | None) – The SimCC to use for this procedure
sim_kwargs – Additional keyword arguments to be passed to run()
is_function – Whether this procedure emulates a function

The following class variables should be set if necessary when implementing a new SimProcedure:

Variables:

NO_RET – Set this to true if control flow will never return from this function
DYNAMIC_RET – Set this to true if whether the control flow returns from this function or not depends on the context (e.g., libc’s error() call). Must implement dynamic_returns() method.
ADDS_EXITS – Set this to true if you do any control flow other than returning
IS_FUNCTION – Does this procedure simulate a function? True by default
ARGS_MISMATCH – Does this procedure have a different list of arguments than what is provided in the function specification? This may happen when we manually extract arguments in the run() method of a SimProcedure. False by default.
local_vars – If you use self.call(), set this to a list of all the local variable names in your class. They will be restored on return.

The following instance variables are available when working with simprocedures from the inside or the outside:

Variables:

project – The associated angr project
arch – The associated architecture
addr – The linear address at which the procedure is executing
cc – The calling convention in use for engaging with the ABI
canonical – The canonical version of this SimProcedure. Procedures are deepcopied for many reasons, including to be able to store state related to a specific run and to be able to hook continuations.
kwargs – Any extra keyword arguments used to construct the procedure; will be passed to run
display_name – See the eponymous parameter
library_name – See the eponymous parameter
abi – If this is a syscall simprocedure, which ABI are we using to map the syscall numbers?
symbolic_return – See the eponymous parameter
syscall_number – If this procedure is a syscall, the number will be populated here.
returns – See eponymous parameter and NO_RET cvar
is_syscall – See eponymous parameter
is_function – See eponymous parameter and cvar
is_stub – See eponymous parameter
is_continuation – Whether this procedure is the original or a continuation resulting from self.call()
continuations – A mapping from name to each known continuation
run_func – The name of the function implementing the procedure. “run” by default, but different in continuations.
num_args – The number of arguments to the procedure. If not provided in the parameter, extracted from the definition of self.run

The following instance variables are only used in a copy of the procedure that is actually executing on a state:

Variables:

state – The SimState we should be mutating to perform the procedure
successors – The SimSuccessors associated with the current step
arguments – The function arguments, deserialized from the state
arg_session (None | ArgSession | int) – The ArgSession that was used to parse arguments out of the state, in case you need it for varargs
use_state_arguments – Whether we’re using arguments extracted from the state or manually provided
ret_to – The current return address
ret_expr – The computed return value
call_ret_expr – The return value from having used self.call()
inhibit_autoret – Whether we should avoid automatically adding an exit for returning once the run function ends
arg_session – The ArgSession object that was used to extract the runtime argument values. Useful for if you want to extract variadic args.

__init__(project=None, cc=None, prototype=None, symbolic_return=None, returns=None, is_syscall=False, is_stub=False, num_args=None, display_name=None, library_name=None, is_function=None, **kwargs)

Parameters:

project (Project | None)
cc (SimCC | None)
prototype (str | SimTypeFunction | None)

state: SimState

execute(state, successors=None, arguments=None, ret_to=None)

Call this method with a SimState and a SimSuccessors to execute the procedure.

Alternately, successors may be none if this is an inline call. In that case, you should provide arguments to the function.

make_continuation(name)

NO_RET = False¶

DYNAMIC_RET = False¶

ADDS_EXITS = False¶

IS_FUNCTION = True¶

ARGS_MISMATCH = False¶

ALT_NAMES = None¶

local_vars: tuple[str, ...] = ()¶

run(*args, **kwargs)

Implement the actual procedure here!

Return type:: Any

static_exits(blocks, **kwargs)

Get new exits by performing static analysis and heuristics. This is a fast and best-effort approach to get new exits for scenarios where states are not available (e.g. when building a fast CFG).

Parameters:: blocks (list) – Blocks that are executed before reaching this SimProcedure.
Returns:: A list of dicts. Each dict should contain the following entries: ‘address’, ‘jumpkind’, and ‘namehint’.
Return type:: list

dynamic_returns(blocks, **kwargs)

Determines if a call to this function returns or not by performing static analysis and heuristics.

Parameters:: blocks – Blocks that are executed before reaching this SimProcedure.
Return type:: bool
Returns:: True if the call returns, False otherwise.

property should_add_successors

set_args(args)

va_arg(ty, index=None)

inline_call(procedure, *arguments, **kwargs)

Call another SimProcedure in-line to retrieve its return value. Returns an instance of the procedure with the ret_expr property set.

Parameters:

procedure – The class of the procedure to execute
arguments – Any additional positional args will be used as arguments to the procedure call
sim_kwargs – Any additional keyword args will be passed as sim_kwargs to the procedure constructor

fix_prototype_returnty(ret_size)

ret(expr=None): Add an exit representing a return from this function. If this is not an inline call, grab a return address from the state and jump to it. If this is not an inline call, set a return expression with the calling convention.

call(addr, args, continue_at, cc=None, prototype=None, jumpkind='Ijk_Call')

Add an exit representing calling another function via pointer.

Parameters:

addr – The address of the function to call
args – The list of arguments to call the function with
continue_at – Later, when the called function returns, execution of the current procedure will continue in the named method.
cc – Optional: use this calling convention for calling the new function. Default is to use the current convention.
prototype – Optional: The prototype to use for the call. Will default to all-ints.

jump(addr, jumpkind='Ijk_Boring'): Add an exit representing jumping to an address.

exit(exit_code): Add an exit representing terminating the program.

property is_java

property argument_types

property return_type

exception angr.SimProcedureArgumentError: Bases: SimProcedureError

exception angr.SimProcedureError: Bases: SimEngineError

exception angr.SimRegionMapError: Bases: SimMemoryError

exception angr.SimReliftException: Bases: SimEngineError

angr.SimSegfaultError: alias of SimSegfaultException

exception angr.SimSegfaultException: Bases: SimException, SimMemoryError

exception angr.SimShadowStackError: Bases: SimProcedureError

exception angr.SimSlicerError: Bases: SimError

exception angr.SimSolverError: Bases: SimError

exception angr.SimSolverModeError: Bases: SimSolverError

exception angr.SimSolverOptionError: Bases: SimSolverError

class angr.SimState

Bases: PluginHub[SimStatePlugin], Generic

The SimState represents the state of a program, including its memory, registers, and so forth.

Parameters:

project (Project | None) – The project instance.
arch (Arch | None) – The architecture of the state.

Variables:

regs – A convenient view of the state’s registers, where each register is a property
mem – A convenient view of the state’s memory, a angr.state_plugins.view.SimMemView
registers – The state’s register file as a flat memory region
memory – The state’s memory as a flat memory region
solver – The symbolic solver and variable manager for this state
inspect – The breakpoint manager, a angr.state_plugins.inspect.SimInspector
log – Information about the state’s history
scratch – Information about the current execution step
posix – MISNOMER: information about the operating system or environment model
fs – The current state of the simulated filesystem
libc – Information about the standard library we are emulating
cgc – Information about the cgc environment
uc_manager – Control of under-constrained symbolic execution
unicorn – Control of the Unicorn Engine

solver: SimSolver

posix: SimSystemPosix

registers: DefaultMemory

regs: SimRegNameView

memory: DefaultMemory

callstack: CallStack

mem: SimMemView

history: SimStateHistory

inspect: SimInspector

jni_references: SimStateJNIReferences

scratch: SimStateScratch

__init__(project=None, arch=None, plugins=None, mode=None, options=None, add_options=None, remove_options=None, special_memory_filler=None, os_name=None, plugin_preset='default', cle_memory_backer=None, dict_memory_backer=None, permissions_map=None, default_permissions=3, stack_perms=None, stack_end=None, stack_size=None, regioned_memory_cls=None, **kwargs)

Parameters:

project (Project | None)
arch (Arch | None)
plugins (dict[str, SimStatePlugin] | None)
mode (str | None)
options (set[str] | list[str] | SimStateOptions | None)
add_options (set[str] | None)
remove_options (set[str] | None)
special_memory_filler (Callable[[str, int, int, SimState], Any] | None)
os_name (str | None)
plugin_preset (str)
cle_memory_backer (Clemory | None)
dict_memory_backer (dict[int, bytes] | None)
permissions_map (dict[tuple[int, int], int] | None)
default_permissions (int)
stack_perms (int | None)
stack_end (int | None)
stack_size (int | None)

property plugins

property ip

Get the instruction pointer expression, trigger SimInspect breakpoints, and generate SimActions. Use _ip to not trigger breakpoints or generate actions.

Returns:: an expression

property addr: IPTypeConc

Get the concrete address of the instruction pointer, without triggering SimInspect breakpoints or generating SimActions. An integer is returned, or an exception is raised if the instruction pointer is symbolic.

Returns:: an int

property arch: Arch

property javavm_memory

In case of an JavaVM with JNI support, a state can store the memory plugin twice; one for the native and one for the java view of the state.

Returns:: The JavaVM view of the memory plugin.

property javavm_registers

In case of an JavaVM with JNI support, a state can store the registers plugin twice; one for the native and one for the java view of the state.

Returns:: The JavaVM view of the registers plugin.

simplify(*args): Simplify this state’s constraints.

add_constraints(*constraints)

Add some constraints to the state.

You may pass in any number of symbolic booleans as variadic positional arguments.

satisfiable(**kwargs): Whether the state’s constraints are satisfiable

downsize(): Clean up after the solver engine. Calling this when a state no longer needs to be solved on will reduce memory usage.

step(**kwargs)

Perform a step of symbolic execution using this state. Any arguments to AngrObjectFactory.successors can be passed to this.

Returns:: A SimSuccessors object categorizing the results of the step.

block(*args, **kwargs)

Represent the basic block at this state’s instruction pointer. Any arguments to AngrObjectFactory.block can ba passed to this.

Returns:: A Block object describing the basic block of code at this point.

copy(): Returns a copy of the state.

merge(*others, **kwargs)

Merges this state with the other states. Returns the merging result, merged state, and the merge flag.

Parameters:

states – the states to merge
merge_conditions – a tuple of the conditions under which each state holds
common_ancestor – a state that represents the common history between the states being merged. Usually it is only available when EFFICIENT_STATE_MERGING is enabled, otherwise weak-refed states might be dropped from state history instances.
plugin_whitelist – a list of plugin names that will be merged. If this option is given and is not None, any plugin that is not inside this list will not be merged, and will be created as a fresh instance in the new state.
common_ancestor_history – a SimStateHistory instance that represents the common history between the states being merged. This is to allow optimal state merging when EFFICIENT_STATE_MERGING is disabled.

Returns:

(merged state, merge flag, a bool indicating if any merging occurred)

widen(*others): Perform a widening between self and other states :type others: :param others: :return:

reg_concrete(*args, **kwargs): Returns the contents of a register but, if that register is symbolic, raises a SimValueError.

mem_concrete(*args, **kwargs): Returns the contents of a memory but, if the contents are symbolic, raises a SimValueError.

stack_push(thing): Push ‘thing’ to the stack, writing the thing to memory and adjusting the stack pointer.

stack_pop(): Pops from the stack and returns the popped thing. The length will be the architecture word size.

stack_read(offset, length, bp=False)

Reads length bytes, at an offset into the stack.

Parameters:

offset – The offset from the stack pointer.
length – The number of bytes to read.
bp – If True, offset from the BP instead of the SP. Default: False.

make_concrete_int(expr)

dbg_print_stack(depth=None, sp=None): Only used for debugging purposes. Return the current stack info in formatted string. If depth is None, the current stack frame (from sp to bp) will be printed out.

set_mode(mode)

property thumb

property with_condition

exception angr.SimStateError: Bases: SimError

exception angr.SimStateOptionsError: Bases: SimError

class angr.SimStatePlugin

Bases: object

This is a base class for SimState plugins. A SimState plugin will be copied along with the state when the state is branched. They are intended to be used for things such as tracking open files, tracking heap details, and providing storage and persistence for SimProcedures.

STRONGREF_STATE = False¶

__init__()

Return type:: None

state: SimState[Any, Any]

set_state(state)

Sets a new state (for example, if the state has been branched)

Return type:: None

set_strongref_state(state)

Return type:: None

static memo(f)

A decorator function you should apply to copy

Return type:: _CopyFunc[TypeVar(S_co)]
Parameters:: f (Callable[[Any, dict[int, Any]], S_co])

copy(_memo)

Should return a copy of the plugin without any state attached. Should check the memo first, and add itself to memo if it ends up making a new copy.

In order to simplify using the memo, you should annotate implementations of this function with SimStatePlugin.memo

The base implementation of this function constructs a new instance of the plugin’s class without calling its initializer. If you super-call down to it, make sure you instantiate all the fields in your copy method!

Parameters:

memo – A dictionary mapping object identifiers (id(obj)) to their copied instance. Use this to avoid infinite recursion and diverged copies.
_memo (dict[int, Any])

Return type:

SimStatePlugin

merge(others, merge_conditions, common_ancestor=None)

Should merge the state plugin with the provided others. This will be called by state.merge() after copying the target state, so this should mutate the current instance to merge with the others.

Note that when multiple instances of a single plugin object (for example, a file) are referenced in the state, it is important that merge only ever be called once. This should be solved by designating one of the plugin’s referees as the “real owner”, who should be the one to actually merge it. This technique doesn’t work to resolve the similar issue that arises during copying because merging doesn’t produce a new reference to insert.

There will be n others and n+1 merge conditions, since the first condition corresponds to self. To match elements up to conditions, say zip([self] + others, merge_conditions)

When implementing this, make sure that you “deepen” both others and common_ancestor before calling sub-elements’ merge methods, e.g.

self.foo.merge(
    [o.foo for o in others],
    merge_conditions,
    common_ancestor=common_ancestor.foo if common_ancestor is not None else None
)

During static analysis, merge_conditions can be None, in which case you should use state.solver.union(values). TODO: fish please make this less bullshit

There is a utility claripy.ite_cases which will help with constructing arbitrarily large merged ASTs. Use it like self.bar = claripy.ite_cases(zip(conditions[1:], [o.bar for o in others]), self.bar)

Parameters:

others – the other state plugins to merge with
merge_conditions – a symbolic condition for each of the plugins
common_ancestor – a common ancestor of this plugin and the others being merged

Returns:

True if the state plugins are actually merged.

Return type:

bool

widen(others)

The widening operation for plugins. Widening is a special kind of merging that produces a more general state from several more specific states. It is used only during intensive static analysis. The same behavior regarding copying and mutation from merge should be followed.

Parameters:: others (Iterable[SimStatePlugin]) – the other state plugins to widen with
Returns:: True if the state plugin is actually widened.
Return type:: bool

classmethod register_default(name, xtr=None)

Return type:

None

Parameters:

name (str)
xtr (type[SimStatePlugin] | str | None)

init_state()

Use this function to perform any initialization on the state at plugin-add time

Return type:: None

exception angr.SimStatementError: Bases: SimError

exception angr.SimSymbolicFilesystemError: Bases: SimFilesystemError

exception angr.SimTranslationError: Bases: SimEngineError

exception angr.SimUCManagerAllocationError: Bases: SimUCManagerError

exception angr.SimUCManagerError: Bases: SimError

exception angr.SimUnicornError: Bases: SimError

exception angr.SimUnicornSymbolic: Bases: SimError

exception angr.SimUnicornUnsupport: Bases: SimError

exception angr.SimUninitializedAccessError: Bases: SimExpressionError

exception angr.SimUnsatError: Bases: SimValueError

exception angr.SimUnsupportedError: Bases: SimError

exception angr.SimValueError: Bases: SimSolverError

exception angr.SimZeroDivisionException: Bases: SimException, SimOperationError

class angr.SimulationManager

Bases: object

The Simulation Manager is the future future.

Simulation managers allow you to wrangle multiple states in a slick way. States are organized into “stashes”, which you can step forward, filter, merge, and move around as you wish. This allows you to, for example, step two different stashes of states at different rates, then merge them together.

Stashes can be accessed as attributes (i.e. .active). A mulpyplexed stash can be retrieved by prepending the name with mp_, e.g. .mp_active. A single state from the stash can be retrieved by prepending the name with one_, e.g. .one_active.

Note that you shouldn’t usually be constructing SimulationManagers directly - there is a convenient shortcut for creating them in Project.factory: see angr.factory.AngrObjectFactory.

The most important methods you should look at are step, explore, and use_technique.

Parameters:

project (angr.project.Project) – A Project instance.
stashes – A dictionary to use as the stash store.
active_states – Active states to seed the “active” stash with.
hierarchy – A StateHierarchy object to use to track the relationships between states.
resilience – A set of errors to catch during stepping to put a state in the errore list. You may also provide the values False, None (default), or True to catch, respectively, no errors, all angr-specific errors, and a set of many common errors.
save_unsat – Set to True in order to introduce unsatisfiable states into the unsat stash instead of discarding them immediately.
auto_drop – A set of stash names which should be treated as garbage chutes.
completion_mode – A function describing how multiple exploration techniques with the complete hook set will interact. By default, the builtin function any.
techniques – A list of techniques that should be pre-set to use with this manager.
suggestions – Whether to automatically install the Suggestions exploration technique. Default True.

Variables:

errored – Not a stash, but a list of ErrorRecords. Whenever a step raises an exception that we catch, the state and some information about the error are placed in this list. You can adjust the list of caught exceptions with the resilience parameter.
stashes – All the stashes on this instance, as a dictionary.
completion_mode – A function describing how multiple exploration techniques with the complete hook set will interact. By default, the builtin function any.

ALL = '_ALL'¶

DROP = '_DROP'¶

__init__(project, active_states=None, stashes=None, hierarchy=None, resilience=None, save_unsat=False, auto_drop=None, errored=None, completion_mode=<built-in function any>, techniques=None, suggestions=True, **kwargs)

active: list[SimState]

stashed: list[SimState]

pruned: list[SimState]

unsat: list[SimState]

deadended: list[SimState]

unconstrained: list[SimState]

found: list[SimState]

one_active: SimState

one_stashed: SimState

one_pruned: SimState

one_unsat: SimState

one_deadended: SimState

one_unconstrained: SimState

one_found: SimState

property errored: list[ErrorRecord]

property stashes: defaultdict[str, list[SimState]]

mulpyplex(*stashes)

Mulpyplex across several stashes.

Parameters:: stashes – the stashes to mulpyplex
Returns:: a mulpyplexed list of states from the stashes in question, in the specified order

copy(deep=False)

Make a copy of this simulation manager. Pass deep=True to copy all the states in it as well.

If the current callstack includes hooked methods, the already-called methods will not be included in the copy.

use_technique(tech)

Use an exploration technique with this SimulationManager.

Techniques can be found in angr.exploration_techniques.

Parameters:: tech (ExplorationTechnique) – An ExplorationTechnique object that contains code to modify this SimulationManager’s behavior.
Returns:: The technique that was added, for convenience

remove_technique(tech)

Remove an exploration technique from a list of active techniques.

Parameters:: tech (ExplorationTechnique) – An ExplorationTechnique object.

explore(stash='active', n=None, find=None, avoid=None, find_stash='found', avoid_stash='avoid', cfg=None, num_find=1, avoid_priority=False, **kwargs)

Tick stash “stash” forward (up to “n” times or until “num_find” states are found), looking for condition “find”, avoiding condition “avoid”. Stores found states into “find_stash’ and avoided states into “avoid_stash”.

The “find” and “avoid” parameters may be any of:

An address to find
A set or list of addresses to find
A function that takes a state and returns whether or not it matches.

If an angr CFG is passed in as the “cfg” parameter and “find” is either a number or a list or a set, then any states which cannot possibly reach a success state without going through a failure state will be preemptively avoided.

run(stash='active', n=None, until=None, **kwargs)

Run until the SimulationManager has reached a completed state, according to the current exploration techniques. If no exploration techniques that define a completion state are being used, run until there is nothing left to run.

Parameters:

stash – Operate on this stash
n – Step at most this many times
until – If provided, should be a function that takes a SimulationManager and returns True or False. Stepping will terminate when it is True.

Returns:

The simulation manager, for chaining.

Return type:

SimulationManager

complete(): Returns whether or not this manager has reached a “completed” state.

step(stash='active', target_stash=None, n=None, selector_func=None, step_func=None, error_list=None, successor_func=None, until=None, filter_func=None, **run_args)

Step a stash of states forward and categorize the successors appropriately.

The parameters to this function allow you to control everything about the stepping and categorization process.

Parameters:

stash – The name of the stash to step (default: ‘active’)
target_stash – The name of the stash to put the results in (default: same as stash)
error_list – The list to put ErrorRecord objects in (default: self.errored)
selector_func – If provided, should be a function that takes a state and returns a boolean. If True, the state will be stepped. Otherwise, it will be kept as-is.
step_func – If provided, should be a function that takes a SimulationManager and returns a SimulationManager. Will be called with the SimulationManager at every step. Note that this function should not actually perform any stepping - it is meant to be a maintenance function called after each step.
successor_func – If provided, should be a function that takes a state and return its successors. Otherwise, project.factory.successors will be used.
filter_func – If provided, should be a function that takes a state and return the name of the stash, to which the state should be moved.
until – (DEPRECATED) If provided, should be a function that takes a SimulationManager and returns True or False. Stepping will terminate when it is True.
n – (DEPRECATED) The number of times to step (default: 1 if “until” is not provided)

Additionally, you can pass in any of the following keyword args for project.factory.successors:

Parameters:

jumpkind – The jumpkind of the previous exit
addr – An address to execute at instead of the state’s ip.
stmt_whitelist – A list of stmt indexes to which to confine execution.
last_stmt – A statement index at which to stop execution.
thumb – Whether the block should be lifted in ARM’s THUMB mode.
backup_state – A state to read bytes from instead of using project memory.
opt_level – The VEX optimization level to use.
insn_bytes – A string of bytes to use for the block instead of the project.
size – The maximum size of the block, in bytes.
num_inst – The maximum number of instructions.
traceflags – traceflags to be passed to VEX. Default: 0

Returns:

The simulation manager, for chaining.

Return type:

SimulationManager

step_state(state, successor_func=None, error_list=None, **run_args): Don’t use this function manually - it is meant to interface with exploration techniques.

filter(state, filter_func=None): Don’t use this function manually - it is meant to interface with exploration techniques.

selector(state, selector_func=None): Don’t use this function manually - it is meant to interface with exploration techniques.

successors(state, successor_func=None, **run_args): Don’t use this function manually - it is meant to interface with exploration techniques.

prune(filter_func=None, from_stash='active', to_stash='pruned')

Prune unsatisfiable states from a stash.

This function will move all unsatisfiable states in the given stash into a different stash.

Parameters:

filter_func – Only prune states that match this filter.
from_stash – Prune states from this stash. (default: ‘active’)
to_stash – Put pruned states in this stash. (default: ‘pruned’)

Returns:

The simulation manager, for chaining.

Return type:

SimulationManager

populate(stash, states)

Populate a stash with a collection of states.

Parameters:

stash – A stash to populate.
states – A list of states with which to populate the stash.

absorb(simgr): Collect all the states from simgr and put them in their corresponding stashes in this manager. This will not modify simgr.

move(from_stash, to_stash, filter_func=None)

Move states from one stash to another.

Parameters:

from_stash – Take matching states from this stash.
to_stash – Put matching states into this stash.
filter_func – Stash states that match this filter. Should be a function that takes a state and returns True or False. (default: stash all states)

Returns:

The simulation manager, for chaining.

Return type:

SimulationManager

stash(filter_func=None, from_stash='active', to_stash='stashed')

Stash some states. This is an alias for move(), with defaults for the stashes.

Parameters:

filter_func – Stash states that match this filter. Should be a function that takes a state and returns True or False. (default: stash all states)
from_stash – Take matching states from this stash. (default: ‘active’)
to_stash – Put matching states into this stash. (default: ‘stashed’)

Returns:

The simulation manager, for chaining.

Return type:

SimulationManager

unstash(filter_func=None, to_stash='active', from_stash='stashed')

Unstash some states. This is an alias for move(), with defaults for the stashes.

Parameters:

filter_func – Unstash states that match this filter. Should be a function that takes a state and returns True or False. (default: unstash all states)
from_stash – take matching states from this stash. (default: ‘stashed’)
to_stash – put matching states into this stash. (default: ‘active’)

Returns:

The simulation manager, for chaining.

Return type:

SimulationManager

drop(filter_func=None, stash='active')

Drops states from a stash. This is an alias for move(), with defaults for the stashes.

Parameters:

filter_func – Drop states that match this filter. Should be a function that takes a state and returns True or False. (default: drop all states)
stash – Drop matching states from this stash. (default: ‘active’)

Returns:

The simulation manager, for chaining.

Return type:

SimulationManager

apply(state_func=None, stash_func=None, stash='active', to_stash=None)

Applies a given function to a given stash.

Parameters:

state_func – A function to apply to every state. Should take a state and return a state. The returned state will take the place of the old state. If the function doesn’t return a state, the old state will be used. If the function returns a list of states, they will replace the original states.
stash_func – A function to apply to the whole stash. Should take a list of states and return a list of states. The resulting list will replace the stash. If both state_func and stash_func are provided state_func is applied first, then stash_func is applied on the results.
stash – A stash to work with.
to_stash – If specified, this stash will be used to store the resulting states instead.

Returns:

The simulation manager, for chaining.

Return type:

SimulationManager

split(stash_splitter=None, stash_ranker=None, state_ranker=None, limit=8, from_stash='active', to_stash='stashed')

Split a stash of states into two stashes depending on the specified options.

The stash from_stash will be split into two stashes depending on the other options passed in. If to_stash is provided, the second stash will be written there.

stash_splitter overrides stash_ranker, which in turn overrides state_ranker. If no functions are provided, the states are simply split according to the limit.

The sort done with state_ranker is ascending.

Parameters:

stash_splitter – A function that should take a list of states and return a tuple of two lists (the two resulting stashes).
stash_ranker – A function that should take a list of states and return a sorted list of states. This list will then be split according to “limit”.
state_ranker – An alternative to stash_splitter. States will be sorted with outputs of this function, which are to be used as a key. The first “limit” of them will be kept, the rest split off.
limit – For use with state_ranker. The number of states to keep. Default: 8
from_stash – The stash to split (default: ‘active’)
to_stash – The stash to write to (default: ‘stashed’)

Returns:

The simulation manager, for chaining.

Return type:

SimulationManager

merge(merge_func=None, merge_key=None, stash='active', prune=True)

Merge the states in a given stash.

Parameters:

stash – The stash (default: ‘active’)
merge_func – If provided, instead of using state.merge, call this function with the states as the argument. Should return the merged state.
merge_key – If provided, should be a function that takes a state and returns a key that will compare equal for all states that are allowed to be merged together, as a first approximation. By default: uses PC, callstack, and open file descriptors.
prune – Whether to prune the stash prior to merging it

Returns:

The simulation manager, for chaining.

Return type:

SimulationManager

exception angr.SimulationManagerError: Bases: AngrError

class angr.StateHierarchy

Bases: object

The state hierarchy holds weak references to SimStateHistory objects in a directed acyclic graph. It is useful for queries about a state’s ancestry, notably “what is the best ancestor state for a merge among these states” and “what is the most recent unsatisfiable state while using LAZY_SOLVES”

__init__()

get_ref(obj)

dead_ref(ref)

defer_cleanup()

add_state(s)

add_history(h)

simplify()

full_simplify()

lineage(h): Returns the lineage of histories leading up to h.

all_successors(h)

history_successors(h)

history_predecessors(h)

history_contains(h)

unreachable_state(state)

unreachable_history(h)

most_mergeable(states)

Find the “most mergeable” set of states from those provided.

Parameters:: states – a list of states
Returns:: a tuple of: (list of states to merge, those states’ common history, list of states to not merge yet)

exception angr.TracerEnvironmentError: Bases: AngrError

exception angr.UnsupportedCCallError: Bases: SimCCallError, SimUnsupportedError

exception angr.UnsupportedDirtyError: Bases: UnsupportedIRStmtError, SimUnsupportedError

exception angr.UnsupportedIRExprError: Bases: SimExpressionError, SimUnsupportedError

exception angr.UnsupportedIROpError: Bases: SimOperationError, SimUnsupportedError

exception angr.UnsupportedIRStmtError: Bases: SimStatementError, SimUnsupportedError

exception angr.UnsupportedNodeTypeError: Bases: AngrError, NotImplementedError

angr.UnsupportedSyscallError: alias of AngrUnsupportedSyscallError

angr.default_cc(arch, platform='Linux', language=None, syscall=False, default=None)

Return the default calling convention for a given architecture, platform, and language combination.

Parameters:

arch (str) – The architecture name.
platform (str | None) – The platform name (e.g., “Linux” or “Win32”).
language (str | None) – The programming language name (e.g., “go”).
syscall (bool) – Return syscall convention (True), or normal calling convention (False, default).
default (type[SimCC] | None) – The default calling convention to return if nothing fits.

Return type:

type[SimCC] | None

Returns:

A default calling convention class if we can find one for the architecture, platform, and language combination, or the default if nothing fits.

angr.load_shellcode(shellcode, arch, start_offset=0, load_address=0, thumb=False, **kwargs)

Load a new project based on a snippet of assembly or bytecode.

Parameters:

shellcode (bytes | str) – The data to load, as either a bytestring of instructions or a string of assembly text
arch – The name of the arch to use, or an archinfo class
start_offset – The offset into the data to start analysis (default 0)
load_address – The address to place the data in memory (default 0)
thumb – Whether this is ARM Thumb shellcode

angr.register_analysis(cls, name)

Submodules

`ail_callable`
`ailment`
`analyses`
`angrdb`
`annocfg`
`blade`
`block`
`callable`
`calling_conventions`
`code_location`
`codenode`
`concretization_strategies`
`distributed`	angr.distributed provides a simple implementation for conducting long-running symbolic-execution-based tasks.
`emulator`
`engines`
`errors`
`exploration_techniques`
`factory`
`flirt`
`keyed_region`
`knowledge_base`	Representing the artifacts of a project.
`knowledge_plugins`
`llm_client`
`llm_models`
`mcp`	angr MCP Server - Model Context Protocol interface for angr binary analysis.
`misc`
`procedures`
`project`
`protos`
`rust`
`rustylib`
`serializable`
`sim_manager`
`sim_options`
`sim_procedure`
`sim_state`
`sim_state_options`
`sim_type`
`sim_variable`
`simos`	Manage OS-level configuration.
`slicer`
`state_hierarchy`
`state_plugins`
`storage`
`tablespecs`
`utils`
`vaults`