def _get_sink_and_atom(self, inst: 'Instance'):
if self.func_addr is not None:
sinks = [func for func in inst.kb.functions.values() if func.addr == self.func_addr]
if not sinks:
return None, None
sink: Function = sinks[0]
if sink.calling_convention is not None:
cc: SimCC = sink.calling_convention
else:
cc: SimCC = DEFAULT_CC[inst.project.arch.name](inst.project.arch)
# TODO: Handle stack-passing arguments
# TODO: Handle variadic arguments
arg_locs = cc.arg_locs(None)
arg = arg_locs[self.func_arg_idx]
# convert arg into atom
if isinstance(arg, SimRegArg):
atom = Register(inst.project.arch.registers[arg.reg_name][0],
arg.size)
return sink, atom
else:
raise NotImplementedError()
return None, None
def test_add_dependencies_for_concrete_pointers_of_adds_a_definition_with_codelocation_in_binary_if_data_in_readonly_memory(
self):
arch = self.ArchMock()
writable = False
loader = self.LoaderMock(
self.MainObjectMock(self.SectionMock(writable)))
memory_datum = self.MemoryDataMock(self.memory_address,
str.encode(self.string_in_memory),
len(self.string_in_memory),
'string')
cfg = self.CFGMock({self.memory_address: memory_datum})
register_definition = Definition(
Register(0, 4),
CodeLocation(0x42, 0),
)
dependency_graph = DepGraph()
dependency_graph.add_node(register_definition)
dependency_graph.add_dependencies_for_concrete_pointers_of(
[claripy.BVV(self.memory_address, arch.bits)],
register_definition,
cfg,
loader,
)
origin_codelocation = CodeLocation(0, 0, info={'readonly': True})
predecessor = list(
dependency_graph.graph.predecessors(register_definition))[0]
self.assertEqual(predecessor.codeloc, origin_codelocation)
def test_add_dependencies_for_concrete_pointers_of_does_nothing_if_data_pointed_to_by_definition_is_already_in_dependency_graph(
self):
arch = self.ArchMock()
loader = self.LoaderMock(self.MainObjectMock(self.SectionMock(True)))
memory_datum = self.MemoryDataMock(self.memory_address,
str.encode(self.string_in_memory),
len(self.string_in_memory),
'string')
cfg = self.CFGMock({self.memory_address: memory_datum})
memory_location_definition = Definition(
MemoryLocation(self.memory_address, self.string_in_memory_length),
CodeLocation(0, 0),
)
register_definition = Definition(
Register(0, 4),
CodeLocation(0x42, 0),
)
dependency_graph = DepGraph(
networkx.DiGraph([(memory_location_definition, register_definition)
]))
nodes_before_call = dependency_graph.nodes()
dependency_graph.add_dependencies_for_concrete_pointers_of(
[claripy.BVV(self.memory_address, arch.bits)], register_definition,
cfg, loader)
self.assertEqual(nodes_before_call, dependency_graph.nodes())
def test_add_dependencies_for_concrete_pointers_of_adds_a_definition_for_data_pointed_to_by_given_definition(
self):
arch = self.ArchMock()
loader = self.LoaderMock(self.MainObjectMock(self.SectionMock(True)))
memory_datum = self.MemoryDataMock(self.memory_address,
str.encode(self.string_in_memory),
len(self.string_in_memory),
'string')
cfg = self.CFGMock({self.memory_address: memory_datum})
register_definition = Definition(
Register(0, 4),
None,
)
dependency_graph = DepGraph()
dependency_graph.add_node(register_definition)
dependency_graph.add_dependencies_for_concrete_pointers_of(
[claripy.BVV(self.memory_address, arch.bits)], register_definition,
cfg, loader)
memory_definition = Definition(
MemoryLocation(self.memory_address, self.string_in_memory_length),
ExternalCodeLocation(),
)
nodes = list(dependency_graph.nodes())
predecessors = list(
dependency_graph.graph.predecessors(register_definition))
self.assertEqual(nodes, [register_definition, memory_definition])
self.assertListEqual(predecessors, [memory_definition])
def test_add_dependencies_for_concrete_pointers_of_create_memory_location_with_undefined_data_if_data_pointed_to_by_definition_is_not_known(
self):
arch = self.ArchMock()
cfg = self.CFGMock({})
loader = self.LoaderMock(self.MainObjectMock(self.SectionMock(True)))
datum_content = None
datum_size = 0x4242
memory_datum = self.MemoryDataMock(self.memory_address, datum_content,
datum_size, 'unknown')
cfg = self.CFGMock({self.memory_address: memory_datum})
memory_definition = Definition(
MemoryLocation(self.memory_address, datum_size),
ExternalCodeLocation(), DataSet(UNDEFINED, datum_size * 8))
register_definition = Definition(
Register(0, 4), CodeLocation(0x42, 0),
DataSet(self.memory_address, arch.bits))
dependency_graph = DepGraph()
dependency_graph.add_node(register_definition)
dependency_graph.add_dependencies_for_concrete_pointers_of(
register_definition, cfg, loader)
nodes = list(dependency_graph.nodes())
predecessors = list(
dependency_graph.graph.predecessors(register_definition))
self.assertEqual(nodes, [register_definition, memory_definition])
self.assertListEqual(predecessors, [memory_definition])
def test_contains_atom_returns_false_if_the_dependency_graph_does_not_contain_a_definition_of_the_given_atom(
self):
dep_graph = DepGraph()
# A -> B
A = _a_mock_definition()
B = _a_mock_definition()
uses = [(A, B)]
for use in uses:
dep_graph.add_edge(*use)
result = dep_graph.contains_atom(Register(8, 4))
self.assertFalse(result)
def test_add_dependencies_for_concrete_pointers_of_fails_if_the_given_definition_is_not_in_the_graph(
self):
dependency_graph = DepGraph()
definition = Definition(Register(0, 4), CodeLocation(0x42, 0),
DataSet(UNDEFINED, 4))
with self.assertRaises(AssertionError) as cm:
dependency_graph.add_dependencies_for_concrete_pointers_of(
definition, None, None)
ex = cm.exception
self.assertEqual(
str(ex),
'The given Definition must be present in the given graph.')
def test_contains_atom_returns_true_if_the_dependency_graph_contains_a_definition_of_the_given_atom(
self):
dep_graph = DepGraph()
r0 = Register(8, 4)
# A -> B
A = _a_mock_definition(r0)
B = _a_mock_definition()
uses = [(A, B)]
for use in uses:
dep_graph.add_edge(*use)
result = dep_graph.contains_atom(r0)
self.assertTrue(result)
def test_add_dependencies_for_concrete_pointers_of_does_nothing_if_pointer_is_not_concrete(
self):
arch = self.ArchMock()
cfg = self.CFGMock({})
loader = self.LoaderMock(self.MainObjectMock(self.SectionMock(True)))
register_definition = Definition(Register(0, 4), CodeLocation(0x42, 0),
DataSet(UNDEFINED, arch.bits))
dependency_graph = DepGraph()
dependency_graph.add_node(register_definition)
nodes_before_call = dependency_graph.nodes()
dependency_graph.add_dependencies_for_concrete_pointers_of(
register_definition, cfg, loader)
self.assertEqual(nodes_before_call, dependency_graph.nodes())
mem_magic,target_mem_addr,mem_size = reg_name.split(",")
if target_mem_addr.startswith("0x"):
target_mem_addr = int(target_mem_addr,16)
else:
target_mem_addr = int(target_mem_addr)
if mem_size.startswith("0x"):
mem_size = int(mem_size,16)
else:
mem_size = int(mem_size)
target_atom = MemoryLocation(bv_sp_init+target_mem_addr,mem_size)
else:
reg_vex_offset, reg_vex_size = prj.arch.registers[config["register"].lower()]
print("Finding reg: %s index: %d size: %d" % (config["register"].lower(), reg_vex_offset, reg_vex_size))
target_atom = Register(reg_vex_offset, reg_vex_size)
obv_res = rd.observed_results[observation_point]
# reg_def = obv_res.register_definitions.load(reg_vex_offset, reg_vex_size)
# print(reg_def.values)
# def_info_list = []
# def_infos = []
# def get_predecessors_rc(di):
# for i in rd.dep_graph.predecessors(di):
# print("r ",i)
# def_infos.append(i.codeloc.ins_addr)
# get_predecessors_rc(i)
# for i in reg_def.values:
def setUp(self):
self.arch = archinfo.arch_arm.ArchARM()
sp_offset = self.arch.registers['sp'][0]
self.sp_register = Register(sp_offset, self.arch.bytes)
