def get_node_label(self, n):
item = self.items[n]
op = item.op
insn = item.cinsn
expr = item.cexpr
parts = [ida_hexrays.get_ctype_name(op)]
if op == ida_hexrays.cot_ptr:
parts.append(".%d" % expr.ptrsize)
elif op == ida_hexrays.cot_memptr:
parts.append(".%d (m=%d)" % (expr.ptrsize, expr.m))
elif op == ida_hexrays.cot_memref:
parts.append(" (m=%d)" % (expr.m, ))
elif op in [ida_hexrays.cot_obj, ida_hexrays.cot_var]:
name = self.get_expr_name(expr)
parts.append(".%d %s" % (expr.refwidth, name))
elif op in [
ida_hexrays.cot_num, ida_hexrays.cot_helper,
ida_hexrays.cot_str
]:
name = self.get_expr_name(expr)
parts.append(" %s" % (name, ))
elif op == ida_hexrays.cit_goto:
parts.append(" LABEL_%d" % insn.cgoto.label_num)
elif op == ida_hexrays.cit_asm:
parts.append("<asm statements; unsupported ATM>")
# parts.append(" %a.%d" % ())
parts.append("\\n")
parts.append("ea: %08X" % item.ea)
if item.is_expr() and not expr.type.empty():
parts.append("\\n")
tstr = expr.type._print()
parts.append(tstr if tstr else "?")
return "".join(parts)
def create_hint(self, vd):
if vd.get_current_item(ida_hexrays.USE_MOUSE):
lnnum = vd.cpos.lnnum
if lnnum < vd.cfunc.hdrlines:
return 0
lines = []
title = "HRDevHelper:"
sep = 30 * "-"
indent = 2 * " "
item = vd.item.it
op = item.op
is_expr = item.is_expr()
item_type = ida_hexrays.get_ctype_name(op)
item_ea = item.ea
lines.append("%s" % title)
lines.append("%s" % (len(title) * "="))
if is_expr:
name = item.cexpr.print1(None)
#name = ida_lines.tag_remove(name)
#name = ida_pro.str2user(name)
lines.append("%sName:\t%s" % (indent, name))
lines.append("%sType:\tc%ct_%s" %
(indent, "o" if is_expr else "i", item_type))
lines.append("%sea:\t%x" % (indent, item_ea))
lines.append("%s" % sep)
lines.append("")
custom_hints = "\n".join(lines)
return (2, custom_hints, len(lines))
return 0
def _update(self, vu):
if vu:
focus = None
if vu.get_current_item(ida_hexrays.USE_MOUSE):
focus = vu.item.e if vu.item.is_citem() else None
_ea = _exp = _type = _objid = "???"
if vu.get_current_item(ida_hexrays.USE_MOUSE):
item = vu.item.it
isexpr = item.is_expr()
item_type = ida_hexrays.get_ctype_name(item.op)
if isexpr:
_exp = item.cexpr.print1(None)
_exp = ida_lines.tag_remove(_exp)
_ea = "%x" % item.ea
_type = "c%ct_%s" % ("o" if isexpr else "i", item_type)
_objid = "%x" % item.obj_id
self.SetControlValue(self.lbl_ea, _ea)
self.SetControlValue(self.lbl_exp, _exp)
self.SetControlValue(self.lbl_op, _type)
self.SetControlValue(self.lbl_objid, _objid)
gd = graph_dumper_t()
gd.apply_to(vu.cfunc.body if not focus else focus, vu.cfunc.body)
expr = "(%s)" % " and\n".join(gd.lines)
tc = self.GetControlValue(self.mstr_pexp)
tc.text = expr
self.SetControlValue(self.mstr_pexp, tc)
self.SetControlValue(self.lbl_sea,
"%x" % ida_kernwin.get_screen_ea())
return
def get_node_label(self, n):
item = self.items[n]
op = item.op
insn = item.cinsn
expr = item.cexpr
parts = [ida_hexrays.get_ctype_name(op)]
if op == ida_hexrays.cot_ptr:
parts.append(".%d" % expr.ptrsize)
elif op == ida_hexrays.cot_memptr:
parts.append(".%d (m=%d)" % (expr.ptrsize, expr.m))
elif op == ida_hexrays.cot_memref:
parts.append(" (m=%d)" % (expr.m,))
elif op in [
ida_hexrays.cot_obj,
ida_hexrays.cot_var]:
name = self.get_expr_name(expr)
parts.append(".%d %s" % (expr.refwidth, name))
elif op in [
ida_hexrays.cot_num,
ida_hexrays.cot_helper,
ida_hexrays.cot_str]:
name = self.get_expr_name(expr)
parts.append(" %s" % (name,))
elif op == ida_hexrays.cit_goto:
parts.append(" LABEL_%d" % insn.cgoto.label_num)
elif op == ida_hexrays.cit_asm:
parts.append("<asm statements; unsupported ATM>")
# parts.append(" %a.%d" % ())
parts.append("\\n")
parts.append("ea: %08X" % item.ea)
if item.is_expr() and not expr.type.empty():
parts.append("\\n")
tstr = expr.type._print()
parts.append(tstr if tstr else "?")
return "".join(parts)
def ast_a_function(address):
try:
vfun = hexray.decompile(address)
#without this print the vfun has an empty ctree associated.
b = str(vfun)
itemstruct = {}
#itemstruct['src']=b
body = vfun.body
str(body)
treenodes = [x for x in vfun.treeitems]
for x in treenodes:
index = int(x.index)
treeitem = {}
treeitem['op_name'] = hexray.get_ctype_name(x.op)
x = x.to_specific_type
op = x.op
if op == hexray.cot_call:
#se e' una chiamata a funzione ci mettiamo il nome della funzione
#treeitem['opcall']=idaapi.get_func_name(x.obj_ea)
pass
elif op == hexray.cot_ptr:
pass
elif op == hexray.cot_memptr:
pass
elif op == hexray.cot_memref:
pass
elif op == hexray.cot_obj:
treeitem['name'] = idaapi.get_func_name(x.obj_ea)
elif op == hexray.cot_var:
treeitem['size'] = x.refwidth
#treeitem['varname'] = str(dir(x))
pass
elif op == hexray.cot_num:
#typeInfo = idaapi.tinfo_t()
treeitem['value'] = str(x.numval())
#treeitem['size'] = x.refwidth
#treeitem['formatname'] = str(x.n.nf.type_name)
pass
elif op == hexray.cot_helper:
pass
elif op == hexray.cot_str:
pass
try:
treeitem['parent_index'] = int(
vfun.body.find_parent_of(x).index)
except:
treeitem['parent_index'] = None
itemstruct[index] = treeitem
return itemstruct
except Exception as e:
return None
def dump(self):
print("%d items:" % len(self.items))
for idx, item in enumerate(self.items):
print("\t%d: %s" % (idx, ida_hexrays.get_ctype_name(item.op)))
# print("\t%d: %s" % (idx, self.get_node_label(idx)))
print("succs:")
for parent, s in enumerate(self.succs):
print("\t%d: %s" % (parent, s))
print("preds:")
for child, p in enumerate(self.preds):
print("\t%d: %s" % (child, p))
def replace_addr_tags(cfunc, s):
tag = "%c%c" % (il.COLOR_ON, il.COLOR_ADDR)
tag_size = len(tag)
ti = {}
p = s.find(tag)
while p != -1:
ti[s[p+tag_size:p+tag_size+il.COLOR_ADDR_SIZE]] = 0
p = s.find(tag, p+tag_size+il.COLOR_ADDR_SIZE)
for addr in ti.keys():
idx = int(addr, 16)
a = ida_hexrays.ctree_anchor_t()
a.value = idx
if a.is_valid_anchor() and a.is_citem_anchor():
item = cfunc.treeitems.at(a.get_index())
if item:
ctype_name = ida_hexrays.get_ctype_name(item.op)
s = s.replace(tag+addr, il.COLSTR("<%s>" % ctype_name, il.SCOLOR_AUTOCMT)+tag+addr)
return s
def get_node_label(self, n, highlight_node=False):
item = self.items[n]
op = item.op
insn = item.cinsn
expr = item.cexpr
type_name = ida_hexrays.get_ctype_name(op)
parts = []
if op == ida_hexrays.cot_ptr:
parts.append("%s.%d" % (type_name, expr.ptrsize))
elif op == ida_hexrays.cot_memptr:
parts.append("%s.%d (m=%d)" % (type_name, expr.ptrsize, expr.m))
elif op == ida_hexrays.cot_memref:
parts.append("%s (m=%d)" % (
type_name,
expr.m,
))
elif op in [ida_hexrays.cot_obj, ida_hexrays.cot_var]:
name = self.get_expr_name(expr)
parts.append("%s.%d %s" % (type_name, expr.refwidth, name))
elif op in [
ida_hexrays.cot_num, ida_hexrays.cot_helper,
ida_hexrays.cot_str
]:
name = self.get_expr_name(expr)
parts.append("%s %s" % (
type_name,
name,
))
elif op == ida_hexrays.cit_goto:
parts.append("%s LABEL_%d" % (type_name, insn.cgoto.label_num))
elif op == ida_hexrays.cit_asm:
parts.append("%s <asm statements; unsupported ATM>" % type_name)
# parts.append(" %a.%d" % ())
else:
parts.append("%s" % type_name)
parts.append("ea: %08X" % item.ea)
if item.is_expr() and not expr.type.empty():
tstr = expr.type._print()
parts.append(tstr if tstr else "?")
scolor = ida_lines.SCOLOR_EXTRA if highlight_node else ida_lines.SCOLOR_DEFAULT
parts = [ida_lines.COLSTR("%s" % part, scolor) for part in parts]
return "\n".join(parts)
def get_node_label(self, n):
global CL_EDGE_HIGHLIGHT
global CL_EDGE_NORMAL
item = self.items[n]
op = item.op
insn = item.cinsn
expr = item.cexpr
type_name = ida_hexrays.get_ctype_name(op)
parts = []
if op == ida_hexrays.cot_ptr:
parts.append("%s.%d" % (type_name, expr.ptrsize))
elif op == ida_hexrays.cot_memptr:
parts.append("%s.%d (m=%d)" % (type_name, expr.ptrsize, expr.m))
elif op == ida_hexrays.cot_memref:
parts.append("%s (m=%d)" % (
type_name,
expr.m,
))
elif op in [ida_hexrays.cot_obj, ida_hexrays.cot_var]:
name = self.get_expr_name(expr)
parts.append("%s.%d %s" % (type_name, expr.refwidth, name))
elif op in [
ida_hexrays.cot_num, ida_hexrays.cot_helper,
ida_hexrays.cot_str
]:
name = self.get_expr_name(expr)
parts.append("%s %s" % (
type_name,
name,
))
elif op == ida_hexrays.cit_goto:
parts.append("%s LABEL_%d" % (type_name, insn.cgoto.label_num))
elif op == ida_hexrays.cit_asm:
parts.append("%s <asm statements; unsupported ATM>" % type_name)
# parts.append(" %a.%d" % ())
else:
parts.append("%s" % type_name)
parts.append("ea: %08X" % item.ea)
if item.is_expr() and not expr.type.empty():
tstr = expr.type._print()
parts.append(tstr if tstr else "?")
return "\n".join(parts)
def _append_lambda_expression(self, i, label, include_data=False):
def to_mask(n):
mask = 0
for i in range(n):
mask |= 0xff << 8 * i
return mask
ci = i.cexpr if i.is_expr() else i.cinsn
expr1 = "%s.op is idaapi.c%ct_%s" % (label,
"o" if i.is_expr() else "i",
ida_hexrays.get_ctype_name(ci.op))
expr2 = None
if include_data:
# TODO
if i.op is ida_hexrays.cot_num: #in [ida_hexrays.cot_num, ida_hexrays.cot_helper, ida_hexrays.cot_str]:
#expr2 = "%s.numval() == %s" % (label, get_expr_name(i))
#print("%x %d" % (i.ea, ord(i.n.nf.org_nbytes)))
expr2 = "%s.numval() == 0x%x" % (
label, i.numval() & to_mask(ord(i.n.nf.org_nbytes)))
self.lines.append(expr1)
if expr2:
self.lines.append(expr2)
return
def _get_node_label(self, n, highlight_node=False):
item = self.items[n]
op = item.op
insn = item.cinsn
expr = item.cexpr
type_name = ida_hexrays.get_ctype_name(op)
parts = []
if op == ida_hexrays.cot_ptr:
parts.append("%s.%d" % (type_name, expr.ptrsize))
elif op == ida_hexrays.cot_memptr:
parts.append("%s.%d (m=%d)" % (type_name, expr.ptrsize, expr.m))
elif op == ida_hexrays.cot_memref:
parts.append("%s (m=%d)" % (
type_name,
expr.m,
))
elif op in [ida_hexrays.cot_obj, ida_hexrays.cot_var]:
name = self._get_expr_name(expr)
parts.append("%s.%d %s" % (type_name, expr.refwidth, name))
elif op in [
ida_hexrays.cot_num, ida_hexrays.cot_helper,
ida_hexrays.cot_str
]:
name = self._get_expr_name(expr)
parts.append("%s %s" % (
type_name,
name,
))
elif op == ida_hexrays.cit_goto:
parts.append("%s LABEL_%d" % (type_name, insn.cgoto.label_num))
elif op == ida_hexrays.cit_asm:
parts.append("%s <asm statements; unsupported ATM>" % type_name)
# parts.append(" %a.%d" % ())
else:
parts.append("%s" % type_name)
parts.append("ea: %x" % item.ea)
# add type
if item.is_expr() and not expr.type.empty():
tstr = expr.type._print()
parts.append(tstr if tstr else "?")
if self.debug:
parts.append("-" * 20)
parts.append("obj_id: %x" % item.obj_id)
if op is ida_hexrays.cot_var:
parts.append("idx: %d" % expr.v.idx)
lv = expr.v.getv()
if lv:
parts.append("width: %d" % lv.width)
parts.append("defblk: %d" % lv.defblk)
parts.append("cmt: %s" % lv.cmt)
parts.append("arg_var: %r" % lv.is_arg_var)
parts.append("thisarg: %r" % lv.is_thisarg())
parts.append("result_var: %r" % lv.is_result_var)
parts.append("used_byref: %r" % lv.is_used_byref())
parts.append("mapdst_var: %r" % lv.is_mapdst_var)
parts.append("overlapped_var: %r" % lv.is_overlapped_var)
parts.append("floating_var: %r" % lv.is_floating_var)
parts.append("typed: %r" % lv.typed)
if self.debug > 1:
parts.append("divisor: %d" % lv.divisor)
parts.append("automapped: %r" % lv.is_automapped())
parts.append("fake_var: %r" % lv.is_fake_var)
parts.append("spoiled_var: %r" % lv.is_spoiled_var)
parts.append("noptr_var: %r" % lv.is_noptr_var())
parts.append("forced_var: %r" % lv.is_forced_var())
parts.append("dummy_arg: %r" % lv.is_dummy_arg())
parts.append("used: %r" % lv.used)
parts.append("user_info: %r" % lv.has_user_info)
parts.append("user_name: %r" % lv.has_user_name)
parts.append("user_type: %r" % lv.has_user_type)
parts.append("regname: %r" % lv.has_regname())
parts.append("mreg_done: %r" % lv.mreg_done)
parts.append("nice_name: %r" % lv.has_nice_name)
parts.append("unknown_width: %r" % lv.is_unknown_width)
parts.append("in_asm: %r" % lv.in_asm())
parts.append("notarg: %r" % lv.is_notarg())
parts.append("decl_unused: %r" % lv.is_decl_unused())
elif op is ida_hexrays.cot_obj:
parts.append("obj_ea: %x" % expr.obj_ea)
# disable hightlight color for now -> requires labels to be re-generated/graph to be redrawn
#scolor = self.COLOR_TEXT_HIGHLIGHT if highlight_node else self.COLOR_TEXT_DEFAULT
scolor = self.COLOR_TEXT_DEFAULT
parts = [ida_lines.COLSTR("%s" % part, scolor) for part in parts]
return "\n".join(parts)
def json_tree(self, n):
# Each node has a unique ID
node_info = {"node_id": n}
item = self.items[n]
# This is the type of ctree node
node_info["node_type"] = ida_hexrays.get_ctype_name(item.op)
# This is the type of the data (in C-land)
if item.is_expr() and not item.cexpr.type.empty():
node_info["type"] = item.cexpr.type._print()
node_info["address"] = "%08X" % item.ea
if item.ea == UNDEF_ADDR:
node_info["parent_address"] = "%08X" % self.get_pred_ea(n)
# Specific info for different node types
if item.op == ida_hexrays.cot_ptr:
node_info["pointer_size"] = item.cexpr.ptrsize
elif item.op == ida_hexrays.cot_memptr:
node_info.update({
"pointer_size": item.cexpr.ptrsize,
"m": item.cexpr.m
})
elif item.op == ida_hexrays.cot_memref:
node_info["m"] = item.cexpr.m
elif item.op == ida_hexrays.cot_obj:
node_info.update({
"name": get_expr_name(item.cexpr),
"ref_width": item.cexpr.refwidth
})
elif item.op == ida_hexrays.cot_var:
_, var_id, old_name, new_name = get_expr_name(
item.cexpr).split("@@")
node_info.update({
"var_id": var_id,
"old_name": old_name,
"new_name": new_name,
"ref_width": item.cexpr.refwidth
})
elif item.op in [
ida_hexrays.cot_num, ida_hexrays.cot_str,
ida_hexrays.cot_helper
]:
node_info["name"] = get_expr_name(item.cexpr)
# Get info for children of this node
successors = []
x_successor = None
y_successor = None
z_successor = None
for i in xrange(self.nsucc(n)):
successors.append(self.succ(n, i))
successor_trees = []
if item.is_expr():
if item.x:
for s in successors:
if item.x == self.items[s]:
successors.remove(s)
x_successor = self.json_tree(s)
break
if item.y:
for s in successors:
if item.y == self.items[s]:
successors.remove(s)
y_successor = self.json_tree(s)
break
if item.z:
for s in successors:
if item.z == self.items[s]:
successors.remove(s)
z_successor = self.json_tree(s)
break
if successors:
for succ in successors:
successor_trees.append(self.json_tree(succ))
if successor_trees != []:
node_info["children"] = successor_trees
if x_successor:
node_info["x"] = x_successor
if y_successor:
node_info["y"] = y_successor
if z_successor:
node_info["z"] = z_successor
return node_info
