repo stringlengths 7 55 | path stringlengths 4 223 | func_name stringlengths 1 134 | original_string stringlengths 75 104k | language stringclasses 1
value | code stringlengths 75 104k | code_tokens listlengths 19 28.4k | docstring stringlengths 1 46.9k | docstring_tokens listlengths 1 1.97k | sha stringlengths 40 40 | url stringlengths 87 315 | partition stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
angr/angr | angr/analyses/cfg/cfg_emulated.py | CFGEmulated._is_indirect_jump | 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
default_jumpkind = sim_successors.artifacts['irsb_default_jump... | python | 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
default_jumpkind = sim_successors.artifacts['irsb_default_jump... | [
"def",
"_is_indirect_jump",
"(",
"_",
",",
"sim_successors",
")",
":",
"if",
"sim_successors",
".",
"artifacts",
"[",
"'irsb_direct_next'",
"]",
":",
"# It's a direct jump",
"return",
"False",
"default_jumpkind",
"=",
"sim_successors",
".",
"artifacts",
"[",
"'irsb_... | Determine if this SimIRSB has an indirect jump as its exit | [
"Determine",
"if",
"this",
"SimIRSB",
"has",
"an",
"indirect",
"jump",
"as",
"its",
"exit"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_emulated.py#L3276-L3290 | train |
angr/angr | angr/analyses/cfg/cfg_emulated.py | CFGEmulated._is_address_executable | def _is_address_executable(self, address):
"""
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
"""
for r in self._executable_address_ranges:
if r[... | python | def _is_address_executable(self, address):
"""
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
"""
for r in self._executable_address_ranges:
if r[... | [
"def",
"_is_address_executable",
"(",
"self",
",",
"address",
")",
":",
"for",
"r",
"in",
"self",
".",
"_executable_address_ranges",
":",
"if",
"r",
"[",
"0",
"]",
"<=",
"address",
"<",
"r",
"[",
"1",
"]",
":",
"return",
"True",
"return",
"False"
] | 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 | [
"Check",
"if",
"the",
"specific",
"address",
"is",
"in",
"one",
"of",
"the",
"executable",
"ranges",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_emulated.py#L3342-L3353 | train |
angr/angr | angr/analyses/cfg/cfg_emulated.py | CFGEmulated._get_callsites | def _get_callsites(self, function_address):
"""
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
"""
all_predecessors =... | python | def _get_callsites(self, function_address):
"""
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
"""
all_predecessors =... | [
"def",
"_get_callsites",
"(",
"self",
",",
"function_address",
")",
":",
"all_predecessors",
"=",
"[",
"]",
"nodes",
"=",
"self",
".",
"get_all_nodes",
"(",
"function_address",
")",
"for",
"n",
"in",
"nodes",
":",
"predecessors",
"=",
"list",
"(",
"self",
... | 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 | [
"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",... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_emulated.py#L3367-L3381 | train |
angr/angr | angr/analyses/cfg/cfg_emulated.py | CFGEmulated._get_nx_paths | def _get_nx_paths(self, begin, end):
"""
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.
"""
if isinstance(begin, int) and isins... | python | def _get_nx_paths(self, begin, end):
"""
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.
"""
if isinstance(begin, int) and isins... | [
"def",
"_get_nx_paths",
"(",
"self",
",",
"begin",
",",
"end",
")",
":",
"if",
"isinstance",
"(",
"begin",
",",
"int",
")",
"and",
"isinstance",
"(",
"end",
",",
"int",
")",
":",
"n_begin",
"=",
"self",
".",
"get_any_node",
"(",
"begin",
")",
"n_end"... | 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. | [
"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",
"no... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_emulated.py#L3383-L3401 | train |
angr/angr | angr/analyses/cfg/cfg_emulated.py | CFGEmulated._quasi_topological_sort | def _quasi_topological_sort(self):
"""
Perform a quasi-topological sort on an already constructed CFG graph (a networkx DiGraph)
:return: None
"""
# Clear the existing sorting result
self._quasi_topological_order = {}
ctr = self._graph.number_of_nodes()
... | python | def _quasi_topological_sort(self):
"""
Perform a quasi-topological sort on an already constructed CFG graph (a networkx DiGraph)
:return: None
"""
# Clear the existing sorting result
self._quasi_topological_order = {}
ctr = self._graph.number_of_nodes()
... | [
"def",
"_quasi_topological_sort",
"(",
"self",
")",
":",
"# Clear the existing sorting result",
"self",
".",
"_quasi_topological_order",
"=",
"{",
"}",
"ctr",
"=",
"self",
".",
"_graph",
".",
"number_of_nodes",
"(",
")",
"for",
"ep",
"in",
"self",
".",
"_entry_p... | Perform a quasi-topological sort on an already constructed CFG graph (a networkx DiGraph)
:return: None | [
"Perform",
"a",
"quasi",
"-",
"topological",
"sort",
"on",
"an",
"already",
"constructed",
"CFG",
"graph",
"(",
"a",
"networkx",
"DiGraph",
")"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_emulated.py#L3403-L3425 | train |
angr/angr | angr/analyses/cfg/cfg_emulated.py | CFGEmulated._reset_state_mode | def _reset_state_mode(self, state, mode):
"""
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
"""
state.set_m... | python | def _reset_state_mode(self, state, mode):
"""
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
"""
state.set_m... | [
"def",
"_reset_state_mode",
"(",
"self",
",",
"state",
",",
"mode",
")",
":",
"state",
".",
"set_mode",
"(",
"mode",
")",
"state",
".",
"options",
"|=",
"self",
".",
"_state_add_options",
"state",
".",
"options",
"=",
"state",
".",
"options",
".",
"diffe... | 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 | [
"Reset",
"the",
"state",
"mode",
"to",
"the",
"given",
"mode",
"and",
"apply",
"the",
"custom",
"state",
"options",
"specified",
"with",
"this",
"analysis",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_emulated.py#L3427-L3438 | train |
angr/angr | angr/analyses/reassembler.py | SymbolManager.label_got | def label_got(self, addr, label):
"""
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
... | python | def label_got(self, addr, label):
"""
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",
")",
":",
"if",
"label",
"in",
"self",
".",
"addr_to_label",
"[",
"addr",
"]",
":",
"label",
".",
"assigned",
"=",
"True"
] | 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 | [
"Mark",
"a",
"certain",
"label",
"as",
"assigned",
"(",
"to",
"an",
"instruction",
"or",
"a",
"block",
"of",
"data",
")",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L398-L409 | train |
angr/angr | angr/analyses/reassembler.py | Operand._imm_to_ptr | def _imm_to_ptr(self, imm, operand_type, mnemonic): # pylint:disable=no-self-use,unused-argument
"""
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 mne... | python | def _imm_to_ptr(self, imm, operand_type, mnemonic): # pylint:disable=no-self-use,unused-argument
"""
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 mne... | [
"def",
"_imm_to_ptr",
"(",
"self",
",",
"imm",
",",
"operand_type",
",",
"mnemonic",
")",
":",
"# pylint:disable=no-self-use,unused-argument",
"is_coderef",
",",
"is_dataref",
"=",
"False",
",",
"False",
"baseaddr",
"=",
"None",
"if",
"not",
"is_coderef",
"and",
... | 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... | [
"Try",
"to",
"classify",
"an",
"immediate",
"as",
"a",
"pointer",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L625-L667 | train |
angr/angr | angr/analyses/reassembler.py | Procedure.name | def name(self):
"""
Get function name from the labels of the very first block.
:return: Function name if there is any, None otherwise
:rtype: string
"""
if self._name is not None:
return self._name
if not self.blocks:
return None
... | python | def name(self):
"""
Get function name from the labels of the very first block.
:return: Function name if there is any, None otherwise
:rtype: string
"""
if self._name is not None:
return self._name
if not self.blocks:
return None
... | [
"def",
"name",
"(",
"self",
")",
":",
"if",
"self",
".",
"_name",
"is",
"not",
"None",
":",
"return",
"self",
".",
"_name",
"if",
"not",
"self",
".",
"blocks",
":",
"return",
"None",
"if",
"not",
"self",
".",
"blocks",
"[",
"0",
"]",
".",
"instru... | Get function name from the labels of the very first block.
:return: Function name if there is any, None otherwise
:rtype: string | [
"Get",
"function",
"name",
"from",
"the",
"labels",
"of",
"the",
"very",
"first",
"block",
".",
":",
"return",
":",
"Function",
"name",
"if",
"there",
"is",
"any",
"None",
"otherwise",
":",
"rtype",
":",
"string"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L967-L991 | train |
angr/angr | angr/analyses/reassembler.py | Procedure.is_plt | 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
"""
if self.section == ".plt":
return True
if not self.blocks:
return False
initial_block =... | python | 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
"""
if self.section == ".plt":
return True
if not self.blocks:
return False
initial_block =... | [
"def",
"is_plt",
"(",
"self",
")",
":",
"if",
"self",
".",
"section",
"==",
"\".plt\"",
":",
"return",
"True",
"if",
"not",
"self",
".",
"blocks",
":",
"return",
"False",
"initial_block",
"=",
"next",
"(",
"(",
"b",
"for",
"b",
"in",
"self",
".",
"... | If this function is a PLT entry or not.
:return: True if this function is a PLT entry, False otherwise
:rtype: bool | [
"If",
"this",
"function",
"is",
"a",
"PLT",
"entry",
"or",
"not",
".",
":",
"return",
":",
"True",
"if",
"this",
"function",
"is",
"a",
"PLT",
"entry",
"False",
"otherwise",
":",
"rtype",
":",
"bool"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L994-L1022 | train |
angr/angr | angr/analyses/reassembler.py | Procedure.assembly | def assembly(self, comments=False, symbolized=True):
"""
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
"""
assembly... | python | def assembly(self, comments=False, symbolized=True):
"""
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
"""
assembly... | [
"def",
"assembly",
"(",
"self",
",",
"comments",
"=",
"False",
",",
"symbolized",
"=",
"True",
")",
":",
"assembly",
"=",
"[",
"]",
"header",
"=",
"\"\\t.section\\t{section}\\n\\t.align\\t{alignment}\\n\"",
".",
"format",
"(",
"section",
"=",
"self",
".",
"sec... | 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 | [
"Get",
"the",
"assembly",
"manifest",
"of",
"the",
"procedure",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L1043-L1081 | train |
angr/angr | angr/analyses/reassembler.py | Procedure.instruction_addresses | def instruction_addresses(self):
"""
Get all instruction addresses in the binary.
:return: A list of sorted instruction addresses.
:rtype: list
"""
addrs = [ ]
for b in sorted(self.blocks, key=lambda x: x.addr): # type: BasicBlock
addrs.extend(b.ins... | python | def instruction_addresses(self):
"""
Get all instruction addresses in the binary.
:return: A list of sorted instruction addresses.
:rtype: list
"""
addrs = [ ]
for b in sorted(self.blocks, key=lambda x: x.addr): # type: BasicBlock
addrs.extend(b.ins... | [
"def",
"instruction_addresses",
"(",
"self",
")",
":",
"addrs",
"=",
"[",
"]",
"for",
"b",
"in",
"sorted",
"(",
"self",
".",
"blocks",
",",
"key",
"=",
"lambda",
"x",
":",
"x",
".",
"addr",
")",
":",
"# type: BasicBlock",
"addrs",
".",
"extend",
"(",... | Get all instruction addresses in the binary.
:return: A list of sorted instruction addresses.
:rtype: list | [
"Get",
"all",
"instruction",
"addresses",
"in",
"the",
"binary",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L1083-L1095 | train |
angr/angr | angr/analyses/reassembler.py | Procedure._output_function_label | def _output_function_label(self):
"""
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... | python | def _output_function_label(self):
"""
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... | [
"def",
"_output_function_label",
"(",
"self",
")",
":",
"if",
"self",
".",
"asm_code",
":",
"return",
"True",
"if",
"not",
"self",
".",
"blocks",
":",
"return",
"True",
"the_block",
"=",
"next",
"(",
"(",
"b",
"for",
"b",
"in",
"self",
".",
"blocks",
... | 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 | [
"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",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L1117-L1138 | train |
angr/angr | angr/analyses/reassembler.py | Data.shrink | 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':
self.null_terminated = False # string without the null byte terminator
self._... | python | 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':
self.null_terminated = False # string without the null byte terminator
self._... | [
"def",
"shrink",
"(",
"self",
",",
"new_size",
")",
":",
"self",
".",
"size",
"=",
"new_size",
"if",
"self",
".",
"sort",
"==",
"'string'",
":",
"self",
".",
"null_terminated",
"=",
"False",
"# string without the null byte terminator",
"self",
".",
"_content",... | Reduce the size of this block
:param int new_size: The new size
:return: None | [
"Reduce",
"the",
"size",
"of",
"this",
"block"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L1196-L1221 | train |
angr/angr | angr/analyses/reassembler.py | Data.desymbolize | def desymbolize(self):
"""
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
"""
self.sort = 'unknown'
... | python | def desymbolize(self):
"""
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
"""
self.sort = 'unknown'
... | [
"def",
"desymbolize",
"(",
"self",
")",
":",
"self",
".",
"sort",
"=",
"'unknown'",
"content",
"=",
"self",
".",
"binary",
".",
"fast_memory_load",
"(",
"self",
".",
"addr",
",",
"self",
".",
"size",
",",
"bytes",
")",
"self",
".",
"content",
"=",
"[... | 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 | [
"We",
"believe",
"this",
"was",
"a",
"pointer",
"and",
"symbolized",
"it",
"before",
".",
"Now",
"we",
"want",
"to",
"desymbolize",
"it",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L1223-L1236 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler.main_executable_region_limbos_contain | def main_executable_region_limbos_contain(self, addr):
"""
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:... | python | def main_executable_region_limbos_contain(self, addr):
"""
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:... | [
"def",
"main_executable_region_limbos_contain",
"(",
"self",
",",
"addr",
")",
":",
"TOLERANCE",
"=",
"64",
"closest_region",
"=",
"None",
"least_limbo",
"=",
"None",
"for",
"start",
",",
"end",
"in",
"self",
".",
"main_executable_regions",
":",
"if",
"start",
... | 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 | [
"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",
"o... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L1821-L1848 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler.main_nonexecutable_region_limbos_contain | def main_nonexecutable_region_limbos_contain(self, addr, tolerance_before=64, tolerance_after=64):
"""
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 ... | python | def main_nonexecutable_region_limbos_contain(self, addr, tolerance_before=64, tolerance_after=64):
"""
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 ... | [
"def",
"main_nonexecutable_region_limbos_contain",
"(",
"self",
",",
"addr",
",",
"tolerance_before",
"=",
"64",
",",
"tolerance_after",
"=",
"64",
")",
":",
"closest_region",
"=",
"None",
"least_limbo",
"=",
"None",
"for",
"start",
",",
"end",
"in",
"self",
"... | 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 | [
"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",
"o... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L1862-L1887 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler.add_label | def add_label(self, name, addr):
"""
Add a new label to the symbol manager.
:param str name: Name of the label.
:param int addr: Address of the label.
:return: None
"""
# set the label
self._symbolization_needed = True
self.symbol_manager.new_la... | python | def add_label(self, name, addr):
"""
Add a new label to the symbol manager.
:param str name: Name of the label.
:param int addr: Address of the label.
:return: None
"""
# set the label
self._symbolization_needed = True
self.symbol_manager.new_la... | [
"def",
"add_label",
"(",
"self",
",",
"name",
",",
"addr",
")",
":",
"# set the label",
"self",
".",
"_symbolization_needed",
"=",
"True",
"self",
".",
"symbol_manager",
".",
"new_label",
"(",
"addr",
",",
"name",
"=",
"name",
",",
"force",
"=",
"True",
... | Add a new label to the symbol manager.
:param str name: Name of the label.
:param int addr: Address of the label.
:return: None | [
"Add",
"a",
"new",
"label",
"to",
"the",
"symbol",
"manager",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L1950-L1962 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler.insert_asm | def insert_asm(self, addr, asm_code, before_label=False):
"""
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
""... | python | def insert_asm(self, addr, asm_code, before_label=False):
"""
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",
")",
":",
"if",
"before_label",
":",
"self",
".",
"_inserted_asm_before_label",
"[",
"addr",
"]",
".",
"append",
"(",
"asm_code",
")",
"else",
":",
"self",
... | 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 | [
"Insert",
"some",
"assembly",
"code",
"at",
"the",
"specific",
"address",
".",
"There",
"must",
"be",
"an",
"instruction",
"starting",
"at",
"that",
"address",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L1964-L1976 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler.append_procedure | def append_procedure(self, name, asm_code):
"""
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
"""
proc = Procedure(self, name=name, ... | python | def append_procedure(self, name, asm_code):
"""
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
"""
proc = Procedure(self, name=name, ... | [
"def",
"append_procedure",
"(",
"self",
",",
"name",
",",
"asm_code",
")",
":",
"proc",
"=",
"Procedure",
"(",
"self",
",",
"name",
"=",
"name",
",",
"asm_code",
"=",
"asm_code",
")",
"self",
".",
"procedures",
".",
"append",
"(",
"proc",
")"
] | 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 | [
"Add",
"a",
"new",
"procedure",
"with",
"specific",
"name",
"and",
"assembly",
"code",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L1978-L1988 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler.append_data | def append_data(self, name, initial_content, size, readonly=False, sort="unknown"): # pylint:disable=unused-argument
"""
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 initi... | python | def append_data(self, name, initial_content, size, readonly=False, sort="unknown"): # pylint:disable=unused-argument
"""
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 initi... | [
"def",
"append_data",
"(",
"self",
",",
"name",
",",
"initial_content",
",",
"size",
",",
"readonly",
"=",
"False",
",",
"sort",
"=",
"\"unknown\"",
")",
":",
"# pylint:disable=unused-argument",
"if",
"readonly",
":",
"section_name",
"=",
"\".rodata\"",
"else",
... | 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... | [
"Append",
"a",
"new",
"data",
"entry",
"into",
"the",
"binary",
"with",
"specific",
"name",
"content",
"and",
"size",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L1990-L2017 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler.remove_cgc_attachments | def remove_cgc_attachments(self):
"""
Remove CGC attachments.
:return: True if CGC attachments are found and removed, False otherwise
:rtype: bool
"""
cgc_package_list = None
cgc_extended_application = None
for data in self.data:
if data.sor... | python | def remove_cgc_attachments(self):
"""
Remove CGC attachments.
:return: True if CGC attachments are found and removed, False otherwise
:rtype: bool
"""
cgc_package_list = None
cgc_extended_application = None
for data in self.data:
if data.sor... | [
"def",
"remove_cgc_attachments",
"(",
"self",
")",
":",
"cgc_package_list",
"=",
"None",
"cgc_extended_application",
"=",
"None",
"for",
"data",
"in",
"self",
".",
"data",
":",
"if",
"data",
".",
"sort",
"==",
"'cgc-package-list'",
":",
"cgc_package_list",
"=",
... | Remove CGC attachments.
:return: True if CGC attachments are found and removed, False otherwise
:rtype: bool | [
"Remove",
"CGC",
"attachments",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L2136-L2245 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler.remove_unnecessary_stuff | def remove_unnecessary_stuff(self):
"""
Remove unnecessary functions and data
:return: None
"""
glibc_functions_blacklist = {
'_start',
'_init',
'_fini',
'__gmon_start__',
'__do_global_dtors_aux',
'frame_du... | python | def remove_unnecessary_stuff(self):
"""
Remove unnecessary functions and data
:return: None
"""
glibc_functions_blacklist = {
'_start',
'_init',
'_fini',
'__gmon_start__',
'__do_global_dtors_aux',
'frame_du... | [
"def",
"remove_unnecessary_stuff",
"(",
"self",
")",
":",
"glibc_functions_blacklist",
"=",
"{",
"'_start'",
",",
"'_init'",
",",
"'_fini'",
",",
"'__gmon_start__'",
",",
"'__do_global_dtors_aux'",
",",
"'frame_dummy'",
",",
"'atexit'",
",",
"'deregister_tm_clones'",
... | Remove unnecessary functions and data
:return: None | [
"Remove",
"unnecessary",
"functions",
"and",
"data"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L2247-L2309 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler._initialize | 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.project.loader.main_object.segments:
... | python | 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.project.loader.main_object.segments:
... | [
"def",
"_initialize",
"(",
"self",
")",
":",
"# figure out section alignments",
"for",
"section",
"in",
"self",
".",
"project",
".",
"loader",
".",
"main_object",
".",
"sections",
":",
"in_segment",
"=",
"False",
"for",
"segment",
"in",
"self",
".",
"project",... | Initialize the binary.
:return: None | [
"Initialize",
"the",
"binary",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L2315-L2560 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler._sequence_handler | def _sequence_handler(self, cfg, irsb, irsb_addr, stmt_idx, data_addr, max_size): # pylint:disable=unused-argument
"""
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 ... | python | def _sequence_handler(self, cfg, irsb, irsb_addr, stmt_idx, data_addr, max_size): # pylint:disable=unused-argument
"""
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 ... | [
"def",
"_sequence_handler",
"(",
"self",
",",
"cfg",
",",
"irsb",
",",
"irsb_addr",
",",
"stmt_idx",
",",
"data_addr",
",",
"max_size",
")",
":",
"# pylint:disable=unused-argument",
"if",
"not",
"self",
".",
"_is_sequence",
"(",
"cfg",
",",
"data_addr",
",",
... | 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... | [
"Find",
"sequences",
"in",
"binary",
"data",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L2589-L2613 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler._cgc_package_list_identifier | def _cgc_package_list_identifier(self, data_addr, data_size):
"""
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.
:... | python | def _cgc_package_list_identifier(self, data_addr, data_size):
"""
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.
:... | [
"def",
"_cgc_package_list_identifier",
"(",
"self",
",",
"data_addr",
",",
"data_size",
")",
":",
"if",
"data_size",
"<",
"100",
":",
"return",
"None",
",",
"None",
"data",
"=",
"self",
".",
"fast_memory_load",
"(",
"data_addr",
",",
"data_size",
",",
"str",... | 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 | [
"Identifies",
"the",
"CGC",
"package",
"list",
"associated",
"with",
"the",
"CGC",
"binary",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L2615-L2639 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler._cgc_extended_application_handler | def _cgc_extended_application_handler(self, cfg, irsb, irsb_addr, stmt_idx, data_addr, max_size): # pylint:disable=unused-argument
"""
Identifies the extended application (a PDF file) associated with the CGC binary.
:param angr.analyses.CFG cfg: The control flow graph.
:param pyvex.IRS... | python | def _cgc_extended_application_handler(self, cfg, irsb, irsb_addr, stmt_idx, data_addr, max_size): # pylint:disable=unused-argument
"""
Identifies the extended application (a PDF file) associated with the CGC binary.
:param angr.analyses.CFG cfg: The control flow graph.
:param pyvex.IRS... | [
"def",
"_cgc_extended_application_handler",
"(",
"self",
",",
"cfg",
",",
"irsb",
",",
"irsb_addr",
",",
"stmt_idx",
",",
"data_addr",
",",
"max_size",
")",
":",
"# pylint:disable=unused-argument",
"if",
"max_size",
"<",
"100",
":",
"return",
"None",
",",
"None"... | 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... | [
"Identifies",
"the",
"extended",
"application",
"(",
"a",
"PDF",
"file",
")",
"associated",
"with",
"the",
"CGC",
"binary",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L2641-L2681 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler._unknown_data_size_handler | def _unknown_data_size_handler(self, cfg, irsb, irsb_addr, stmt_idx, data_addr, max_size): # pylint:disable=unused-argument
"""
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 py... | python | def _unknown_data_size_handler(self, cfg, irsb, irsb_addr, stmt_idx, data_addr, max_size): # pylint:disable=unused-argument
"""
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 py... | [
"def",
"_unknown_data_size_handler",
"(",
"self",
",",
"cfg",
",",
"irsb",
",",
"irsb_addr",
",",
"stmt_idx",
",",
"data_addr",
",",
"max_size",
")",
":",
"# pylint:disable=unused-argument",
"sequence_offset",
"=",
"None",
"for",
"offset",
"in",
"range",
"(",
"1... | 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... | [
"Return",
"the",
"maximum",
"number",
"of",
"bytes",
"until",
"a",
"potential",
"pointer",
"or",
"a",
"potential",
"sequence",
"is",
"found",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L2683-L2726 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler._has_integer_used_as_pointers | def _has_integer_used_as_pointers(self):
"""
Test if there is any (suspicious) pointer decryption in the code.
:return: True if there is any pointer decryption, False otherwise.
:rtype: bool
"""
# check all integer accesses and see if there is any integer being used as ... | python | def _has_integer_used_as_pointers(self):
"""
Test if there is any (suspicious) pointer decryption in the code.
:return: True if there is any pointer decryption, False otherwise.
:rtype: bool
"""
# check all integer accesses and see if there is any integer being used as ... | [
"def",
"_has_integer_used_as_pointers",
"(",
"self",
")",
":",
"# check all integer accesses and see if there is any integer being used as a pointer later, but it wasn't",
"# classified as a pointer reference",
"# we only care about unknown memory data that are 4 bytes long, and is directly referenc... | Test if there is any (suspicious) pointer decryption in the code.
:return: True if there is any pointer decryption, False otherwise.
:rtype: bool | [
"Test",
"if",
"there",
"is",
"any",
"(",
"suspicious",
")",
"pointer",
"decryption",
"in",
"the",
"code",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L2728-L2806 | train |
angr/angr | angr/analyses/reassembler.py | Reassembler.fast_memory_load | def fast_memory_load(self, addr, size, data_type, endness='Iend_LE'):
"""
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:... | python | def fast_memory_load(self, addr, size, data_type, endness='Iend_LE'):
"""
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:... | [
"def",
"fast_memory_load",
"(",
"self",
",",
"addr",
",",
"size",
",",
"data_type",
",",
"endness",
"=",
"'Iend_LE'",
")",
":",
"if",
"data_type",
"is",
"int",
":",
"try",
":",
"return",
"self",
".",
"project",
".",
"loader",
".",
"memory",
".",
"unpac... | 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.
... | [
"Load",
"memory",
"bytes",
"from",
"loader",
"s",
"memory",
"backend",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reassembler.py#L2808-L2832 | train |
angr/angr | angr/analyses/variable_recovery/variable_recovery_fast.py | VariableRecoveryFastState.merge | def merge(self, other, successor=None):
"""
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 wi... | python | def merge(self, other, successor=None):
"""
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 wi... | [
"def",
"merge",
"(",
"self",
",",
"other",
",",
"successor",
"=",
"None",
")",
":",
"replacements",
"=",
"{",
"}",
"if",
"successor",
"in",
"self",
".",
"dominance_frontiers",
":",
"replacements",
"=",
"self",
".",
"_make_phi_variables",
"(",
"successor",
... | 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 ... | [
"Merge",
"two",
"abstract",
"states",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/variable_recovery/variable_recovery_fast.py#L525-L557 | train |
angr/angr | angr/analyses/variable_recovery/variable_recovery_fast.py | VariableRecoveryFast._process_block | def _process_block(self, state, block): # pylint:disable=no-self-use
"""
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 mar... | python | def _process_block(self, state, block): # pylint:disable=no-self-use
"""
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 mar... | [
"def",
"_process_block",
"(",
"self",
",",
"state",
",",
"block",
")",
":",
"# pylint:disable=no-self-use",
"l",
".",
"debug",
"(",
"'Processing block %#x.'",
",",
"block",
".",
"addr",
")",
"processor",
"=",
"self",
".",
"_ail_engine",
"if",
"isinstance",
"("... | 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... | [
"Scan",
"through",
"all",
"statements",
"and",
"perform",
"the",
"following",
"tasks",
":",
"-",
"Find",
"stack",
"pointers",
"and",
"the",
"VEX",
"temporary",
"variable",
"storing",
"stack",
"pointers",
"-",
"Selectively",
"calculate",
"VEX",
"statements",
"-",... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/variable_recovery/variable_recovery_fast.py#L718-L741 | train |
angr/angr | angr/utils/graph.py | shallow_reverse | def shallow_reverse(g):
"""
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-o... | python | def shallow_reverse(g):
"""
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-o... | [
"def",
"shallow_reverse",
"(",
"g",
")",
":",
"new_g",
"=",
"networkx",
".",
"DiGraph",
"(",
")",
"new_g",
".",
"add_nodes_from",
"(",
"g",
".",
"nodes",
"(",
")",
")",
"for",
"src",
",",
"dst",
",",
"data",
"in",
"g",
".",
"edges",
"(",
"data",
... | 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:... | [
"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",
... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/utils/graph.py#L8-L25 | train |
angr/angr | angr/utils/graph.py | dfs_back_edges | def dfs_back_edges(graph, start_node):
"""
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_edg... | python | def dfs_back_edges(graph, start_node):
"""
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_edg... | [
"def",
"dfs_back_edges",
"(",
"graph",
",",
"start_node",
")",
":",
"visited",
"=",
"set",
"(",
")",
"finished",
"=",
"set",
"(",
")",
"def",
"_dfs_back_edges_core",
"(",
"node",
")",
":",
"visited",
".",
"add",
"(",
"node",
")",
"for",
"child",
"in",
... | 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... | [
"Do",
"a",
"DFS",
"traversal",
"of",
"the",
"graph",
"and",
"return",
"with",
"the",
"back",
"edges",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/utils/graph.py#L28-L56 | train |
angr/angr | angr/utils/graph.py | compute_dominance_frontier | def compute_dominance_frontier(graph, domtree):
"""
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 c... | python | def compute_dominance_frontier(graph, domtree):
"""
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 c... | [
"def",
"compute_dominance_frontier",
"(",
"graph",
",",
"domtree",
")",
":",
"df",
"=",
"{",
"}",
"# Perform a post-order search on the dominator tree",
"for",
"x",
"in",
"networkx",
".",
"dfs_postorder_nodes",
"(",
"domtree",
")",
":",
"if",
"x",
"not",
"in",
"... | 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... | [
"Compute",
"a",
"dominance",
"frontier",
"based",
"on",
"the",
"given",
"post",
"-",
"dominator",
"tree",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/utils/graph.py#L63-L104 | train |
angr/angr | angr/utils/graph.py | Dominators._graph_successors | def _graph_successors(self, graph, node):
"""
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 FakeRe... | python | def _graph_successors(self, graph, node):
"""
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 FakeRe... | [
"def",
"_graph_successors",
"(",
"self",
",",
"graph",
",",
"node",
")",
":",
"if",
"self",
".",
"_graph_successors_func",
"is",
"not",
"None",
":",
"return",
"self",
".",
"_graph_successors_func",
"(",
"graph",
",",
"node",
")",
"return",
"graph",
".",
"s... | 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... | [
"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",
"wh... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/utils/graph.py#L186-L201 | train |
angr/angr | angr/utils/graph.py | Dominators._construct | def _construct(self, graph, entry_node):
"""
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 L... | python | def _construct(self, graph, entry_node):
"""
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 L... | [
"def",
"_construct",
"(",
"self",
",",
"graph",
",",
"entry_node",
")",
":",
"# Step 1",
"_prepared_graph",
",",
"vertices",
",",
"parent",
"=",
"self",
".",
"_prepare_graph",
"(",
"graph",
",",
"entry_node",
")",
"# vertices is a list of ContainerNode instances",
... | 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 | [
"Find",
"post",
"-",
"dominators",
"for",
"each",
"node",
"in",
"the",
"graph",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/utils/graph.py#L203-L264 | train |
angr/angr | angr/misc/loggers.py | Loggers.load_all_loggers | def load_all_loggers(self):
"""
A dumb and simple way to conveniently aggregate all loggers.
Adds attributes to this instance of each registered logger, replacing '.' with '_'
"""
for name, logger in logging.Logger.manager.loggerDict.items():
if any(name.startswith(x... | python | def load_all_loggers(self):
"""
A dumb and simple way to conveniently aggregate all loggers.
Adds attributes to this instance of each registered logger, replacing '.' with '_'
"""
for name, logger in logging.Logger.manager.loggerDict.items():
if any(name.startswith(x... | [
"def",
"load_all_loggers",
"(",
"self",
")",
":",
"for",
"name",
",",
"logger",
"in",
"logging",
".",
"Logger",
".",
"manager",
".",
"loggerDict",
".",
"items",
"(",
")",
":",
"if",
"any",
"(",
"name",
".",
"startswith",
"(",
"x",
"+",
"'.'",
")",
... | A dumb and simple way to conveniently aggregate all loggers.
Adds attributes to this instance of each registered logger, replacing '.' with '_' | [
"A",
"dumb",
"and",
"simple",
"way",
"to",
"conveniently",
"aggregate",
"all",
"loggers",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/misc/loggers.py#L20-L28 | train |
angr/angr | angr/engines/procedure.py | SimEngineProcedure.process | def process(self, state, procedure,
ret_to=None,
inline=None,
force_addr=None,
**kwargs):
"""
Perform execution with a state.
:param state: The state with which to execute
:param procedure: An instance of a SimProcedure to run
... | python | def process(self, state, procedure,
ret_to=None,
inline=None,
force_addr=None,
**kwargs):
"""
Perform execution with a state.
:param state: The state with which to execute
:param procedure: An instance of a SimProcedure to run
... | [
"def",
"process",
"(",
"self",
",",
"state",
",",
"procedure",
",",
"ret_to",
"=",
"None",
",",
"inline",
"=",
"None",
",",
"force_addr",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"super",
"(",
"SimEngineProcedure",
",",
"self",
")",
... | 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... | [
"Perform",
"execution",
"with",
"a",
"state",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/engines/procedure.py#L13-L31 | train |
angr/angr | angr/engines/soot/values/arrayref.py | SimSootValue_ArrayBaseRef.get_default_value | 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_value_by_type(self.element_type, state=state) | python | 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_value_by_type(self.element_type, state=state) | [
"def",
"get_default_value",
"(",
"self",
",",
"state",
")",
":",
"if",
"self",
".",
"_default_value_generator",
":",
"return",
"self",
".",
"_default_value_generator",
"(",
"state",
")",
"else",
":",
"return",
"state",
".",
"project",
".",
"simos",
".",
"get... | :return: Default value for array elements. | [
":",
"return",
":",
"Default",
"value",
"for",
"array",
"elements",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/engines/soot/values/arrayref.py#L26-L33 | train |
angr/angr | angr/analyses/cfg/cfb.py | CFBlanket.add_function | 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) | python | 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) | [
"def",
"add_function",
"(",
"self",
",",
"func",
")",
":",
"for",
"block",
"in",
"func",
".",
"blocks",
":",
"self",
".",
"add_obj",
"(",
"block",
".",
"addr",
",",
"block",
")"
] | Add a function `func` and all blocks of this function to the blanket. | [
"Add",
"a",
"function",
"func",
"and",
"all",
"blocks",
"of",
"this",
"function",
"to",
"the",
"blanket",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfb.py#L174-L179 | train |
angr/angr | angr/analyses/cfg/cfb.py | CFBlanket.dbg_repr | def dbg_repr(self):
"""
The debugging representation of this CFBlanket.
:return: The debugging representation of this CFBlanket.
:rtype: str
"""
output = [ ]
for obj in self.project.loader.all_objects:
for section in obj.sections:
... | python | def dbg_repr(self):
"""
The debugging representation of this CFBlanket.
:return: The debugging representation of this CFBlanket.
:rtype: str
"""
output = [ ]
for obj in self.project.loader.all_objects:
for section in obj.sections:
... | [
"def",
"dbg_repr",
"(",
"self",
")",
":",
"output",
"=",
"[",
"]",
"for",
"obj",
"in",
"self",
".",
"project",
".",
"loader",
".",
"all_objects",
":",
"for",
"section",
"in",
"obj",
".",
"sections",
":",
"if",
"section",
".",
"memsize",
"==",
"0",
... | The debugging representation of this CFBlanket.
:return: The debugging representation of this CFBlanket.
:rtype: str | [
"The",
"debugging",
"representation",
"of",
"this",
"CFBlanket",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfb.py#L181-L212 | train |
angr/angr | angr/analyses/cfg/cfb.py | CFBlanket._from_cfg | 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
for func in cfg.kb.functions.values():
self.add_function(func)
self._mark_unknowns... | python | 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
for func in cfg.kb.functions.values():
self.add_function(func)
self._mark_unknowns... | [
"def",
"_from_cfg",
"(",
"self",
",",
"cfg",
")",
":",
"# Let's first add all functions first",
"for",
"func",
"in",
"cfg",
".",
"kb",
".",
"functions",
".",
"values",
"(",
")",
":",
"self",
".",
"add_function",
"(",
"func",
")",
"self",
".",
"_mark_unknow... | Initialize CFBlanket from a CFG instance.
:param cfg: A CFG instance.
:return: None | [
"Initialize",
"CFBlanket",
"from",
"a",
"CFG",
"instance",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfb.py#L214-L226 | train |
angr/angr | angr/analyses/cfg/cfb.py | CFBlanket._mark_unknowns | 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:
for section in obj.sections:
... | python | 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:
for section in obj.sections:
... | [
"def",
"_mark_unknowns",
"(",
"self",
")",
":",
"for",
"obj",
"in",
"self",
".",
"project",
".",
"loader",
".",
"all_objects",
":",
"if",
"isinstance",
"(",
"obj",
",",
"cle",
".",
"ELF",
")",
":",
"# sections?",
"if",
"obj",
".",
"sections",
":",
"f... | Mark all unmapped regions.
:return: None | [
"Mark",
"all",
"unmapped",
"regions",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfb.py#L228-L265 | train |
angr/angr | angr/simos/cgc.py | SimCGC.state_blank | 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
# Special stack base for CGC binaries to work with Shellphish CRS
... | python | 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
# Special stack base for CGC binaries to work with Shellphish CRS
... | [
"def",
"state_blank",
"(",
"self",
",",
"flag_page",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"s",
"=",
"super",
"(",
"SimCGC",
",",
"self",
")",
".",
"state_blank",
"(",
"*",
"*",
"kwargs",
")",
"# pylint:disable=invalid-name",
"# Special stack bas... | :param flag_page: Flag page content, either a string or a list of BV8s | [
":",
"param",
"flag_page",
":",
"Flag",
"page",
"content",
"either",
"a",
"string",
"or",
"a",
"list",
"of",
"BV8s"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/simos/cgc.py#L29-L68 | train |
angr/angr | angr/analyses/loop_analysis.py | SootBlockProcessor._stmt_inside_loop | 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 performance issue
for node in self.loop.body_nodes:
if node.addr.stmt_idx <= stmt_idx < n... | python | 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 performance issue
for node in self.loop.body_nodes:
if node.addr.stmt_idx <= stmt_idx < n... | [
"def",
"_stmt_inside_loop",
"(",
"self",
",",
"stmt_idx",
")",
":",
"# TODO: This is slow. Fix the performance issue",
"for",
"node",
"in",
"self",
".",
"loop",
".",
"body_nodes",
":",
"if",
"node",
".",
"addr",
".",
"stmt_idx",
"<=",
"stmt_idx",
"<",
"node",
... | Test whether a statement is inside the loop body or not.
:param stmt_idx:
:return: | [
"Test",
"whether",
"a",
"statement",
"is",
"inside",
"the",
"loop",
"body",
"or",
"not",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/loop_analysis.py#L85-L98 | train |
angr/angr | angr/analyses/loop_analysis.py | LoopAnalysis._is_bounded_iterator_based | def _is_bounded_iterator_based(self):
"""
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
"""
... | python | def _is_bounded_iterator_based(self):
"""
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",
")",
":",
"# Condition 0",
"check_0",
"=",
"lambda",
"cond",
":",
"(",
"isinstance",
"(",
"cond",
",",
"Condition",
")",
"and",
"cond",
".",
"op",
"==",
"Condition",
".",
"Equal",
"and",
"cond",
".",
"val1"... | 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 | [
"Iterator",
"based",
"check",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/loop_analysis.py#L329-L363 | train |
angr/angr | angr/analyses/reaching_definitions/reaching_definitions.py | LiveDefinitions.kill_definitions | def kill_definitions(self, atom, code_loc, data=None, dummy=True):
"""
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 objec... | python | def kill_definitions(self, atom, code_loc, data=None, dummy=True):
"""
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 objec... | [
"def",
"kill_definitions",
"(",
"self",
",",
"atom",
",",
"code_loc",
",",
"data",
"=",
"None",
",",
"dummy",
"=",
"True",
")",
":",
"if",
"data",
"is",
"None",
":",
"data",
"=",
"DataSet",
"(",
"Undefined",
"(",
"atom",
".",
"size",
")",
",",
"ato... | 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 | [
"Overwrite",
"existing",
"definitions",
"w",
".",
"r",
".",
"t",
"atom",
"with",
"a",
"dummy",
"definition",
"instance",
".",
"A",
"dummy",
"definition",
"will",
"not",
"be",
"removed",
"during",
"simplification",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/reaching_definitions/reaching_definitions.py#L149-L163 | train |
angr/angr | angr/simos/javavm.py | SimJavaVM.state_entry | 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(**kwargs)
# for the Java main method `public static main(String[] args)`,
#... | python | 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(**kwargs)
# for the Java main method `public static main(String[] args)`,
#... | [
"def",
"state_entry",
"(",
"self",
",",
"args",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"# pylint: disable=arguments-differ",
"state",
"=",
"self",
".",
"state_blank",
"(",
"*",
"*",
"kwargs",
")",
"# for the Java main method `public static main(String[] arg... | Create an entry state.
:param args: List of SootArgument values (optional). | [
"Create",
"an",
"entry",
"state",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/simos/javavm.py#L161-L180 | train |
angr/angr | angr/simos/javavm.py | SimJavaVM.generate_symbolic_cmd_line_arg | 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.memory.get_new_uuid())
str_sym = StringS("cmd_line_arg", max_length)
state.... | python | 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.memory.get_new_uuid())
str_sym = StringS("cmd_line_arg", max_length)
state.... | [
"def",
"generate_symbolic_cmd_line_arg",
"(",
"state",
",",
"max_length",
"=",
"1000",
")",
":",
"str_ref",
"=",
"SimSootValue_StringRef",
"(",
"state",
".",
"memory",
".",
"get_new_uuid",
"(",
")",
")",
"str_sym",
"=",
"StringS",
"(",
"\"cmd_line_arg\"",
",",
... | Generates a new symbolic cmd line argument string.
:return: The string reference. | [
"Generates",
"a",
"new",
"symbolic",
"cmd",
"line",
"argument",
"string",
".",
":",
"return",
":",
"The",
"string",
"reference",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/simos/javavm.py#L183-L192 | train |
angr/angr | angr/simos/javavm.py | SimJavaVM.state_call | def state_call(self, addr, *args, **kwargs):
"""
Create a native or a Java call state.
:param addr: Soot or native addr of the invoke target.
:param args: List of SootArgument values.
"""
state = kwargs.pop('base_state', None)
# check if we need to setup a n... | python | def state_call(self, addr, *args, **kwargs):
"""
Create a native or a Java call state.
:param addr: Soot or native addr of the invoke target.
:param args: List of SootArgument values.
"""
state = kwargs.pop('base_state', None)
# check if we need to setup a n... | [
"def",
"state_call",
"(",
"self",
",",
"addr",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"state",
"=",
"kwargs",
".",
"pop",
"(",
"'base_state'",
",",
"None",
")",
"# check if we need to setup a native or a java callsite",
"if",
"isinstance",
"(",
... | Create a native or a Java call state.
:param addr: Soot or native addr of the invoke target.
:param args: List of SootArgument values. | [
"Create",
"a",
"native",
"or",
"a",
"Java",
"call",
"state",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/simos/javavm.py#L194-L258 | train |
angr/angr | angr/simos/javavm.py | SimJavaVM.get_default_value_by_type | def get_default_value_by_type(type_, state=None):
"""
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.
"""
if... | python | def get_default_value_by_type(type_, state=None):
"""
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.
"""
if... | [
"def",
"get_default_value_by_type",
"(",
"type_",
",",
"state",
"=",
"None",
")",
":",
"if",
"type_",
"in",
"[",
"'byte'",
",",
"'char'",
",",
"'short'",
",",
"'int'",
",",
"'boolean'",
"]",
":",
"return",
"BVS",
"(",
"'default_value_{}'",
".",
"format",
... | 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. | [
"Java",
"specify",
"defaults",
"values",
"for",
"primitive",
"and",
"reference",
"types",
".",
"This",
"method",
"returns",
"the",
"default",
"value",
"for",
"a",
"given",
"type",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/simos/javavm.py#L265-L297 | train |
angr/angr | angr/simos/javavm.py | SimJavaVM.cast_primitive | def cast_primitive(state, value, to_type):
"""
Cast the value of primtive types.
:param value: Bitvector storing the primitive value.
:param to_type: Name of the targeted type.
:return: Resized value.
"""
if to_type in ['float', 'double']:
... | python | def cast_primitive(state, value, to_type):
"""
Cast the value of primtive types.
:param value: Bitvector storing the primitive value.
:param to_type: Name of the targeted type.
:return: Resized value.
"""
if to_type in ['float', 'double']:
... | [
"def",
"cast_primitive",
"(",
"state",
",",
"value",
",",
"to_type",
")",
":",
"if",
"to_type",
"in",
"[",
"'float'",
",",
"'double'",
"]",
":",
"if",
"value",
".",
"symbolic",
":",
"# TODO extend support for floating point types",
"l",
".",
"warning",
"(",
... | Cast the value of primtive types.
:param value: Bitvector storing the primitive value.
:param to_type: Name of the targeted type.
:return: Resized value. | [
"Cast",
"the",
"value",
"of",
"primtive",
"types",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/simos/javavm.py#L300-L339 | train |
angr/angr | angr/simos/javavm.py | SimJavaVM.init_static_field | def init_static_field(state, field_class_name, field_name, field_type):
"""
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.
:pa... | python | def init_static_field(state, field_class_name, field_name, field_type):
"""
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.
:pa... | [
"def",
"init_static_field",
"(",
"state",
",",
"field_class_name",
",",
"field_name",
",",
"field_type",
")",
":",
"field_ref",
"=",
"SimSootValue_StaticFieldRef",
".",
"get_ref",
"(",
"state",
",",
"field_class_name",
",",
"field_name",
",",
"field_type",
")",
"f... | 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 ... | [
"Initialize",
"the",
"static",
"field",
"with",
"an",
"allocated",
"but",
"not",
"initialized",
"object",
"of",
"the",
"given",
"type",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/simos/javavm.py#L342-L355 | train |
angr/angr | angr/simos/javavm.py | SimJavaVM.get_addr_of_native_method | def get_addr_of_native_method(self, soot_method):
"""
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.
"""
for name, symbol in self.nativ... | python | def get_addr_of_native_method(self, soot_method):
"""
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.
"""
for name, symbol in self.nativ... | [
"def",
"get_addr_of_native_method",
"(",
"self",
",",
"soot_method",
")",
":",
"for",
"name",
",",
"symbol",
"in",
"self",
".",
"native_symbols",
".",
"items",
"(",
")",
":",
"if",
"soot_method",
".",
"matches_with_native_name",
"(",
"native_method",
"=",
"nam... | 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. | [
"Get",
"address",
"of",
"the",
"implementation",
"from",
"a",
"native",
"declared",
"Java",
"function",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/simos/javavm.py#L373-L391 | train |
angr/angr | angr/simos/javavm.py | SimJavaVM.get_native_type | def get_native_type(self, java_type):
"""
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.
"""
if... | python | def get_native_type(self, java_type):
"""
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.
"""
if... | [
"def",
"get_native_type",
"(",
"self",
",",
"java_type",
")",
":",
"if",
"java_type",
"in",
"ArchSoot",
".",
"sizeof",
".",
"keys",
"(",
")",
":",
"jni_type_size",
"=",
"ArchSoot",
".",
"sizeof",
"[",
"java_type",
"]",
"else",
":",
"# if it's not a primitive... | 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. | [
"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",
"... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/simos/javavm.py#L393-L406 | train |
angr/angr | angr/simos/javavm.py | SimJavaVM.get_native_cc | 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) | python | 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) | [
"def",
"get_native_cc",
"(",
"self",
",",
"func_ty",
"=",
"None",
")",
":",
"native_cc_cls",
"=",
"DEFAULT_CC",
"[",
"self",
".",
"native_simos",
".",
"arch",
".",
"name",
"]",
"return",
"native_cc_cls",
"(",
"self",
".",
"native_simos",
".",
"arch",
",",
... | :return: SimCC object for the native simos. | [
":",
"return",
":",
"SimCC",
"object",
"for",
"the",
"native",
"simos",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/simos/javavm.py#L415-L420 | train |
angr/angr | angr/procedures/win32/sim_time.py | GetLocalTime.fill_symbolic | 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=('api', 'GetLocalTime', 'cur_month'))
sel... | python | 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=('api', 'GetLocalTime', 'cur_month'))
sel... | [
"def",
"fill_symbolic",
"(",
"self",
")",
":",
"self",
".",
"wYear",
"=",
"self",
".",
"state",
".",
"solver",
".",
"BVS",
"(",
"'cur_year'",
",",
"16",
",",
"key",
"=",
"(",
"'api'",
",",
"'GetLocalTime'",
",",
"'cur_year'",
")",
")",
"self",
".",
... | Fill the class with constrained symbolic values. | [
"Fill",
"the",
"class",
"with",
"constrained",
"symbolic",
"values",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/procedures/win32/sim_time.py#L61-L84 | train |
angr/angr | angr/procedures/win32/sim_time.py | GetLocalTime.fill_from_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 = datetime.datetime.fromtimestamp(ts)
self.wYear = dt.year
self.wMonth = dt.month
self.wDayOfWeek =... | python | def fill_from_timestamp(self, ts):
"""
Fill the class with the appropriate values extracted from the given timestamp.
:param ts: A POSIX timestamp.
"""
dt = datetime.datetime.fromtimestamp(ts)
self.wYear = dt.year
self.wMonth = dt.month
self.wDayOfWeek =... | [
"def",
"fill_from_timestamp",
"(",
"self",
",",
"ts",
")",
":",
"dt",
"=",
"datetime",
".",
"datetime",
".",
"fromtimestamp",
"(",
"ts",
")",
"self",
".",
"wYear",
"=",
"dt",
".",
"year",
"self",
".",
"wMonth",
"=",
"dt",
".",
"month",
"self",
".",
... | Fill the class with the appropriate values extracted from the given timestamp.
:param ts: A POSIX timestamp. | [
"Fill",
"the",
"class",
"with",
"the",
"appropriate",
"values",
"extracted",
"from",
"the",
"given",
"timestamp",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/procedures/win32/sim_time.py#L86-L100 | train |
angr/angr | angr/annocfg.py | AnnotatedCFG.from_digraph | def from_digraph(self, digraph):
"""
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.DiGra... | python | def from_digraph(self, digraph):
"""
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.DiGra... | [
"def",
"from_digraph",
"(",
"self",
",",
"digraph",
")",
":",
"for",
"n1",
"in",
"digraph",
".",
"nodes",
"(",
")",
":",
"addr1",
",",
"stmt_idx1",
"=",
"n1",
"self",
".",
"add_statements_to_whitelist",
"(",
"addr1",
",",
"(",
"stmt_idx1",
",",
")",
")... | 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 | [
"Initialize",
"this",
"AnnotatedCFG",
"object",
"with",
"a",
"networkx",
".",
"DiGraph",
"consisting",
"of",
"the",
"following",
"form",
"of",
"nodes",
":"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/annocfg.py#L49-L73 | train |
angr/angr | angr/annocfg.py | AnnotatedCFG.get_whitelisted_statements | 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 is the default value used to say
... | python | 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 is the default value used to say
... | [
"def",
"get_whitelisted_statements",
"(",
"self",
",",
"addr",
")",
":",
"if",
"addr",
"in",
"self",
".",
"_run_statement_whitelist",
":",
"if",
"self",
".",
"_run_statement_whitelist",
"[",
"addr",
"]",
"is",
"True",
":",
"return",
"None",
"# This is the defaul... | :returns: True if all statements are whitelisted | [
":",
"returns",
":",
"True",
"if",
"all",
"statements",
"are",
"whitelisted"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/annocfg.py#L140-L154 | train |
angr/angr | angr/annocfg.py | AnnotatedCFG.dbg_print_irsb | 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 is empty. " + \
"Give... | python | 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 is empty. " + \
"Give... | [
"def",
"dbg_print_irsb",
"(",
"self",
",",
"irsb_addr",
",",
"project",
"=",
"None",
")",
":",
"if",
"project",
"is",
"None",
":",
"project",
"=",
"self",
".",
"_project",
"if",
"project",
"is",
"None",
":",
"raise",
"Exception",
"(",
"\"Dict addr_to_run i... | Pretty-print an IRSB with whitelist information | [
"Pretty",
"-",
"print",
"an",
"IRSB",
"with",
"whitelist",
"information"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/annocfg.py#L200-L224 | train |
angr/angr | angr/annocfg.py | AnnotatedCFG.keep_path | 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_exit(path.addr_trace[-2], path.addr_trace[-1]) | python | 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_exit(path.addr_trace[-2], path.addr_trace[-1]) | [
"def",
"keep_path",
"(",
"self",
",",
"path",
")",
":",
"if",
"len",
"(",
"path",
".",
"addr_trace",
")",
"<",
"2",
":",
"return",
"True",
"return",
"self",
".",
"should_take_exit",
"(",
"path",
".",
"addr_trace",
"[",
"-",
"2",
"]",
",",
"path",
"... | Given a path, returns True if the path should be kept, False if it should be cut. | [
"Given",
"a",
"path",
"returns",
"True",
"if",
"the",
"path",
"should",
"be",
"kept",
"False",
"if",
"it",
"should",
"be",
"cut",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/annocfg.py#L230-L237 | train |
angr/angr | angr/annocfg.py | AnnotatedCFG.successor_func | def successor_func(self, path):
"""
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... | python | def successor_func(self, path):
"""
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... | [
"def",
"successor_func",
"(",
"self",
",",
"path",
")",
":",
"whitelist",
"=",
"self",
".",
"get_whitelisted_statements",
"(",
"path",
".",
"addr",
")",
"last_stmt",
"=",
"self",
".",
"get_last_statement_index",
"(",
"path",
".",
"addr",
")",
"# pass in those ... | 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. | [
"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",
"Path... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/annocfg.py#L262-L292 | train |
angr/angr | angr/storage/memory.py | AddressWrapper.to_valueset | def to_valueset(self, state):
"""
Convert to a ValueSet instance
:param state: A state
:return: The converted ValueSet instance
"""
return state.solver.VS(state.arch.bits, self.region, self.region_base_addr, self.address) | python | def to_valueset(self, state):
"""
Convert to a ValueSet instance
:param state: A state
:return: The converted ValueSet instance
"""
return state.solver.VS(state.arch.bits, self.region, self.region_base_addr, self.address) | [
"def",
"to_valueset",
"(",
"self",
",",
"state",
")",
":",
"return",
"state",
".",
"solver",
".",
"VS",
"(",
"state",
".",
"arch",
".",
"bits",
",",
"self",
".",
"region",
",",
"self",
".",
"region_base_addr",
",",
"self",
".",
"address",
")"
] | Convert to a ValueSet instance
:param state: A state
:return: The converted ValueSet instance | [
"Convert",
"to",
"a",
"ValueSet",
"instance"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L47-L54 | train |
angr/angr | angr/storage/memory.py | RegionMap.map | def map(self, absolute_address, region_id, related_function_address=None):
"""
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: ... | python | def map(self, absolute_address, region_id, related_function_address=None):
"""
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: ... | [
"def",
"map",
"(",
"self",
",",
"absolute_address",
",",
"region_id",
",",
"related_function_address",
"=",
"None",
")",
":",
"if",
"self",
".",
"is_stack",
":",
"# Sanity check",
"if",
"not",
"region_id",
".",
"startswith",
"(",
"'stack_'",
")",
":",
"raise... | 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... | [
"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"... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L129-L171 | train |
angr/angr | angr/storage/memory.py | RegionMap.unmap_by_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_region_id[absolute_address]
del self._address_to_region_id[absolute_address]
del self._reg... | python | 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_region_id[absolute_address]
del self._address_to_region_id[absolute_address]
del self._reg... | [
"def",
"unmap_by_address",
"(",
"self",
",",
"absolute_address",
")",
":",
"desc",
"=",
"self",
".",
"_address_to_region_id",
"[",
"absolute_address",
"]",
"del",
"self",
".",
"_address_to_region_id",
"[",
"absolute_address",
"]",
"del",
"self",
".",
"_region_id_t... | Removes a mapping based on its absolute address.
:param absolute_address: An absolute address | [
"Removes",
"a",
"mapping",
"based",
"on",
"its",
"absolute",
"address",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L173-L182 | train |
angr/angr | angr/storage/memory.py | RegionMap.absolutize | def absolutize(self, region_id, relative_address):
"""
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: ... | python | def absolutize(self, region_id, relative_address):
"""
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: ... | [
"def",
"absolutize",
"(",
"self",
",",
"region_id",
",",
"relative_address",
")",
":",
"if",
"region_id",
"==",
"'global'",
":",
"# The global region always bases 0",
"return",
"relative_address",
"if",
"region_id",
"not",
"in",
"self",
".",
"_region_id_to_address",
... | 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",
"a",
"relative",
"address",
"in",
"some",
"memory",
"region",
"to",
"an",
"absolute",
"address",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L184-L202 | train |
angr/angr | angr/storage/memory.py | RegionMap.relativize | def relativize(self, absolute_address, target_region_id=None):
"""
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 fram... | python | def relativize(self, absolute_address, target_region_id=None):
"""
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 fram... | [
"def",
"relativize",
"(",
"self",
",",
"absolute_address",
",",
"target_region_id",
"=",
"None",
")",
":",
"if",
"target_region_id",
"is",
"None",
":",
"if",
"self",
".",
"is_stack",
":",
"# Get the base address of the stack frame it belongs to",
"base_address",
"=",
... | 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... | [
"Convert",
"an",
"absolute",
"address",
"to",
"the",
"memory",
"offset",
"in",
"a",
"memory",
"region",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L204-L244 | train |
angr/angr | angr/storage/memory.py | SimMemory.category | 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 in ('reg', 'mem'):
return self.id
elif self._abstract_backer:
return 'mem'
elif se... | python | 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 in ('reg', 'mem'):
return self.id
elif self._abstract_backer:
return 'mem'
elif se... | [
"def",
"category",
"(",
"self",
")",
":",
"if",
"self",
".",
"id",
"in",
"(",
"'reg'",
",",
"'mem'",
")",
":",
"return",
"self",
".",
"id",
"elif",
"self",
".",
"_abstract_backer",
":",
"return",
"'mem'",
"elif",
"self",
".",
"id",
".",
"startswith",... | Return the category of this SimMemory instance. It can be one of the three following categories: reg, mem,
or file. | [
"Return",
"the",
"category",
"of",
"this",
"SimMemory",
"instance",
".",
"It",
"can",
"be",
"one",
"of",
"the",
"three",
"following",
"categories",
":",
"reg",
"mem",
"or",
"file",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L316-L332 | train |
angr/angr | angr/storage/memory.py | SimMemory.set_state | def set_state(self, state):
"""
Call the set_state method in SimStatePlugin class, and then perform the delayed initialization.
:param state: The SimState instance
"""
SimStatePlugin.set_state(self, state)
# Delayed initialization
stack_region_map, generic_regio... | python | def set_state(self, state):
"""
Call the set_state method in SimStatePlugin class, and then perform the delayed initialization.
:param state: The SimState instance
"""
SimStatePlugin.set_state(self, state)
# Delayed initialization
stack_region_map, generic_regio... | [
"def",
"set_state",
"(",
"self",
",",
"state",
")",
":",
"SimStatePlugin",
".",
"set_state",
"(",
"self",
",",
"state",
")",
"# Delayed initialization",
"stack_region_map",
",",
"generic_region_map",
"=",
"self",
".",
"_temp_stack_region_map",
",",
"self",
".",
... | Call the set_state method in SimStatePlugin class, and then perform the delayed initialization.
:param state: The SimState instance | [
"Call",
"the",
"set_state",
"method",
"in",
"SimStatePlugin",
"class",
"and",
"then",
"perform",
"the",
"delayed",
"initialization",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L341-L365 | train |
angr/angr | angr/storage/memory.py | SimMemory._convert_to_ast | 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
data_e = self.state.solver.BV... | python | 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
data_e = self.state.solver.BV... | [
"def",
"_convert_to_ast",
"(",
"self",
",",
"data_e",
",",
"size_e",
"=",
"None",
")",
":",
"if",
"type",
"(",
"data_e",
")",
"is",
"bytes",
":",
"# Convert the string into a BVV, *regardless of endness*",
"bits",
"=",
"len",
"(",
"data_e",
")",
"*",
"self",
... | Make an AST out of concrete @data_e | [
"Make",
"an",
"AST",
"out",
"of",
"concrete"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L397-L411 | train |
angr/angr | angr/storage/memory.py | SimMemory.set_stack_address_mapping | def set_stack_address_mapping(self, absolute_address, region_id, related_function_address=None):
"""
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.
:par... | python | def set_stack_address_mapping(self, absolute_address, region_id, related_function_address=None):
"""
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.
:par... | [
"def",
"set_stack_address_mapping",
"(",
"self",
",",
"absolute_address",
",",
"region_id",
",",
"related_function_address",
"=",
"None",
")",
":",
"if",
"self",
".",
"_stack_region_map",
"is",
"None",
":",
"raise",
"SimMemoryError",
"(",
"'Stack region map is not ini... | 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. | [
"Create",
"a",
"new",
"mapping",
"between",
"an",
"absolute",
"address",
"(",
"which",
"is",
"the",
"base",
"address",
"of",
"a",
"specific",
"stack",
"frame",
")",
"and",
"a",
"region",
"ID",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L413-L424 | train |
angr/angr | angr/storage/memory.py | SimMemory.unset_stack_address_mapping | def unset_stack_address_mapping(self, absolute_address):
"""
Remove a stack mapping.
:param absolute_address: An absolute memory address, which is the base address of the stack frame to destroy.
"""
if self._stack_region_map is None:
raise SimMemoryError('Stack regio... | python | def unset_stack_address_mapping(self, absolute_address):
"""
Remove a stack mapping.
:param absolute_address: An absolute memory address, which is the base address of the stack frame to destroy.
"""
if self._stack_region_map is None:
raise SimMemoryError('Stack regio... | [
"def",
"unset_stack_address_mapping",
"(",
"self",
",",
"absolute_address",
")",
":",
"if",
"self",
".",
"_stack_region_map",
"is",
"None",
":",
"raise",
"SimMemoryError",
"(",
"'Stack region map is not initialized.'",
")",
"self",
".",
"_stack_region_map",
".",
"unma... | Remove a stack mapping.
:param absolute_address: An absolute memory address, which is the base address of the stack frame to destroy. | [
"Remove",
"a",
"stack",
"mapping",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L426-L434 | train |
angr/angr | angr/storage/memory.py | SimMemory.stack_id | def stack_id(self, function_address):
"""
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 cal... | python | def stack_id(self, function_address):
"""
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 cal... | [
"def",
"stack_id",
"(",
"self",
",",
"function_address",
")",
":",
"region_id",
"=",
"'stack_0x%x'",
"%",
"function_address",
"# deduplication",
"region_ids",
"=",
"self",
".",
"_stack_region_map",
".",
"region_ids",
"if",
"region_id",
"not",
"in",
"region_ids",
"... | 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... | [
"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",
... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L436-L460 | train |
angr/angr | angr/storage/memory.py | SimMemory.store | def store(self, addr, data, size=None, condition=None, add_constraints=None, endness=None, action=None,
inspect=True, priv=None, disable_actions=False):
"""
Stores content into memory.
:param addr: A claripy expression representing the address to store at.
:param da... | python | def store(self, addr, data, size=None, condition=None, add_constraints=None, endness=None, action=None,
inspect=True, priv=None, disable_actions=False):
"""
Stores content into memory.
:param addr: A claripy expression representing the address to store at.
:param da... | [
"def",
"store",
"(",
"self",
",",
"addr",
",",
"data",
",",
"size",
"=",
"None",
",",
"condition",
"=",
"None",
",",
"add_constraints",
"=",
"None",
",",
"endness",
"=",
"None",
",",
"action",
"=",
"None",
",",
"inspect",
"=",
"True",
",",
"priv",
... | 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",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L462-L599 | train |
angr/angr | angr/storage/memory.py | SimMemory.store_cases | def store_cases(self, addr, contents, conditions, fallback=None, add_constraints=None, endness=None, action=None):
"""
Stores content into memory, conditional by case.
:param addr: A claripy expression representing the address to store at.
:param contents: A list of bi... | python | def store_cases(self, addr, contents, conditions, fallback=None, add_constraints=None, endness=None, action=None):
"""
Stores content into memory, conditional by case.
:param addr: A claripy expression representing the address to store at.
:param contents: A list of bi... | [
"def",
"store_cases",
"(",
"self",
",",
"addr",
",",
"contents",
",",
"conditions",
",",
"fallback",
"=",
"None",
",",
"add_constraints",
"=",
"None",
",",
"endness",
"=",
"None",
",",
"action",
"=",
"None",
")",
":",
"if",
"fallback",
"is",
"None",
"a... | 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... | [
"Stores",
"content",
"into",
"memory",
"conditional",
"by",
"case",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L604-L660 | train |
angr/angr | angr/storage/memory.py | SimMemory.load | def load(self, addr, size=None, condition=None, fallback=None, add_constraints=None, action=None, endness=None,
inspect=True, disable_actions=False, ret_on_segv=False):
"""
Loads size bytes from dst.
:param dst: The address to load from.
:param size: ... | python | def load(self, addr, size=None, condition=None, fallback=None, add_constraints=None, action=None, endness=None,
inspect=True, disable_actions=False, ret_on_segv=False):
"""
Loads size bytes from dst.
:param dst: The address to load from.
:param size: ... | [
"def",
"load",
"(",
"self",
",",
"addr",
",",
"size",
"=",
"None",
",",
"condition",
"=",
"None",
",",
"fallback",
"=",
"None",
",",
"add_constraints",
"=",
"None",
",",
"action",
"=",
"None",
",",
"endness",
"=",
"None",
",",
"inspect",
"=",
"True",... | 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... | [
"Loads",
"size",
"bytes",
"from",
"dst",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L701-L836 | train |
angr/angr | angr/storage/memory.py | SimMemory.find | def find(self, addr, what, max_search=None, max_symbolic_bytes=None, default=None, step=1,
disable_actions=False, inspect=True, chunk_size=None):
"""
Returns the address of bytes equal to 'what', starting from 'start'. Note that, if you don't specify a default
value, this search co... | python | def find(self, addr, what, max_search=None, max_symbolic_bytes=None, default=None, step=1,
disable_actions=False, inspect=True, chunk_size=None):
"""
Returns the address of bytes equal to 'what', starting from 'start'. Note that, if you don't specify a default
value, this search co... | [
"def",
"find",
"(",
"self",
",",
"addr",
",",
"what",
",",
"max_search",
"=",
"None",
",",
"max_symbolic_bytes",
"=",
"None",
",",
"default",
"=",
"None",
",",
"step",
"=",
"1",
",",
"disable_actions",
"=",
"False",
",",
"inspect",
"=",
"True",
",",
... | 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;... | [
"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... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L858-L888 | train |
angr/angr | angr/storage/memory.py | SimMemory.copy_contents | def copy_contents(self, dst, src, size, condition=None, src_memory=None, dst_memory=None, inspect=True,
disable_actions=False):
"""
Copies data within a memory.
:param dst: A claripy expression representing the address of the destination
:param src: ... | python | def copy_contents(self, dst, src, size, condition=None, src_memory=None, dst_memory=None, inspect=True,
disable_actions=False):
"""
Copies data within a memory.
:param dst: A claripy expression representing the address of the destination
:param src: ... | [
"def",
"copy_contents",
"(",
"self",
",",
"dst",
",",
"src",
",",
"size",
",",
"condition",
"=",
"None",
",",
"src_memory",
"=",
"None",
",",
"dst_memory",
"=",
"None",
",",
"inspect",
"=",
"True",
",",
"disable_actions",
"=",
"False",
")",
":",
"dst",... | 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... | [
"Copies",
"data",
"within",
"a",
"memory",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/storage/memory.py#L894-L916 | train |
angr/angr | angr/analyses/datagraph_meta.py | DataGraphMeta._vfg_node | 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" % addr) | python | 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" % addr) | [
"def",
"_vfg_node",
"(",
"self",
",",
"addr",
")",
":",
"for",
"n",
"in",
"self",
".",
"_vfg",
".",
"_nodes",
".",
"values",
"(",
")",
":",
"if",
"n",
".",
"addr",
"==",
"addr",
":",
"return",
"n",
"raise",
"DataGraphError",
"(",
"\"No VFG node at 0x... | Gets vfg node at @addr
Returns VFGNode or None | [
"Gets",
"vfg",
"node",
"at"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/datagraph_meta.py#L17-L25 | train |
angr/angr | angr/analyses/datagraph_meta.py | DataGraphMeta.pp | def pp(self, imarks=False):
"""
Pretty print the graph. @imarks determine whether the printed graph
represents instructions (coarse grained) for easier navigation, or
exact statements.
"""
for e in self.graph.edges():
data = dict(self.graph.get_edge_data(e[0... | python | def pp(self, imarks=False):
"""
Pretty print the graph. @imarks determine whether the printed graph
represents instructions (coarse grained) for easier navigation, or
exact statements.
"""
for e in self.graph.edges():
data = dict(self.graph.get_edge_data(e[0... | [
"def",
"pp",
"(",
"self",
",",
"imarks",
"=",
"False",
")",
":",
"for",
"e",
"in",
"self",
".",
"graph",
".",
"edges",
"(",
")",
":",
"data",
"=",
"dict",
"(",
"self",
".",
"graph",
".",
"get_edge_data",
"(",
"e",
"[",
"0",
"]",
",",
"e",
"["... | Pretty print the graph. @imarks determine whether the printed graph
represents instructions (coarse grained) for easier navigation, or
exact statements. | [
"Pretty",
"print",
"the",
"graph",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/datagraph_meta.py#L33-L42 | train |
angr/angr | angr/analyses/datagraph_meta.py | DataGraphMeta._branch | def _branch(self, live_defs, node, path=""):
"""
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
... | python | def _branch(self, live_defs, node, path=""):
"""
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",
"=",
"\"\"",
")",
":",
"irsb",
"=",
"self",
".",
"_irsb",
"(",
"node",
".",
"state",
")",
"path",
"=",
"path",
"+",
"\" -> \"",
"+",
"hex",
"(",
"irsb",
".",
"addr",
")",
... | 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 | [
"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",
"starti... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/datagraph_meta.py#L55-L92 | train |
angr/angr | angr/state_plugins/abstract_memory.py | MemoryRegion.get_abstract_locations | def get_abstract_locations(self, addr, size):
"""
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:... | python | def get_abstract_locations(self, addr, size):
"""
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:... | [
"def",
"get_abstract_locations",
"(",
"self",
",",
"addr",
",",
"size",
")",
":",
"ret",
"=",
"[",
"]",
"for",
"aloc",
"in",
"self",
".",
"_alocs",
".",
"values",
"(",
")",
":",
"for",
"seg",
"in",
"aloc",
".",
"segments",
":",
"if",
"seg",
".",
... | 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: ... | [
"Get",
"a",
"list",
"of",
"abstract",
"locations",
"that",
"is",
"within",
"the",
"range",
"of",
"[",
"addr",
"addr",
"+",
"size",
"]"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/abstract_memory.py#L68-L87 | train |
angr/angr | angr/state_plugins/abstract_memory.py | MemoryRegion._merge_alocs | 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()
merging_occurred = True... | python | 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()
merging_occurred = True... | [
"def",
"_merge_alocs",
"(",
"self",
",",
"other_region",
")",
":",
"merging_occurred",
"=",
"False",
"for",
"aloc_id",
",",
"aloc",
"in",
"other_region",
".",
"alocs",
".",
"items",
"(",
")",
":",
"if",
"aloc_id",
"not",
"in",
"self",
".",
"alocs",
":",
... | Helper function for merging. | [
"Helper",
"function",
"for",
"merging",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/abstract_memory.py#L132-L144 | train |
angr/angr | angr/state_plugins/abstract_memory.py | MemoryRegion.dbg_print | 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:" % (" " * indent))
self.me... | python | 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:" % (" " * indent))
self.me... | [
"def",
"dbg_print",
"(",
"self",
",",
"indent",
"=",
"0",
")",
":",
"print",
"(",
"\"%sA-locs:\"",
"%",
"(",
"\" \"",
"*",
"indent",
")",
")",
"for",
"aloc_id",
",",
"aloc",
"in",
"self",
".",
"_alocs",
".",
"items",
"(",
")",
":",
"print",
"(",
... | Print out debugging information | [
"Print",
"out",
"debugging",
"information"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/abstract_memory.py#L168-L177 | train |
angr/angr | angr/state_plugins/abstract_memory.py | SimAbstractMemory._region_base | def _region_base(self, region):
"""
Get the base address of a memory region.
:param str region: ID of the memory region
:return: Address of the memory region
:rtype: int
"""
if region == 'global':
region_base_addr = 0
elif region.startswith('... | python | def _region_base(self, region):
"""
Get the base address of a memory region.
:param str region: ID of the memory region
:return: Address of the memory region
:rtype: int
"""
if region == 'global':
region_base_addr = 0
elif region.startswith('... | [
"def",
"_region_base",
"(",
"self",
",",
"region",
")",
":",
"if",
"region",
"==",
"'global'",
":",
"region_base_addr",
"=",
"0",
"elif",
"region",
".",
"startswith",
"(",
"'stack_'",
")",
":",
"region_base_addr",
"=",
"self",
".",
"_stack_region_map",
".",
... | Get the base address of a memory region.
:param str region: ID of the memory region
:return: Address of the memory region
:rtype: int | [
"Get",
"the",
"base",
"address",
"of",
"a",
"memory",
"region",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/abstract_memory.py#L215-L231 | train |
angr/angr | angr/state_plugins/abstract_memory.py | SimAbstractMemory.create_region | def create_region(self, key, state, is_stack, related_function_addr, endness, backer_dict=None):
"""
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 bo... | python | def create_region(self, key, state, is_stack, related_function_addr, endness, backer_dict=None):
"""
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 bo... | [
"def",
"create_region",
"(",
"self",
",",
"key",
",",
"state",
",",
"is_stack",
",",
"related_function_addr",
",",
"endness",
",",
"backer_dict",
"=",
"None",
")",
":",
"self",
".",
"_regions",
"[",
"key",
"]",
"=",
"MemoryRegion",
"(",
"key",
",",
"stat... | 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 ... | [
"Create",
"a",
"new",
"MemoryRegion",
"with",
"the",
"region",
"key",
"specified",
"and",
"store",
"it",
"to",
"self",
".",
"_regions",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/abstract_memory.py#L236-L255 | train |
angr/angr | angr/state_plugins/abstract_memory.py | SimAbstractMemory._normalize_address | def _normalize_address(self, region_id, relative_address, target_region=None):
"""
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... | python | def _normalize_address(self, region_id, relative_address, target_region=None):
"""
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... | [
"def",
"_normalize_address",
"(",
"self",
",",
"region_id",
",",
"relative_address",
",",
"target_region",
"=",
"None",
")",
":",
"if",
"self",
".",
"_stack_region_map",
".",
"is_empty",
"and",
"self",
".",
"_generic_region_map",
".",
"is_empty",
":",
"# We don'... | 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... | [
"If",
"this",
"is",
"a",
"stack",
"address",
"we",
"convert",
"it",
"to",
"a",
"correct",
"region",
"and",
"address"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/abstract_memory.py#L257-L298 | train |
angr/angr | angr/state_plugins/abstract_memory.py | SimAbstractMemory.set_state | def set_state(self, state):
"""
Overriding the SimStatePlugin.set_state() method
:param state: A SimState object
:return: None
"""
# Sanity check
if REGION_MAPPING not in state.options:
# add REGION_MAPPING into state.options
l.warning('O... | python | def set_state(self, state):
"""
Overriding the SimStatePlugin.set_state() method
:param state: A SimState object
:return: None
"""
# Sanity check
if REGION_MAPPING not in state.options:
# add REGION_MAPPING into state.options
l.warning('O... | [
"def",
"set_state",
"(",
"self",
",",
"state",
")",
":",
"# Sanity check",
"if",
"REGION_MAPPING",
"not",
"in",
"state",
".",
"options",
":",
"# add REGION_MAPPING into state.options",
"l",
".",
"warning",
"(",
"'Option \"REGION_MAPPING\" must be enabled when using SimAbs... | Overriding the SimStatePlugin.set_state() method
:param state: A SimState object
:return: None | [
"Overriding",
"the",
"SimStatePlugin",
".",
"set_state",
"()",
"method"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/abstract_memory.py#L300-L329 | train |
angr/angr | angr/state_plugins/abstract_memory.py | SimAbstractMemory.normalize_address | def normalize_address(self, addr, is_write=False, convert_to_valueset=False, target_region=None, condition=None): #pylint:disable=arguments-differ
"""
Convert a ValueSet object into a list of addresses.
:param addr: A ValueSet object (which describes an address)
:param is_write: Is this... | python | def normalize_address(self, addr, is_write=False, convert_to_valueset=False, target_region=None, condition=None): #pylint:disable=arguments-differ
"""
Convert a ValueSet object into a list of addresses.
:param addr: A ValueSet object (which describes an address)
:param is_write: Is this... | [
"def",
"normalize_address",
"(",
"self",
",",
"addr",
",",
"is_write",
"=",
"False",
",",
"convert_to_valueset",
"=",
"False",
",",
"target_region",
"=",
"None",
",",
"condition",
"=",
"None",
")",
":",
"#pylint:disable=arguments-differ",
"targets_limit",
"=",
"... | 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",
"a",
"ValueSet",
"object",
"into",
"a",
"list",
"of",
"addresses",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/abstract_memory.py#L331-L380 | train |
angr/angr | angr/state_plugins/abstract_memory.py | SimAbstractMemory._normalize_address_type | def _normalize_address_type(self, addr): #pylint:disable=no-self-use
"""
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... | python | def _normalize_address_type(self, addr): #pylint:disable=no-self-use
"""
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... | [
"def",
"_normalize_address_type",
"(",
"self",
",",
"addr",
")",
":",
"#pylint:disable=no-self-use",
"addr_e",
"=",
"_raw_ast",
"(",
"addr",
")",
"if",
"isinstance",
"(",
"addr_e",
",",
"(",
"claripy",
".",
"bv",
".",
"BVV",
",",
"claripy",
".",
"vsa",
"."... | 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 | [
"Convert",
"address",
"of",
"different",
"types",
"to",
"a",
"list",
"of",
"mapping",
"between",
"region",
"IDs",
"and",
"offsets",
"(",
"strided",
"intervals",
")",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/abstract_memory.py#L382-L404 | train |
angr/angr | angr/state_plugins/abstract_memory.py | SimAbstractMemory.get_segments | def get_segments(self, addr, size):
"""
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
- Th... | python | def get_segments(self, addr, size):
"""
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
- Th... | [
"def",
"get_segments",
"(",
"self",
",",
"addr",
",",
"size",
")",
":",
"address_wrappers",
"=",
"self",
".",
"normalize_address",
"(",
"addr",
",",
"is_write",
"=",
"False",
")",
"# assert len(address_wrappers) > 0",
"aw",
"=",
"address_wrappers",
"[",
"0",
"... | 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 ... | [
"Get",
"a",
"segmented",
"memory",
"region",
"based",
"on",
"AbstractLocation",
"information",
"available",
"from",
"VSA",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/abstract_memory.py#L541-L605 | train |
angr/angr | angr/state_plugins/abstract_memory.py | SimAbstractMemory.copy | 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._stack_region_map,
generic_region_map=self._generic_r... | python | 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._stack_region_map,
generic_region_map=self._generic_r... | [
"def",
"copy",
"(",
"self",
",",
"memo",
")",
":",
"am",
"=",
"SimAbstractMemory",
"(",
"memory_id",
"=",
"self",
".",
"_memory_id",
",",
"endness",
"=",
"self",
".",
"endness",
",",
"stack_region_map",
"=",
"self",
".",
"_stack_region_map",
",",
"generic_... | Make a copy of this SimAbstractMemory object
:return: | [
"Make",
"a",
"copy",
"of",
"this",
"SimAbstractMemory",
"object",
":",
"return",
":"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/abstract_memory.py#L608-L622 | train |
angr/angr | angr/state_plugins/abstract_memory.py | SimAbstractMemory.merge | 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():
if region_id in self._regions:
... | python | 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():
if region_id in self._regions:
... | [
"def",
"merge",
"(",
"self",
",",
"others",
",",
"merge_conditions",
",",
"common_ancestor",
"=",
"None",
")",
":",
"merging_occurred",
"=",
"False",
"for",
"o",
"in",
"others",
":",
"for",
"region_id",
",",
"region",
"in",
"o",
".",
"_regions",
".",
"it... | Merge this guy with another SimAbstractMemory instance | [
"Merge",
"this",
"guy",
"with",
"another",
"SimAbstractMemory",
"instance"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/abstract_memory.py#L624-L640 | train |
angr/angr | angr/state_plugins/abstract_memory.py | SimAbstractMemory.dbg_print | 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) | python | 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) | [
"def",
"dbg_print",
"(",
"self",
")",
":",
"for",
"region_id",
",",
"region",
"in",
"self",
".",
"regions",
".",
"items",
"(",
")",
":",
"print",
"(",
"\"Region [%s]:\"",
"%",
"region_id",
")",
"region",
".",
"dbg_print",
"(",
"indent",
"=",
"2",
")"
] | Print out debugging information | [
"Print",
"out",
"debugging",
"information"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/abstract_memory.py#L699-L705 | train |
angr/angr | angr/procedures/glibc/__libc_start_main.py | __libc_start_main._initialize_toupper_loc_table | 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 entries, 4 bytes each
table = self.inline_call(malloc, 384*4).ret_expr
table... | python | 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 entries, 4 bytes each
table = self.inline_call(malloc, 384*4).ret_expr
table... | [
"def",
"_initialize_toupper_loc_table",
"(",
"self",
")",
":",
"malloc",
"=",
"angr",
".",
"SIM_PROCEDURES",
"[",
"'libc'",
"]",
"[",
"'malloc'",
"]",
"# 384 entries, 4 bytes each",
"table",
"=",
"self",
".",
"inline_call",
"(",
"malloc",
",",
"384",
"*",
"4",... | Initialize ptable for ctype
See __ctype_toupper_loc.c in libc implementation | [
"Initialize",
"ptable",
"for",
"ctype"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/procedures/glibc/__libc_start_main.py#L80-L109 | train |
angr/angr | angr/procedures/glibc/__libc_start_main.py | __libc_start_main._extract_args | def _extract_args(state, main, argc, argv, init, fini):
"""
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 t... | python | def _extract_args(state, main, argc, argv, init, fini):
"""
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 t... | [
"def",
"_extract_args",
"(",
"state",
",",
"main",
",",
"argc",
",",
"argv",
",",
"init",
",",
"fini",
")",
":",
"main_",
"=",
"main",
"argc_",
"=",
"argc",
"argv_",
"=",
"argv",
"init_",
"=",
"init",
"fini_",
"=",
"fini",
"if",
"state",
".",
"arch... | 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.
... | [
"Extract",
"arguments",
"and",
"set",
"them",
"to"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/procedures/glibc/__libc_start_main.py#L177-L210 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice.dbg_repr | def dbg_repr(self, max_display=10):
"""
Debugging output of this slice.
:param max_display: The maximum number of SimRun slices to show.
:return: A string representation.
"""
s = repr(self) + "\n"
if len(self.chosen_statements) > max_display:
... | python | def dbg_repr(self, max_display=10):
"""
Debugging output of this slice.
:param max_display: The maximum number of SimRun slices to show.
:return: A string representation.
"""
s = repr(self) + "\n"
if len(self.chosen_statements) > max_display:
... | [
"def",
"dbg_repr",
"(",
"self",
",",
"max_display",
"=",
"10",
")",
":",
"s",
"=",
"repr",
"(",
"self",
")",
"+",
"\"\\n\"",
"if",
"len",
"(",
"self",
".",
"chosen_statements",
")",
">",
"max_display",
":",
"s",
"+=",
"\"%d SimRuns in program slice, displa... | Debugging output of this slice.
:param max_display: The maximum number of SimRun slices to show.
:return: A string representation. | [
"Debugging",
"output",
"of",
"this",
"slice",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L97-L124 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice.dbg_repr_run | def dbg_repr_run(self, run_addr):
"""
Debugging output of a single SimRun slice.
:param run_addr: Address of the SimRun.
:return: A string representation.
"""
if self.project.is_hooked(run_addr):
ss = "%#x Hooked\n" % run_addr
else:
... | python | def dbg_repr_run(self, run_addr):
"""
Debugging output of a single SimRun slice.
:param run_addr: Address of the SimRun.
:return: A string representation.
"""
if self.project.is_hooked(run_addr):
ss = "%#x Hooked\n" % run_addr
else:
... | [
"def",
"dbg_repr_run",
"(",
"self",
",",
"run_addr",
")",
":",
"if",
"self",
".",
"project",
".",
"is_hooked",
"(",
"run_addr",
")",
":",
"ss",
"=",
"\"%#x Hooked\\n\"",
"%",
"run_addr",
"else",
":",
"ss",
"=",
"\"%#x\\n\"",
"%",
"run_addr",
"# statements"... | Debugging output of a single SimRun slice.
:param run_addr: Address of the SimRun.
:return: A string representation. | [
"Debugging",
"output",
"of",
"a",
"single",
"SimRun",
"slice",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L126-L166 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.