def yatest_comments(self):
eas = []
for offset in range(0, 3):
for fn_cmt, fn_rpt, cmt, rpt, post, ant in tests:
ea = get_func_item(offset)
eas.append(ea)
logger.debug("setting at 0x%08X : %r, %r, %r, %r, %r, %r" %
(ea, fn_cmt, fn_rpt, cmt, rpt, post, ant))
if fn_cmt != None:
self.assertEqual(idc.SetFunctionCmt(ea, fn_cmt, False),
True)
if fn_rpt != None:
self.assertEqual(idc.SetFunctionCmt(ea, fn_rpt, True),
True)
if cmt != None:
self.assertEqual(idc.MakeComm(ea, cmt), True)
if rpt != None:
self.assertEqual(idc.MakeRptCmt(ea, rpt), True)
if post != None:
for i, txt in enumerate(post.split('\n')):
self.try_ext_lin(idc.ExtLinB, ea, i, txt)
if ant != None:
for i, txt in enumerate(ant.split('\n')):
self.try_ext_lin(idc.ExtLinA, ea, i, txt)
yaunit.save('comments', eas)
def test_create_struct_complex(self, in_stack):
ident, sida = self.get_function_sid(in_stack, local_size=complex_struc1_size)
self.assertNotEqual(sida, -1)
sidb = idc.AddStrucEx(0, 'create_struct_complex_sub_%d' % in_stack, 0)
self.assertNotEqual(sidb, -1)
self.create_complex(sida, sidb)
yaunit.save('create_struct_complex_%d' % in_stack, ident)
def yatest_enums(self):
values = []
for flag in flags:
for prefix, enum_width, is_bitfield, num_fields in tests:
name = '%s_%x_%d_%x' % (prefix, enum_width, is_bitfield, flag)
ea = None
eid = idc.AddEnum(-1, name, flag)
self.assertNotEqual(eid, idaapi.BADADDR)
if enum_width != 0:
idc.SetEnumWidth(eid, enum_width)
if is_bitfield:
self.assertTrue(idc.SetEnumBf(eid, True))
idc.SetEnumCmt(eid, prefix + 'cmt', False)
idc.SetEnumCmt(eid, prefix + 'rpt', True)
for n in range(0, num_fields):
field = '%s_%d' % (name , n)
cid = None
if is_bitfield:
self.assertEqual(idc.AddConstEx(eid, field, 1 << n, 1 << n), 0)
else:
self.assertEqual(idc.AddConst(eid, field, n), 0)
if n == 0:
ea = get_ea()
self.assertNotEqual(idaapi.op_enum(ea, 1, eid, 0), idaapi.BADADDR)
cid = idc.GetConstByName(field)
self.assertTrue(idc.SetConstCmt(cid, field + 'cmt', False))
#self.assertTrue(idc.SetConstCmt(cid, field + 'rpt', True))
values.append((name, ea))
yaunit.save('enums', values)
def yatest_create_struct_in_stack_vars_with_renaming(self):
"""
test creation of struct from stack vars
used to find a bug (structure is correctly applied on var if renamed)
"""
# create structure
ident, sida = self.get_function_sid_without_del(
True, local_size=complex_struc3_size, count_from_first_var=True)
self.assertNotEqual(sida, -1)
sidb = idc.AddStrucEx(0, 'create_struct_in_stack_vars_with_renaming',
0)
self.assertNotEqual(sidb, -1)
size = self.create_complex2(sidb, complex_struc3)
self.assertEqual(complex_struc3_size, size)
# set first var prototype
offset = idc.GetFirstMember(sida)
member_id = idc.GetMemberId(sida, offset)
self.assertNotEqual(member_id, -1)
self.assertTrue(
idc.SetType(member_id,
"create_struct_in_stack_vars_with_renaming* x;"))
self.assertEqual("create_struct_in_stack_vars_with_renaming *",
idc.GetType(idc.GetMemberId(sida, offset)))
idc.SetMemberName(sida, offset, "var1")
yaunit.save("create_struct_in_stack_vars_with_renaming", sida)
yaunit.save("create_struct_in_stack_vars_with_renaming_offset", offset)
def yatest_reference_views(self):
addr = yaunit.get_next_function()
f = idaapi.get_flags_novalue(addr)
while not idaapi.isNum1(f) and not idaapi.isOff(f, 1):
addr += idc.ItemSize(addr)
f = idaapi.get_flags_novalue(addr)
self.assertTrue(idaapi.set_offset(addr, self.operand, self.reference_addr))
yaunit.save('reference_view_addr', addr)
def yatest_bookmarks(self):
logger.info("yatest_bookmarks")
addrs = []
for i in range(0, 3):
addr = yaunit.get_next_function()
logger.info("yatest_bookmarks:0x%08X : %d", addr, i)
idc.MarkPosition(addr, 1, 1, 1, i+1, 'bookmark_%d' % i)
addrs.append(addr)
yaunit.save('bookmarks', addrs)
def yatest_function_flags(self):
addrs = []
for i, k in enumerate(flag_types):
addr = yaunit.get_next_function()
flags = idc.GetFunctionFlags(addr)
self.assertNotEqual(flags, -1)
self.assertEqual(idc.SetFunctionFlags(addr, flags | k), 1)
addrs.append(addr)
yaunit.save('function_flags', addrs)
def yatest_function_local_vars(self):
addr = yaunit.get_next_function(yaunit.has_locals)
frame = idaapi.get_frame(addr)
offset = 0
frame_size = idaapi.get_struc_size(frame.id)
while offset < frame_size:
if idc.SetMemberName(frame.id, offset, 'local_var'):
break
offset += 1
yaunit.save('function_with_local_vars', addr)
def yatest_reference_views(self):
eas = []
for (operand, is_num, reference) in tests:
ea = yaunit.get_next_function()
f = idaapi.get_flags_novalue(ea)
while not is_num(f) and not idaapi.isOff(f, operand):
ea += idc.ItemSize(ea)
f = idaapi.get_flags_novalue(ea)
self.assertTrue(idaapi.set_offset(ea, operand, reference))
eas.append(ea)
yaunit.save('reference_views', eas)
def yatest_hiddenareas(self):
logger.info("yatest_hiddenarea")
addrs = []
for i in range(0, 3):
addr = yaunit.get_next_function()
logger.info("yatest_hiddenarea:0x%08X : %d", addr, i)
ea2 = idaapi.nextaddr(addr)
idaapi.add_hidden_area(addr, ea2, "yatest_hiddenarea_%x" % addr,
"header", "footer", 0)
addrs.append(addr)
yaunit.save('hiddenarea', addrs)
def yatest_apply_struct(self):
addrs = []
# -1: struct, n: union
for k in range(-1, 4):
# find an integer operand in any function
addr = self.find_operand_addr()
addrs.append(addr)
# create struct
sid = idc.AddStrucEx(-1, 'apply_struct_%x' % (k + 1), 0)
self.assertNotEqual(sid, -1)
ftype = idaapi.FF_BYTE | idaapi.FF_DATA
# apply struct only
if k == -1:
# add struct fields
for x in xrange(0, 0x60):
self.assertEqual(
idc.AddStrucMember(sid, 'field_%x' % x, -1, ftype, -1,
1), 0)
path = idaapi.tid_array(1)
path[0] = sid
self.assertNotEqual(
self.custom_op_stroff(addr, path.cast(), 1),
idaapi.BADADDR)
continue
# create union
uid = idc.AddStrucEx(-1, 'apply_union_%x' % (k + 1), 1)
self.assertNotEqual(uid, -1)
for x in xrange(1, 0x10):
self.assertEqual(
idc.AddStrucMember(uid, 'union_%x' % x, -1, ftype, -1, 1),
0)
# add struct fields
for x in xrange(0, 0x60):
self.assertEqual(
idc.AddStrucMember(sid, 'field_%x' % x, -1,
idaapi.struflag(), uid, 1), 0)
# apply selected union field
fid = idc.GetMemberId(uid, k)
self.assertNotEqual(fid, -1)
path = idaapi.tid_array(2)
path[0] = sid
path[1] = fid
self.assertNotEqual(self.custom_op_stroff(addr, path.cast(), 2),
idaapi.BADADDR)
yaunit.save('apply_struct', addrs)
def yatest_rename_register(self):
eas = []
for offset in range(0, 2):
for operand in range(0, 2):
for i in range(0, 2):
ea = self.get_address_for_operand(offset, operand)
key = 'rename_register_%d_%d_%d' % (offset, operand, i)
eas.append((ea, operand, key))
func = idaapi.get_func(ea)
self.assertIsNotNone(func)
end = ea + idc.ItemSize(ea) if i == 0 else func.endEA
text = idc.GetOpnd(ea, operand)
self.assertEqual(
idaapi.add_regvar(func, ea, end, text, key, None),
idaapi.REGVAR_ERROR_OK)
yaunit.save('registers', eas)
def yatest_data_comments(self):
eas = []
for offset in range(0, 3):
for cmt, rpt, post, ant in tests_data:
ea = get_data_item()
eas.append(ea)
logger.debug(
"setting data comment at 0x%08X : %r, %r, %r, %r" %
(ea, cmt, rpt, post, ant))
if cmt != None:
idc.MakeComm(ea, cmt)
if rpt != None:
idc.MakeRptCmt(ea, rpt)
if post != None:
for i, txt in enumerate(post.split('\n')):
try_ext_lin(idc.ExtLinB, ea, i, txt)
if ant != None:
for i, txt in enumerate(ant.split('\n')):
try_ext_lin(idc.ExtLinA, ea, i, txt)
yaunit.save('data_comments', eas)
def yatest_code_comments(self):
eas = []
for offset in range(0, 3):
for cmt, rpt, post, ant in tests_code:
ea = get_code_item()
eas.append(ea)
logger.debug(
"setting code comment at 0x%08X : %r, %r, %r, %r" %
(ea, cmt, rpt, post, ant))
if cmt:
self.assertEqual(idc.MakeComm(ea, cmt), True)
if rpt:
self.assertEqual(idc.MakeRptCmt(ea, rpt), True)
if post:
for i, txt in enumerate(post.split('\n')):
self.try_ext_lin(idc.ExtLinB, ea, i, txt)
if ant:
for i, txt in enumerate(ant.split('\n')):
self.try_ext_lin(idc.ExtLinA, ea, i, txt)
yaunit.save('code_comments', eas)
def yatest_create_struct_in_stack_vars(self):
"""
test creation of struct from stack vars
used to find a bug when creating struct for stack vars and naming vars
"""
# create structure
ident, sida = self.get_function_sid_without_del(True, local_size=complex_struc3_size, count_from_first_var=True)
self.assertNotEqual(sida, -1)
sidb = idc.AddStrucEx(0, 'create_struct_in_stack_vars', 0)
self.assertNotEqual(sidb, -1)
size = self.create_complex2(sidb, complex_struc3)
self.assertEqual(complex_struc3_size, size)
# set first var prototype
offset = idc.GetFirstMember(sida)
member_id = idc.GetMemberId(sida, offset)
self.assertNotEqual(member_id, -1)
self.assertTrue(idc.SetType(member_id, "create_struct_in_stack_vars* x;"))
self.assertEqual("create_struct_in_stack_vars *",
idc.GetType(idc.GetMemberId(sida, offset)))
yaunit.save("create_struct_in_stack_vars", sida)
yaunit.save("create_struct_in_stack_vars_offset", offset)
def yatest_function_name(self):
addr = yaunit.get_next_function()
self.assertTrue(
idc.MakeNameEx(addr, 'some_new_function_name', idc.SN_PUBLIC))
yaunit.save('function_name', addr)
