text stringlengths 81 112k |
|---|
Determine if this SimIRSB has an indirect jump as its exit
def _is_indirect_jump(_, sim_successors):
"""
Determine if this SimIRSB has an indirect jump as its exit
"""
if sim_successors.artifacts['irsb_direct_next']:
# It's a direct jump
return False
de... |
Check if the specific address is in one of the executable ranges.
:param int address: The address
:return: True if it's in an executable range, False otherwise
def _is_address_executable(self, address):
"""
Check if the specific address is in one of the executable ranges.
:par... |
Get where a specific function is called.
:param function_address: Address of the target function
:return: A list of CFGNodes whose exits include a call/jump to the given function
def _get_callsites(self, function_address):
"""
Get where a specific function is calle... |
Get the possible (networkx) simple paths between two nodes or addresses
corresponding to nodes.
Input: addresses or node instances
Return: a list of lists of nodes representing paths.
def _get_nx_paths(self, begin, end):
"""
Get the possible (networkx) simple paths between two n... |
Perform a quasi-topological sort on an already constructed CFG graph (a networkx DiGraph)
:return: None
def _quasi_topological_sort(self):
"""
Perform a quasi-topological sort on an already constructed CFG graph (a networkx DiGraph)
:return: None
"""
# Clear the exist... |
Reset the state mode to the given mode, and apply the custom state options specified with this analysis.
:param state: The state to work with.
:param str mode: The state mode.
:return: None
def _reset_state_mode(self, state, mode):
"""
Reset the state mode to the giv... |
Mark a certain label as assigned (to an instruction or a block of data).
:param int addr: The address of the label.
:param angr.analyses.reassembler.Label label:
The label that is just assigned.
:return: None
def label_got(self, addr, label):
"""
Mark a... |
Try to classify an immediate as a pointer.
:param int imm: The immediate to test.
:param int operand_type: Operand type of this operand, can either be IMM or MEM.
:param str mnemonic: Mnemonic of the instruction that this operand belongs to.
:return: A tuple of (is code reference, is da... |
Get function name from the labels of the very first block.
:return: Function name if there is any, None otherwise
:rtype: string
def name(self):
"""
Get function name from the labels of the very first block.
:return: Function name if there is any, None otherwise
:rtype: ... |
If this function is a PLT entry or not.
:return: True if this function is a PLT entry, False otherwise
:rtype: bool
def is_plt(self):
"""
If this function is a PLT entry or not.
:return: True if this function is a PLT entry, False otherwise
:rtype: bool
"""
... |
Get the assembly manifest of the procedure.
:param comments:
:param symbolized:
:return: A list of tuples (address, basic block assembly), ordered by basic block addresses
:rtype: list
def assembly(self, comments=False, symbolized=True):
"""
Get the assembly manifest of... |
Get all instruction addresses in the binary.
:return: A list of sorted instruction addresses.
:rtype: list
def instruction_addresses(self):
"""
Get all instruction addresses in the binary.
:return: A list of sorted instruction addresses.
:rtype: list
"""
... |
Determines if we want to output the function label in assembly. We output the function label only when the
original instruction does not output the function label.
:return: True if we should output the function label, False otherwise.
:rtype: bool
def _output_function_label(self):
"""
... |
Reduce the size of this block
:param int new_size: The new size
:return: None
def shrink(self, new_size):
"""
Reduce the size of this block
:param int new_size: The new size
:return: None
"""
self.size = new_size
if self.sort == 'string':
... |
We believe this was a pointer and symbolized it before. Now we want to desymbolize it.
The following actions are performed:
- Reload content from memory
- Mark the sort as 'unknown'
:return: None
def desymbolize(self):
"""
We believe this was a pointer and symbolized i... |
Sometimes there exists a pointer that points to a few bytes before the beginning of a section, or a few bytes
after the beginning of the section. We take care of that here.
:param int addr: The address to check.
:return: A 2-tuple of (bool, the closest base address)
:rtype: tuple
def m... |
Sometimes there exists a pointer that points to a few bytes before the beginning of a section, or a few bytes
after the beginning of the section. We take care of that here.
:param int addr: The address to check.
:return: A 2-tuple of (bool, the closest base address)
:rtype: tuple
def m... |
Add a new label to the symbol manager.
:param str name: Name of the label.
:param int addr: Address of the label.
:return: None
def add_label(self, name, addr):
"""
Add a new label to the symbol manager.
:param str name: Name of the label.
:param int addr: Addr... |
Insert some assembly code at the specific address. There must be an instruction starting at that address.
:param int addr: Address of insertion
:param str asm_code: The assembly code to insert
:return: None
def insert_asm(self, addr, asm_code, before_label=False):
"""
Insert so... |
Add a new procedure with specific name and assembly code.
:param str name: The name of the new procedure.
:param str asm_code: The assembly code of the procedure
:return: None
def append_procedure(self, name, asm_code):
"""
Add a new procedure with specific name and assembly co... |
Append a new data entry into the binary with specific name, content, and size.
:param str name: Name of the data entry. Will be used as the label.
:param bytes initial_content: The initial content of the data entry.
:param int size: Size of the data entry.
:param bool readonly: If the d... |
Remove CGC attachments.
:return: True if CGC attachments are found and removed, False otherwise
:rtype: bool
def remove_cgc_attachments(self):
"""
Remove CGC attachments.
:return: True if CGC attachments are found and removed, False otherwise
:rtype: bool
"""
... |
Remove unnecessary functions and data
:return: None
def remove_unnecessary_stuff(self):
"""
Remove unnecessary functions and data
:return: None
"""
glibc_functions_blacklist = {
'_start',
'_init',
'_fini',
'__gmon_start_... |
Initialize the binary.
:return: None
def _initialize(self):
"""
Initialize the binary.
:return: None
"""
# figure out section alignments
for section in self.project.loader.main_object.sections:
in_segment = False
for segment in self.pro... |
Find sequences in binary data.
:param angr.analyses.CFG cfg: The control flow graph.
:param pyvex.IRSB irsb: The IRSB object.
:param int irsb_addr: Address of the block.
:param int stmt_idx: Statement ID.
:param int data_addr: Address of the data in memory.
:param int ma... |
Identifies the CGC package list associated with the CGC binary.
:param int data_addr: Address of the data in memory.
:param int data_size: Maximum size possible.
:return: A 2-tuple of data type and size.
:rtype: tuple
def _cgc_package_list_identifier(self, data_addr, data_size):
... |
Identifies the extended application (a PDF file) associated with the CGC binary.
:param angr.analyses.CFG cfg: The control flow graph.
:param pyvex.IRSB irsb: The IRSB object.
:param int irsb_addr: Address of the block.
:param int stmt_idx: Statement ID.
:param int data_addr: Ad... |
Return the maximum number of bytes until a potential pointer or a potential sequence is found.
:param angr.analyses.CFG cfg: The control flow graph.
:param pyvex.IRSB irsb: The IRSB object.
:param int irsb_addr: Address of the block.
:param int stmt_idx: Statement ID.
:param int... |
Test if there is any (suspicious) pointer decryption in the code.
:return: True if there is any pointer decryption, False otherwise.
:rtype: bool
def _has_integer_used_as_pointers(self):
"""
Test if there is any (suspicious) pointer decryption in the code.
:return: True if the... |
Load memory bytes from loader's memory backend.
:param int addr: The address to begin memory loading.
:param int size: Size in bytes.
:param data_type: Type of the data.
:param str endness: Endianness of this memory load.
:return: Data read out of the memory.
... |
Merge two abstract states.
For any node A whose dominance frontier that the current node (at the current program location) belongs to, we
create a phi variable V' for each variable V that is defined in A, and then replace all existence of V with V'
in the merged abstract state.
:param ... |
Scan through all statements and perform the following tasks:
- Find stack pointers and the VEX temporary variable storing stack pointers
- Selectively calculate VEX statements
- Track memory loading and mark stack and global variables accordingly
:param angr.Block block:
:return... |
Make a shallow copy of a directional graph and reverse the edges. This is a workaround to solve the issue that one
cannot easily make a shallow reversed copy of a graph in NetworkX 2, since networkx.reverse(copy=False) now returns
a GraphView, and GraphViews are always read-only.
:param networkx.DiGraph g:... |
Do a DFS traversal of the graph, and return with the back edges.
Note: This is just a naive recursive implementation, feel free to replace it.
I couldn't find anything in networkx to do this functionality. Although the
name suggest it, but `dfs_labeled_edges` is doing something different.
:param graph... |
Compute a dominance frontier based on the given post-dominator tree.
This implementation is based on figure 2 of paper An Efficient Method of Computing Static Single Assignment
Form by Ron Cytron, etc.
:param graph: The graph where we want to compute the dominance frontier.
:param domtree: The domin... |
Return the successors of a node in the graph.
This method can be overriden in case there are special requirements with the graph and the successors. For
example, when we are dealing with a control flow graph, we may not want to get the FakeRet successors.
:param graph: The graph.
:param... |
Find post-dominators for each node in the graph.
This implementation is based on paper A Fast Algorithm for Finding Dominators in a Flow Graph by Thomas
Lengauer and Robert E. Tarjan from Stanford University, ACM Transactions on Programming Languages and Systems,
Vol. 1, No. 1, July 1979
def _... |
A dumb and simple way to conveniently aggregate all loggers.
Adds attributes to this instance of each registered logger, replacing '.' with '_'
def load_all_loggers(self):
"""
A dumb and simple way to conveniently aggregate all loggers.
Adds attributes to this instance of each registe... |
Perform execution with a state.
:param state: The state with which to execute
:param procedure: An instance of a SimProcedure to run
:param ret_to: The address to return to when this procedure is finished
:param inline: This is an inline execution. Do not bother copyin... |
:return: Default value for array elements.
def get_default_value(self, state):
"""
:return: Default value for array elements.
"""
if self._default_value_generator:
return self._default_value_generator(state)
else:
return state.project.simos.get_default_va... |
Add a function `func` and all blocks of this function to the blanket.
def add_function(self, func):
"""
Add a function `func` and all blocks of this function to the blanket.
"""
for block in func.blocks:
self.add_obj(block.addr, block) |
The debugging representation of this CFBlanket.
:return: The debugging representation of this CFBlanket.
:rtype: str
def dbg_repr(self):
"""
The debugging representation of this CFBlanket.
:return: The debugging representation of this CFBlanket.
:rtype: s... |
Initialize CFBlanket from a CFG instance.
:param cfg: A CFG instance.
:return: None
def _from_cfg(self, cfg):
"""
Initialize CFBlanket from a CFG instance.
:param cfg: A CFG instance.
:return: None
"""
# Let's first add all functions first
... |
Mark all unmapped regions.
:return: None
def _mark_unknowns(self):
"""
Mark all unmapped regions.
:return: None
"""
for obj in self.project.loader.all_objects:
if isinstance(obj, cle.ELF):
# sections?
if obj.sections:
... |
:param flag_page: Flag page content, either a string or a list of BV8s
def state_blank(self, flag_page=None, **kwargs):
"""
:param flag_page: Flag page content, either a string or a list of BV8s
"""
s = super(SimCGC, self).state_blank(**kwargs) # pylint:disable=invalid-name
... |
Test whether a statement is inside the loop body or not.
:param stmt_idx:
:return:
def _stmt_inside_loop(self, stmt_idx):
"""
Test whether a statement is inside the loop body or not.
:param stmt_idx:
:return:
"""
# TODO: This is slow. Fix the performan... |
Iterator based check.
With respect to a certain variable/value A,
- there must be at least one exit condition being A//Iterator//HasNext == 0
- there must be at least one local that ticks the iterator next: A//Iterator//Next
def _is_bounded_iterator_based(self):
"""
Iterator ba... |
Overwrite existing definitions w.r.t 'atom' with a dummy definition instance. A dummy definition will not be
removed during simplification.
:param Atom atom:
:param CodeLocation code_loc:
:param object data:
:return: None
def kill_definitions(self, atom, code_loc, data=None, du... |
Create an entry state.
:param args: List of SootArgument values (optional).
def state_entry(self, args=None, **kwargs): # pylint: disable=arguments-differ
"""
Create an entry state.
:param args: List of SootArgument values (optional).
"""
state = self.state_blank(**kwa... |
Generates a new symbolic cmd line argument string.
:return: The string reference.
def generate_symbolic_cmd_line_arg(state, max_length=1000):
"""
Generates a new symbolic cmd line argument string.
:return: The string reference.
"""
str_ref = SimSootValue_StringRef(state.... |
Create a native or a Java call state.
:param addr: Soot or native addr of the invoke target.
:param args: List of SootArgument values.
def state_call(self, addr, *args, **kwargs):
"""
Create a native or a Java call state.
:param addr: Soot or native addr of the invoke ... |
Java specify defaults values for primitive and reference types. This
method returns the default value for a given type.
:param str type_: Name of type.
:return: Default value for this type.
def get_default_value_by_type(type_, state=None):
"""
Java specify defaults... |
Cast the value of primtive types.
:param value: Bitvector storing the primitive value.
:param to_type: Name of the targeted type.
:return: Resized value.
def cast_primitive(state, value, to_type):
"""
Cast the value of primtive types.
:param value:... |
Initialize the static field with an allocated, but not initialized,
object of the given type.
:param state: State associated to the field.
:param field_class_name: Class containing the field.
:param field_name: Name of the field.
:param field_type: Type of the field and the new ... |
Get address of the implementation from a native declared Java function.
:param soot_method: Method descriptor of a native declared function.
:return: CLE address of the given method.
def get_addr_of_native_method(self, soot_method):
"""
Get address of the implementation from a native d... |
Maps the Java type to a SimTypeReg representation of its native
counterpart. This type can be used to indicate the (well-defined) size
of native JNI types.
:return: A SymTypeReg with the JNI size of the given type.
def get_native_type(self, java_type):
"""
Maps the Java type to... |
:return: SimCC object for the native simos.
def get_native_cc(self, func_ty=None):
"""
:return: SimCC object for the native simos.
"""
native_cc_cls = DEFAULT_CC[self.native_simos.arch.name]
return native_cc_cls(self.native_simos.arch, func_ty=func_ty) |
Fill the class with constrained symbolic values.
def fill_symbolic(self):
"""
Fill the class with constrained symbolic values.
"""
self.wYear = self.state.solver.BVS('cur_year', 16, key=('api', 'GetLocalTime', 'cur_year'))
self.wMonth = self.state.solver.BVS('cur_month', 16, key... |
Fill the class with the appropriate values extracted from the given timestamp.
:param ts: A POSIX timestamp.
def fill_from_timestamp(self, ts):
"""
Fill the class with the appropriate values extracted from the given timestamp.
:param ts: A POSIX timestamp.
"""
dt = d... |
Initialize this AnnotatedCFG object with a networkx.DiGraph consisting of the following
form of nodes:
Tuples like (block address, statement ID)
Those nodes are connected by edges indicating the execution flow.
:param networkx.DiGraph digraph: A networkx.DiGraph object
def from_digra... |
:returns: True if all statements are whitelisted
def get_whitelisted_statements(self, addr):
"""
:returns: True if all statements are whitelisted
"""
if addr in self._run_statement_whitelist:
if self._run_statement_whitelist[addr] is True:
return None # This ... |
Pretty-print an IRSB with whitelist information
def dbg_print_irsb(self, irsb_addr, project=None):
"""
Pretty-print an IRSB with whitelist information
"""
if project is None:
project = self._project
if project is None:
raise Exception("Dict addr_to_run ... |
Given a path, returns True if the path should be kept, False if it should be cut.
def keep_path(self, path):
"""
Given a path, returns True if the path should be kept, False if it should be cut.
"""
if len(path.addr_trace) < 2:
return True
return self.should_take_ex... |
Callback routine that takes in a path, and returns all feasible successors to path group. This callback routine
should be passed to the keyword argument "successor_func" of PathGroup.step().
:param path: A Path instance.
:return: A list of all feasible Path successors.
def successor_func(self,... |
Convert to a ValueSet instance
:param state: A state
:return: The converted ValueSet instance
def to_valueset(self, state):
"""
Convert to a ValueSet instance
:param state: A state
:return: The converted ValueSet instance
"""
return state.solver.VS(stat... |
Add a mapping between an absolute address and a region ID. If this is a stack region map, all stack regions
beyond (lower than) this newly added regions will be discarded.
:param absolute_address: An absolute memory address.
:param region_id: ID of the memory region... |
Removes a mapping based on its absolute address.
:param absolute_address: An absolute address
def unmap_by_address(self, absolute_address):
"""
Removes a mapping based on its absolute address.
:param absolute_address: An absolute address
"""
desc = self._address_to_re... |
Convert a relative address in some memory region to an absolute address.
:param region_id: The memory region ID
:param relative_address: The relative memory offset in that memory region
:return: An absolute address if converted, or an exception is raised when reg... |
Convert an absolute address to the memory offset in a memory region.
Note that if an address belongs to heap region is passed in to a stack region map, it will be converted to an
offset included in the closest stack frame, and vice versa for passing a stack address to a heap region.
Therefore y... |
Return the category of this SimMemory instance. It can be one of the three following categories: reg, mem,
or file.
def category(self):
"""
Return the category of this SimMemory instance. It can be one of the three following categories: reg, mem,
or file.
"""
if self.id... |
Call the set_state method in SimStatePlugin class, and then perform the delayed initialization.
:param state: The SimState instance
def set_state(self, state):
"""
Call the set_state method in SimStatePlugin class, and then perform the delayed initialization.
:param state: The SimStat... |
Make an AST out of concrete @data_e
def _convert_to_ast(self, data_e, size_e=None):
"""
Make an AST out of concrete @data_e
"""
if type(data_e) is bytes:
# Convert the string into a BVV, *regardless of endness*
bits = len(data_e) * self.state.arch.byte_width
... |
Create a new mapping between an absolute address (which is the base address of a specific stack frame) and a
region ID.
:param absolute_address: The absolute memory address.
:param region_id: The region ID.
:param related_function_address: Related function address.
def set_stack_addres... |
Remove a stack mapping.
:param absolute_address: An absolute memory address, which is the base address of the stack frame to destroy.
def unset_stack_address_mapping(self, absolute_address):
"""
Remove a stack mapping.
:param absolute_address: An absolute memory address, which is the ... |
Return a memory region ID for a function. If the default region ID exists in the region mapping, an integer
will appended to the region name. In this way we can handle recursive function calls, or a function that
appears more than once in the call frame.
This also means that `stack_id()` should... |
Stores content into memory.
:param addr: A claripy expression representing the address to store at.
:param data: The data to store (claripy expression or something convertable to a claripy expression).
:param size: A claripy expression representing the size of the data to s... |
Stores content into memory, conditional by case.
:param addr: A claripy expression representing the address to store at.
:param contents: A list of bitvectors, not necessarily of the same size. Use None to denote an empty
write.
:param condition... |
Loads size bytes from dst.
:param dst: The address to load from.
:param size: The size (in bytes) of the load.
:param condition: A claripy expression representing a condition for a conditional load.
:param fallback: A fallback value if the condition e... |
Returns the address of bytes equal to 'what', starting from 'start'. Note that, if you don't specify a default
value, this search could cause the state to go unsat if no possible matching byte exists.
:param addr: The start address.
:param what: What to search for;... |
Copies data within a memory.
:param dst: A claripy expression representing the address of the destination
:param src: A claripy expression representing the address of the source
The following parameters are optional.
:param src_memory: Copy data from this SimMemory in... |
Gets vfg node at @addr
Returns VFGNode or None
def _vfg_node(self, addr):
"""
Gets vfg node at @addr
Returns VFGNode or None
"""
for n in self._vfg._nodes.values():
if n.addr == addr:
return n
raise DataGraphError("No VFG node at 0x%x"... |
Pretty print the graph. @imarks determine whether the printed graph
represents instructions (coarse grained) for easier navigation, or
exact statements.
def pp(self, imarks=False):
"""
Pretty print the graph. @imarks determine whether the printed graph
represents instructions... |
Recursive function, it branches in every possible path in the VFG.
@live_defs: a dict {addr:stmt} of live definitions at the start point
@node: the starting vfg node
Returns: the address of the block where the execution stops
def _branch(self, live_defs, node, path=""):
"""
Rec... |
Get a list of abstract locations that is within the range of [addr, addr + size]
This implementation is pretty slow. But since this method won't be called frequently, we can live with the bad
implementation for now.
:param addr: Starting address of the memory region.
:param size: ... |
Helper function for merging.
def _merge_alocs(self, other_region):
"""
Helper function for merging.
"""
merging_occurred = False
for aloc_id, aloc in other_region.alocs.items():
if aloc_id not in self.alocs:
self.alocs[aloc_id] = aloc.copy()
... |
Print out debugging information
def dbg_print(self, indent=0):
"""
Print out debugging information
"""
print("%sA-locs:" % (" " * indent))
for aloc_id, aloc in self._alocs.items():
print("%s<0x%x> %s" % (" " * (indent + 2), aloc_id, aloc))
print("%sMemory:" ... |
Get the base address of a memory region.
:param str region: ID of the memory region
:return: Address of the memory region
:rtype: int
def _region_base(self, region):
"""
Get the base address of a memory region.
:param str region: ID of the memory region
:return... |
Create a new MemoryRegion with the region key specified, and store it to self._regions.
:param key: a string which is the region key
:param state: the SimState instance
:param bool is_stack: Whether this memory region is on stack. True/False
:param related_function_addr: Which function ... |
If this is a stack address, we convert it to a correct region and address
:param region_id: a string indicating which region the address is relative to
:param relative_address: an address that is relative to the region parameter
:param target_region: the ideal target region that address is norm... |
Overriding the SimStatePlugin.set_state() method
:param state: A SimState object
:return: None
def set_state(self, state):
"""
Overriding the SimStatePlugin.set_state() method
:param state: A SimState object
:return: None
"""
# Sanity check
if ... |
Convert a ValueSet object into a list of addresses.
:param addr: A ValueSet object (which describes an address)
:param is_write: Is this address used in a write or not
:param convert_to_valueset: True if you want to have a list of ValueSet instances instead of AddressWrappers,
... |
Convert address of different types to a list of mapping between region IDs and offsets (strided intervals).
:param claripy.ast.Base addr: Address to convert
:return: A list of mapping between region IDs and offsets.
:rtype: dict
def _normalize_address_type(self, addr): #pylint:disable=no-self-... |
Get a segmented memory region based on AbstractLocation information available from VSA.
Here are some assumptions to make this method fast:
- The entire memory region [addr, addr + size] is located within the same MemoryRegion
- The address 'addr' has only one concrete value. It cannot ... |
Make a copy of this SimAbstractMemory object
:return:
def copy(self, memo):
"""
Make a copy of this SimAbstractMemory object
:return:
"""
am = SimAbstractMemory(
memory_id=self._memory_id,
endness=self.endness,
stack_region_map=self._s... |
Merge this guy with another SimAbstractMemory instance
def merge(self, others, merge_conditions, common_ancestor=None):
"""
Merge this guy with another SimAbstractMemory instance
"""
merging_occurred = False
for o in others:
for region_id, region in o._regions.items... |
Print out debugging information
def dbg_print(self):
"""
Print out debugging information
"""
for region_id, region in self.regions.items():
print("Region [%s]:" % region_id)
region.dbg_print(indent=2) |
Initialize ptable for ctype
See __ctype_toupper_loc.c in libc implementation
def _initialize_toupper_loc_table(self):
"""
Initialize ptable for ctype
See __ctype_toupper_loc.c in libc implementation
"""
malloc = angr.SIM_PROCEDURES['libc']['malloc']
# 384 entri... |
Extract arguments and set them to
:param angr.sim_state.SimState state: The program state.
:param main: An argument to __libc_start_main.
:param argc: An argument to __libc_start_main.
:param argv: An argument to __libc_start_main.
:param init: An argument to __libc_start_main.
... |
Debugging output of this slice.
:param max_display: The maximum number of SimRun slices to show.
:return: A string representation.
def dbg_repr(self, max_display=10):
"""
Debugging output of this slice.
:param max_display: The maximum number of SimRun slices to show... |
Debugging output of a single SimRun slice.
:param run_addr: Address of the SimRun.
:return: A string representation.
def dbg_repr_run(self, run_addr):
"""
Debugging output of a single SimRun slice.
:param run_addr: Address of the SimRun.
:return: ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.