diff options
| -rw-r--r-- | example/expression/expr_translate.py | 42 | ||||
| -rw-r--r-- | miasm2/ir/ir2C.py | 192 | ||||
| -rw-r--r-- | miasm2/ir/translators/C.py | 168 | ||||
| -rw-r--r-- | miasm2/ir/translators/__init__.py | 5 | ||||
| -rw-r--r-- | miasm2/ir/translators/python.py | 74 | ||||
| -rw-r--r-- | miasm2/ir/translators/translator.py | 111 | ||||
| -rwxr-xr-x | setup.py | 1 | ||||
| -rw-r--r-- | test/ir/ir2C.py | 80 | ||||
| -rw-r--r-- | test/test_all.py | 1 |
9 files changed, 463 insertions, 211 deletions
diff --git a/example/expression/expr_translate.py b/example/expression/expr_translate.py new file mode 100644 index 00000000..17663cd2 --- /dev/null +++ b/example/expression/expr_translate.py @@ -0,0 +1,42 @@ +import random + +from miasm2.expression.expression import ExprId +from miasm2.expression.expression_helper import ExprRandom +from miasm2.ir.translators import Translator + + +class ExprRandom_OpSubRange(ExprRandom): + operations_by_args_number = {1: ["-"], + 2: ["<<", ">>",], + "2+": ["+", "*", "&", "|", "^"], + } + + +print "[+] Compute a random expression:" +expr = ExprRandom_OpSubRange.get(depth=8) +print "-> %s" % expr +print "" + +print "[+] Translate in Python:" +exprPython = Translator.to_language("Python").from_expr(expr) +print exprPython +print "" + +print "[+] Translate in C:" +exprC = Translator.to_language("C").from_expr(expr) +print exprC +print "" + +print "[+] Eval in Python:" +def memory(addr, size): + ret = random.randint(0, (1 << size) - 1) + print "Memory access: @0x%x -> 0x%x" % (addr, ret) + return ret + +for expr_id in expr.get_r(mem_read=True): + if isinstance(expr_id, ExprId): + value = random.randint(0, (1 << expr_id.size) - 1) + print "Declare var: %s = 0x%x" % (expr_id.name, value) + globals()[expr_id.name] = value + +print "-> 0x%x" % eval(exprPython) diff --git a/miasm2/ir/ir2C.py b/miasm2/ir/ir2C.py index 30e9fee0..ef39fe27 100644 --- a/miasm2/ir/ir2C.py +++ b/miasm2/ir/ir2C.py @@ -1,6 +1,7 @@ from miasm2.expression.expression import * from miasm2.expression.simplifications import expr_simp from miasm2.core import asmbloc +from miasm2.ir.translators.C import TranslatorC import logging @@ -11,167 +12,6 @@ log_to_c_h.addHandler(console_handler) log_to_c_h.setLevel(logging.WARN) -def ExprInt_toC(self): - return str(self) - - -def ExprId_toC(self): - if isinstance(self.name, asmbloc.asm_label): - return "0x%x" % self.name.offset - return str(self) - - -def ExprAff_toC(self): - return "%s = %s" % (self.dst.toC(), self.src.toC()) - - -def ExprCond_toC(self): - return "(%s?%s:%s)" % (self.cond.toC(), self.src1.toC(), self.src2.toC()) - - -def ExprMem_toC(self): - return "MEM_LOOKUP_%.2d(vm_mngr, %s)" % (self._size, self.arg.toC()) - - -def ExprOp_toC(self): - dct_shift = {'a>>': "right_arith", - '>>': "right_logic", - '<<': "left_logic", - 'a<<': "left_logic", - } - dct_rot = {'<<<': 'rot_left', - '>>>': 'rot_right', - } - dct_div = {'div8': "div_op", - 'div16': "div_op", - 'div32': "div_op", - 'idiv32': "div_op", # XXX to test - '<<<c_rez': 'rcl_rez_op', - '<<<c_cf': 'rcl_cf_op', - '>>>c_rez': 'rcr_rez_op', - '>>>c_cf': 'rcr_cf_op', - } - if len(self.args) == 1: - if self.op == 'parity': - return "parity(%s&0x%x)" % ( - self.args[0].toC(), size2mask(self.args[0].size)) - elif self.op == '!': - return "(~ %s)&0x%x" % ( - self.args[0].toC(), size2mask(self.args[0].size)) - elif self.op in ["hex2bcd", "bcd2hex"]: - return "%s_%d(%s)" % ( - self.op, self.args[0].size, self.args[0].toC()) - elif (self.op.startswith("double_to_") or - self.op.endswith("_to_double") or - self.op.startswith("access_") or - self.op.startswith("load_") or - self.op in ["-", "ftan", "frndint", "f2xm1", - "fsin", "fsqrt", "fabs", "fcos"]): - return "%s(%s)" % (self.op, self.args[0].toC()) - else: - raise ValueError('unknown op: %r' % self.op) - elif len(self.args) == 2: - if self.op == "==": - return '(((%s&0x%x) == (%s&0x%x))?1:0)' % ( - self.args[0].toC(), size2mask(self.args[0].size), - self.args[1].toC(), size2mask(self.args[1].size)) - elif self.op in dct_shift: - return 'shift_%s_%.2d(%s , %s)' % (dct_shift[self.op], - self.args[0].size, - self.args[0].toC(), - self.args[1].toC()) - elif self.is_associative(): - o = ['(%s&0x%x)' % (a.toC(), size2mask(a.size)) for a in self.args] - o = str(self.op).join(o) - return "((%s)&0x%x)" % (o, size2mask(self.args[0].size)) - elif self.op in ["%", "/"]: - o = ['(%s&0x%x)' % (a.toC(), size2mask(a.size)) for a in self.args] - o = str(self.op).join(o) - return "((%s)&0x%x)" % (o, size2mask(self.args[0].size)) - elif self.op in ['-']: - return '(((%s&0x%x) %s (%s&0x%x))&0x%x)' % ( - self.args[0].toC(), size2mask(self.args[0].size), - str(self.op), - self.args[1].toC(), size2mask(self.args[1].size), - size2mask(self.args[0].size)) - elif self.op in dct_rot: - return '(%s(%s, %s, %s) &0x%x)' % (dct_rot[self.op], - self.args[0].size, - self.args[0].toC(), - self.args[1].toC(), - size2mask(self.args[0].size)) - elif self.op in ['bsr', 'bsf']: - return 'my_%s(%s, %s)' % (self.op, - self.args[0].toC(), - self.args[1].toC()) - elif self.op.startswith('cpuid'): - return "%s(%s, %s)" % ( - self.op, self.args[0].toC(), self.args[1].toC()) - elif self.op.startswith("fcom"): - return "%s(%s, %s)" % ( - self.op, self.args[0].toC(), self.args[1].toC()) - elif self.op in ["fadd", "fsub", "fdiv", 'fmul', "fscale"]: - return "%s(%s, %s)" % ( - self.op, self.args[0].toC(), self.args[1].toC()) - elif self.op == "segm": - return "segm2addr(vmcpu, %s, %s)" % ( - self.args[0].toC(), self.args[1].toC()) - elif self.op in ['udiv', 'umod', 'idiv', 'imod']: - return '%s%d(vmcpu, %s, %s)' % (self.op, - self.args[0].size, - self.args[0].toC(), - self.args[1].toC()) - elif self.op in ["bcdadd", "bcdadd_cf"]: - return "%s_%d(%s, %s)" % (self.op, self.args[0].size, - self.args[0].toC(), - self.args[1].toC()) - else: - raise ValueError('unknown op: %r' % self.op) - elif len(self.args) == 3 and self.op in dct_div: - return '(%s(%s, %s, %s, %s) &0x%x)' % (dct_div[self.op], - self.args[0].size, - self.args[0].toC(), - self.args[1].toC(), - self.args[2].toC(), - size2mask(self.args[0].size)) - elif len(self.args) >= 3 and self.is_associative(): # ????? - o = ['(%s&0x%x)' % (a.toC(), size2mask(a.size)) for a in self.args] - o = str(self.op).join(o) - r = "((%s)&0x%x)" % (o, size2mask(self.args[0].size)) - return r - else: - raise NotImplementedError('unknown op: %s' % self) - - -def ExprSlice_toC(self): - # XXX check mask for 64 bit & 32 bit compat - return "((%s>>%d) & 0x%X)" % (self.arg.toC(), - self.start, - (1 << (self.stop - self.start)) - 1) - - -def ExprCompose_toC(self): - out = [] - # XXX check mask for 64 bit & 32 bit compat - dst_cast = "uint%d_t" % self.size - for x in self.args: - out.append("(((%s)(%s & 0x%X)) << %d)" % (dst_cast, - x[0].toC(), - (1 << (x[2] - x[1])) - 1, - x[1])) - out = ' | '.join(out) - return '(' + out + ')' - - -ExprInt.toC = ExprInt_toC -ExprId.toC = ExprId_toC -ExprAff.toC = ExprAff_toC -ExprCond.toC = ExprCond_toC -ExprMem.toC = ExprMem_toC -ExprOp.toC = ExprOp_toC -ExprSlice.toC = ExprSlice_toC -ExprCompose.toC = ExprCompose_toC - prefetch_id = [] prefetch_id_size = {} for size in [8, 16, 32, 64]: @@ -324,13 +164,13 @@ def gen_resolve_id_lbl(ir_arch, e): return 'Resolve_dst(BlockDst, 0x%X, 0)'%(e.name.offset) def gen_resolve_id(ir_arch, e): - return 'Resolve_dst(BlockDst, %s, 0)'%(patch_c_id(ir_arch.arch, e).toC()) + return 'Resolve_dst(BlockDst, %s, 0)'%(TranslatorC.from_expr(patch_c_id(ir_arch.arch, e))) def gen_resolve_mem(ir_arch, e): - return 'Resolve_dst(BlockDst, %s, 0)'%(patch_c_id(ir_arch.arch, e).toC()) + return 'Resolve_dst(BlockDst, %s, 0)'%(TranslatorC.from_expr(patch_c_id(ir_arch.arch, e))) def gen_resolve_other(ir_arch, e): - return 'Resolve_dst(BlockDst, %s, 0)'%(patch_c_id(ir_arch.arch, e).toC()) + return 'Resolve_dst(BlockDst, %s, 0)'%(TranslatorC.from_expr(patch_c_id(ir_arch.arch, e))) def gen_resolve_dst_simple(ir_arch, e): if isinstance(e, ExprInt): @@ -348,7 +188,7 @@ def gen_resolve_dst_simple(ir_arch, e): def gen_irdst(ir_arch, e): out = [] if isinstance(e, ExprCond): - dst_cond_c = patch_c_id(ir_arch.arch, e.cond).toC() + dst_cond_c = TranslatorC.from_expr(patch_c_id(ir_arch.arch, e.cond)) out.append("if (%s)"%dst_cond_c) out.append(' %s;'%(gen_resolve_dst_simple(ir_arch, e.src1))) out.append("else") @@ -369,7 +209,7 @@ def Expr2C(ir_arch, l, exprs, gen_exception_code=False): new_expr = [] e = set_pc(ir_arch, l.offset & mask_int) - #out.append("%s;" % patch_c_id(ir_arch.arch, e).toC()) + #out.append("%s;" % patch_c_id(ir_arch.arch, e))) pc_is_dst = False fetch_mem = False @@ -416,8 +256,8 @@ def Expr2C(ir_arch, l, exprs, gen_exception_code=False): mem_k = src_mem.keys() mem_k.sort() for k in mem_k: - str_src = patch_c_id(ir_arch.arch, k).toC() - str_dst = patch_c_id(ir_arch.arch, src_mem[k]).toC() + str_src = TranslatorC.from_expr(patch_c_id(ir_arch.arch, k)) + str_dst = TranslatorC.from_expr(patch_c_id(ir_arch.arch, src_mem[k])) out.append('%s = %s;' % (str_dst, str_src)) src_w_len = {} for k, v in src_mem.items(): @@ -432,8 +272,8 @@ def Expr2C(ir_arch, l, exprs, gen_exception_code=False): continue - str_src = patch_c_id(ir_arch.arch, src).toC() - str_dst = patch_c_id(ir_arch.arch, dst).toC() + str_src = TranslatorC.from_expr(patch_c_id(ir_arch.arch, src)) + str_dst = TranslatorC.from_expr(patch_c_id(ir_arch.arch, dst)) @@ -463,12 +303,12 @@ def Expr2C(ir_arch, l, exprs, gen_exception_code=False): if gen_exception_code: if fetch_mem: e = set_pc(ir_arch, l.offset & mask_int) - s1 = "%s" % patch_c_id(ir_arch.arch, e).toC() + s1 = "%s" % TranslatorC.from_expr(patch_c_id(ir_arch.arch, e)) s1 += ';\n Resolve_dst(BlockDst, 0x%X, 0)'%(l.offset & mask_int) out.append(code_exception_fetch_mem_at_instr_noautomod % s1) if set_exception_flags: e = set_pc(ir_arch, l.offset & mask_int) - s1 = "%s" % patch_c_id(ir_arch.arch, e).toC() + s1 = "%s" % TranslatorC.from_expr(patch_c_id(ir_arch.arch, e)) s1 += ';\n Resolve_dst(BlockDst, 0x%X, 0)'%(l.offset & mask_int) out.append(code_exception_at_instr_noautomod % s1) @@ -487,10 +327,10 @@ def Expr2C(ir_arch, l, exprs, gen_exception_code=False): "/*pc = 0x%X; */return; }" % (l.offset)) else: e = set_pc(ir_arch, l.offset & mask_int) - s1 = "%s" % patch_c_id(ir_arch.arch, e).toC() + s1 = "%s" % TranslatorC.from_expr(patch_c_id(ir_arch.arch, e)) s1 += ';\n Resolve_dst(BlockDst, 0x%X, 0)'%(l.offset & mask_int) e = set_pc(ir_arch, (l.offset + l.l) & mask_int) - s2 = "%s" % patch_c_id(ir_arch.arch, e).toC() + s2 = "%s" % TranslatorC.from_expr(patch_c_id(ir_arch.arch, e)) s2 += ';\n Resolve_dst(BlockDst, 0x%X, 0)'%((l.offset + l.l) & mask_int) post_instr.append( code_exception_post_instr_noautomod % (s1, s2)) @@ -502,7 +342,7 @@ def Expr2C(ir_arch, l, exprs, gen_exception_code=False): offset = l.offset + l.l e = set_pc(ir_arch, offset & mask_int) - s1 = "%s" % patch_c_id(ir_arch.arch, e).toC() + s1 = "%s" % TranslatorC.from_expr(patch_c_id(ir_arch.arch, e)) s1 += ';\n Resolve_dst(BlockDst, 0x%X, 0)'%(offset & mask_int) post_instr.append( code_exception_fetch_mem_post_instr_noautomod % (s1)) @@ -542,7 +382,7 @@ def ir2C(ir_arch, irbloc, lbl_done, for l, exprs in zip(irbloc.lines, irbloc.irs): if l.offset not in lbl_done: e = set_pc(ir_arch, l.offset & mask_int) - s1 = "%s" % patch_c_id(ir_arch.arch, e).toC() + s1 = "%s" % TranslatorC.from_expr(patch_c_id(ir_arch.arch, e)) s1 += ';\n Resolve_dst(BlockDst, 0x%X, 0)'%(l.offset & mask_int) out.append([pre_instr_test_exception % (s1)]) lbl_done.add(l.offset) diff --git a/miasm2/ir/translators/C.py b/miasm2/ir/translators/C.py new file mode 100644 index 00000000..a730b1d8 --- /dev/null +++ b/miasm2/ir/translators/C.py @@ -0,0 +1,168 @@ +from miasm2.ir.translators.translator import Translator +from miasm2.core import asmbloc +from miasm2.expression.modint import size2mask + + +class TranslatorC(Translator): + "Translate a Miasm expression to an equivalent C code" + + # Implemented language + __LANG__ = "C" + + # Operations translation + dct_shift = {'a>>': "right_arith", + '>>': "right_logic", + '<<': "left_logic", + 'a<<': "left_logic", + } + dct_rot = {'<<<': 'rot_left', + '>>>': 'rot_right', + } + dct_div = {'div8': "div_op", + 'div16': "div_op", + 'div32': "div_op", + 'idiv32': "div_op", # XXX to test + '<<<c_rez': 'rcl_rez_op', + '<<<c_cf': 'rcl_cf_op', + '>>>c_rez': 'rcr_rez_op', + '>>>c_cf': 'rcr_cf_op', + } + + + @classmethod + def from_ExprId(cls, expr): + if isinstance(expr.name, asmbloc.asm_label): + return "0x%x" % expr.name.offset + return str(expr) + + @classmethod + def from_ExprInt(cls, expr): + return "0x%x" % expr.arg.arg + + @classmethod + def from_ExprAff(cls, expr): + return "%s = %s" % tuple(map(cls.from_expr, (expr.dst, expr.src))) + + @classmethod + def from_ExprCond(cls, expr): + return "(%s?%s:%s)" % tuple(map(cls.from_expr, + (expr.cond, expr.src1, expr.src2))) + + @classmethod + def from_ExprMem(cls, expr): + return "MEM_LOOKUP_%.2d(vm_mngr, %s)" % (expr._size, + cls.from_expr(expr.arg)) + + @classmethod + def from_ExprOp(cls, expr): + if len(expr.args) == 1: + if expr.op == 'parity': + return "parity(%s&0x%x)" % (cls.from_expr(expr.args[0]), + size2mask(expr.args[0].size)) + elif expr.op == '!': + return "(~ %s)&0x%x" % (cls.from_expr(expr.args[0]), + size2mask(expr.args[0].size)) + elif expr.op in ["hex2bcd", "bcd2hex"]: + return "%s_%d(%s)" % (expr.op, expr.args[0].size, + cls.from_expr(expr.args[0])) + elif (expr.op.startswith("double_to_") or + expr.op.endswith("_to_double") or + expr.op.startswith("access_") or + expr.op.startswith("load_") or + expr.op in ["-", "ftan", "frndint", "f2xm1", + "fsin", "fsqrt", "fabs", "fcos"]): + return "%s(%s)" % (expr.op, cls.from_expr(expr.args[0])) + else: + raise NotImplementedError('Unknown op: %r' % expr.op) + + elif len(expr.args) == 2: + if expr.op == "==": + return '(((%s&0x%x) == (%s&0x%x))?1:0)' % ( + cls.from_expr(expr.args[0]), size2mask(expr.args[0].size), + cls.from_expr(expr.args[1]), size2mask(expr.args[1].size)) + elif expr.op in cls.dct_shift: + return 'shift_%s_%.2d(%s , %s)' % (cls.dct_shift[expr.op], + expr.args[0].size, + cls.from_expr(expr.args[0]), + cls.from_expr(expr.args[1])) + elif expr.is_associative() or expr.op in ["%", "/"]: + oper = ['(%s&0x%x)' % (cls.from_expr(arg), size2mask(arg.size)) + for arg in expr.args] + oper = str(expr.op).join(oper) + return "((%s)&0x%x)" % (oper, size2mask(expr.args[0].size)) + elif expr.op in ['-']: + return '(((%s&0x%x) %s (%s&0x%x))&0x%x)' % ( + cls.from_expr(expr.args[0]), size2mask(expr.args[0].size), + str(expr.op), + cls.from_expr(expr.args[1]), size2mask(expr.args[1].size), + size2mask(expr.args[0].size)) + elif expr.op in cls.dct_rot: + return '(%s(%s, %s, %s) &0x%x)' % (cls.dct_rot[expr.op], + expr.args[0].size, + cls.from_expr(expr.args[0]), + cls.from_expr(expr.args[1]), + size2mask(expr.args[0].size)) + elif expr.op in ['bsr', 'bsf']: + return 'my_%s(%s, %s)' % (expr.op, + cls.from_expr(expr.args[0]), + cls.from_expr(expr.args[1])) + elif (expr.op.startswith('cpuid') or + expr.op.startswith("fcom") or + expr.op in ["fadd", "fsub", "fdiv", 'fmul', "fscale"]): + return "%s(%s, %s)" % (expr.op, cls.from_expr(expr.args[0]), + cls.from_expr(expr.args[1])) + elif expr.op == "segm": + return "segm2addr(vmcpu, %s, %s)" % ( + cls.from_expr(expr.args[0]), cls.from_expr(expr.args[1])) + elif expr.op in ['udiv', 'umod', 'idiv', 'imod']: + return '%s%d(vmcpu, %s, %s)' % (expr.op, + expr.args[0].size, + cls.from_expr(expr.args[0]), + cls.from_expr(expr.args[1])) + elif expr.op in ["bcdadd", "bcdadd_cf"]: + return "%s_%d(%s, %s)" % (expr.op, expr.args[0].size, + cls.from_expr(expr.args[0]), + cls.from_expr(expr.args[1])) + else: + raise NotImplementedError('Unknown op: %r' % expr.op) + + elif len(expr.args) == 3 and expr.op in cls.dct_div: + return '(%s(%s, %s, %s, %s) &0x%x)' % (cls.dct_div[expr.op], + expr.args[0].size, + cls.from_expr(expr.args[0]), + cls.from_expr(expr.args[1]), + cls.from_expr(expr.args[2]), + size2mask(expr.args[0].size)) + + elif len(expr.args) >= 3 and expr.is_associative(): # ????? + oper = ['(%s&0x%x)' % (cls.from_expr(arg), size2mask(arg.size)) + for arg in expr.args] + oper = str(expr.op).join(oper) + return "((%s)&0x%x)" % (oper, size2mask(expr.args[0].size)) + + else: + raise NotImplementedError('Unknown op: %s' % expr.op) + + @classmethod + def from_ExprSlice(cls, expr): + # XXX check mask for 64 bit & 32 bit compat + return "((%s>>%d) & 0x%X)" % (cls.from_expr(expr.arg), + expr.start, + (1 << (expr.stop - expr.start)) - 1) + + @classmethod + def from_ExprCompose(cls, expr): + out = [] + # XXX check mask for 64 bit & 32 bit compat + dst_cast = "uint%d_t" % expr.size + for x in expr.args: + out.append("(((%s)(%s & 0x%X)) << %d)" % (dst_cast, + cls.from_expr(x[0]), + (1 << (x[2] - x[1])) - 1, + x[1])) + out = ' | '.join(out) + return '(' + out + ')' + + +# Register the class +Translator.register(TranslatorC) diff --git a/miasm2/ir/translators/__init__.py b/miasm2/ir/translators/__init__.py new file mode 100644 index 00000000..0d768b57 --- /dev/null +++ b/miasm2/ir/translators/__init__.py @@ -0,0 +1,5 @@ +"""IR Translators""" +from miasm2.ir.translators.C import * +from miasm2.ir.translators.python import * + +__all__ = ["Translator"] diff --git a/miasm2/ir/translators/python.py b/miasm2/ir/translators/python.py new file mode 100644 index 00000000..f23d1907 --- /dev/null +++ b/miasm2/ir/translators/python.py @@ -0,0 +1,74 @@ +from miasm2.ir.translators.translator import Translator + + +class TranslatorPython(Translator): + """Translate a Miasm expression to an equivalent Python code + + Memory is abstracted using the unimplemented function: + int memory(int address, int size) + """ + + # Implemented language + __LANG__ = "Python" + # Operations translation + op_no_translate = ["+", "-", "/", "%", ">>", "<<", "&", "^", "|", "*"] + + @classmethod + def from_ExprInt(cls, expr): + return str(expr) + + @classmethod + def from_ExprId(cls, expr): + return str(expr) + + @classmethod + def from_ExprMem(cls, expr): + return "memory(%s, 0x%x)" % (cls.from_expr(expr.arg), + expr.size / 8) + + @classmethod + def from_ExprSlice(cls, expr): + out = cls.from_expr(expr.arg) + if expr.start != 0: + out = "(%s >> %d)" % (out, expr.start) + return "(%s & 0x%x)" % (cls.from_expr(expr.arg), + (1 << (expr.stop - expr.start)) - 1) + + @classmethod + def from_ExprCompose(cls, expr): + out = [] + for subexpr, start, stop in expr.args: + out.append("((%s & 0x%x) << %d)" % (cls.from_expr(subexpr), + (1 << (stop - start)) - 1, + start)) + return "(%s)" % ' | '.join(out) + + @classmethod + def from_ExprCond(cls, expr): + return "(%s if (%s) else %s)" % (cls.from_expr(expr.src1), + cls.from_expr(expr.cond), + cls.from_expr(expr.src2)) + + @classmethod + def from_ExprOp(cls, expr): + if expr.op in cls.op_no_translate: + args = map(cls.from_expr, expr.args) + if len(expr.args) == 1: + return "((%s %s) & 0x%x)" % (expr.op, + args[0], + (1 << expr.size) - 1) + else: + return "(%s & 0x%x)" % ((" %s " % expr.op).join(args), + (1 << expr.size) - 1) + elif expr.op == "parity": + return "(%s & 0x1)" % cls.from_expr(expr.args[0]) + + raise NotImplementedError("Unknown operator: %s" % expr.op) + + @classmethod + def from_ExprAff(cls, expr): + return "%s = %s" % tuple(map(cls.from_expr, (expr.dst, expr.src))) + + +# Register the class +Translator.register(TranslatorPython) diff --git a/miasm2/ir/translators/translator.py b/miasm2/ir/translators/translator.py new file mode 100644 index 00000000..2a971130 --- /dev/null +++ b/miasm2/ir/translators/translator.py @@ -0,0 +1,111 @@ +import miasm2.expression.expression as m2_expr + + +class Translator(object): + "Abstract parent class for translators." + + # Registered translators + available_translators = [] + # Implemented language + __LANG__ = "" + + @classmethod + def register(cls, translator): + """Register a translator + @translator: Translator sub-class + """ + cls.available_translators.append(translator) + + @classmethod + def to_language(cls, target_lang): + """Return the corresponding translator + @target_lang: str (case insensitive) wanted language + Raise a NotImplementedError in case of unmatched language + """ + target_lang = target_lang.lower() + for translator in cls.available_translators: + if translator.__LANG__.lower() == target_lang: + return translator + + raise NotImplementedError("Unknown target language: %s" % target_lang) + + @classmethod + def available_languages(cls): + "Return the list of registered languages" + return [translator.__LANG__ for translator in cls.available_translators] + + @classmethod + def from_ExprInt(cls, expr): + """Translate an ExprInt + @expr: ExprInt to translate + """ + raise NotImplementedError("Abstract method") + + @classmethod + def from_ExprId(cls, expr): + """Translate an ExprId + @expr: ExprId to translate + """ + raise NotImplementedError("Abstract method") + + @classmethod + def from_ExprCompose(cls, expr): + """Translate an ExprCompose + @expr: ExprCompose to translate + """ + raise NotImplementedError("Abstract method") + + @classmethod + def from_ExprSlice(cls, expr): + """Translate an ExprSlice + @expr: ExprSlice to translate + """ + raise NotImplementedError("Abstract method") + + @classmethod + def from_ExprOp(cls, expr): + """Translate an ExprOp + @expr: ExprOp to translate + """ + raise NotImplementedError("Abstract method") + + @classmethod + def from_ExprMem(cls, expr): + """Translate an ExprMem + @expr: ExprMem to translate + """ + raise NotImplementedError("Abstract method") + + @classmethod + def from_ExprAff(cls, expr): + """Translate an ExprAff + @expr: ExprAff to translate + """ + raise NotImplementedError("Abstract method") + + @classmethod + def from_ExprCond(cls, expr): + """Translate an ExprCond + @expr: ExprCond to translate + """ + raise NotImplementedError("Abstract method") + + @classmethod + def from_expr(cls, expr): + """Translate an expression according to its type + @expr: expression to translate + """ + handlers = {m2_expr.ExprInt: cls.from_ExprInt, + m2_expr.ExprId: cls.from_ExprId, + m2_expr.ExprCompose: cls.from_ExprCompose, + m2_expr.ExprSlice: cls.from_ExprSlice, + m2_expr.ExprOp: cls.from_ExprOp, + m2_expr.ExprMem: cls.from_ExprMem, + m2_expr.ExprAff: cls.from_ExprAff, + m2_expr.ExprCond: cls.from_ExprCond + } + for target, handler in handlers.iteritems(): + if isinstance(expr, target): + return handler(expr) + raise ValueError("Unhandled type for %s" % expr) + diff --git a/setup.py b/setup.py index de1667e9..3d5fedac 100755 --- a/setup.py +++ b/setup.py @@ -16,6 +16,7 @@ def buil_all(): 'miasm2/core', 'miasm2/expression', 'miasm2/ir', + 'miasm2/ir/translators', 'miasm2/analysis', 'miasm2/os_dep', 'miasm2/jitter', diff --git a/test/ir/ir2C.py b/test/ir/ir2C.py index c5ae1b8f..1089bba4 100644 --- a/test/ir/ir2C.py +++ b/test/ir/ir2C.py @@ -6,52 +6,62 @@ import unittest class TestIrIr2C(unittest.TestCase): + def translationTest(self, expr, expected): + from miasm2.ir.translators.C import TranslatorC + + self.assertEqual(TranslatorC.from_expr(expr), expected) + def test_ExprOp_toC(self): from miasm2.expression.expression import ExprInt32, ExprOp - import miasm2.ir.ir2C # /!\ REALLY DIRTY HACK + from miasm2.ir.translators.C import TranslatorC + args = [ExprInt32(i) for i in xrange(9)] + # Unary operators - self.assertEqual( - ExprOp('parity', *args[:1]).toC(), r'parity(0x0&0xffffffff)') - self.assertEqual( - ExprOp('!', *args[:1]).toC(), r'(~ 0x0)&0xffffffff') - self.assertEqual( - ExprOp('hex2bcd', *args[:1]).toC(), r'hex2bcd_32(0x0)') - self.assertEqual(ExprOp('fabs', *args[:1]).toC(), r'fabs(0x0)') - self.assertRaises(ValueError, ExprOp('X', *args[:1]).toC) + self.translationTest( + ExprOp('parity', *args[:1]), r'parity(0x0&0xffffffff)') + self.translationTest( + ExprOp('!', *args[:1]), r'(~ 0x0)&0xffffffff') + self.translationTest( + ExprOp('hex2bcd', *args[:1]), r'hex2bcd_32(0x0)') + self.translationTest(ExprOp('fabs', *args[:1]), r'fabs(0x0)') + self.assertRaises(NotImplementedError, TranslatorC.from_expr, + ExprOp('X', *args[:1])) # Binary operators - self.assertEqual( - ExprOp('==', *args[:2]).toC(), r'(((0x0&0xffffffff) == (0x1&0xffffffff))?1:0)') - self.assertEqual( - ExprOp('%', *args[:2]).toC(), r'(((0x0&0xffffffff)%(0x1&0xffffffff))&0xffffffff)') - self.assertEqual( - ExprOp('-', *args[:2]).toC(), r'(((0x0&0xffffffff) - (0x1&0xffffffff))&0xffffffff)') - self.assertEqual( - ExprOp('bsr', *args[:2]).toC(), r'my_bsr(0x0, 0x1)') - self.assertEqual( - ExprOp('cpuid0', *args[:2]).toC(), r'cpuid0(0x0, 0x1)') - self.assertEqual( - ExprOp('fcom0', *args[:2]).toC(), r'fcom0(0x0, 0x1)') - self.assertEqual( - ExprOp('fadd', *args[:2]).toC(), r'fadd(0x0, 0x1)') - self.assertEqual( - ExprOp('segm', *args[:2]).toC(), r'segm2addr(vmcpu, 0x0, 0x1)') - self.assertEqual( - ExprOp('imod', *args[:2]).toC(), r'imod32(vmcpu, 0x0, 0x1)') - self.assertEqual( - ExprOp('bcdadd', *args[:2]).toC(), r'bcdadd_32(0x0, 0x1)') - self.assertRaises(ValueError, ExprOp('X', *args[:2]).toC) + self.translationTest( + ExprOp('==', *args[:2]), r'(((0x0&0xffffffff) == (0x1&0xffffffff))?1:0)') + self.translationTest( + ExprOp('%', *args[:2]), r'(((0x0&0xffffffff)%(0x1&0xffffffff))&0xffffffff)') + self.translationTest( + ExprOp('-', *args[:2]), r'(((0x0&0xffffffff) - (0x1&0xffffffff))&0xffffffff)') + self.translationTest( + ExprOp('bsr', *args[:2]), r'my_bsr(0x0, 0x1)') + self.translationTest( + ExprOp('cpuid0', *args[:2]), r'cpuid0(0x0, 0x1)') + self.translationTest( + ExprOp('fcom0', *args[:2]), r'fcom0(0x0, 0x1)') + self.translationTest( + ExprOp('fadd', *args[:2]), r'fadd(0x0, 0x1)') + self.translationTest( + ExprOp('segm', *args[:2]), r'segm2addr(vmcpu, 0x0, 0x1)') + self.translationTest( + ExprOp('imod', *args[:2]), r'imod32(vmcpu, 0x0, 0x1)') + self.translationTest( + ExprOp('bcdadd', *args[:2]), r'bcdadd_32(0x0, 0x1)') + self.assertRaises(NotImplementedError, TranslatorC.from_expr, + ExprOp('X', *args[:2])) # Ternary operators - self.assertEqual( - ExprOp('div8', *args[:3]).toC(), r'(div_op(32, 0x0, 0x1, 0x2) &0xffffffff)') + self.translationTest( + ExprOp('div8', *args[:3]), r'(div_op(32, 0x0, 0x1, 0x2) &0xffffffff)') # Other cases - self.assertEqual( - ExprOp('+', *args[:3]).toC(), r'(((0x0&0xffffffff)+(0x1&0xffffffff)+(0x2&0xffffffff))&0xffffffff)') - self.assertRaises(NotImplementedError, ExprOp('X', *args[:3]).toC) + self.translationTest( + ExprOp('+', *args[:3]), r'(((0x0&0xffffffff)+(0x1&0xffffffff)+(0x2&0xffffffff))&0xffffffff)') + self.assertRaises(NotImplementedError, TranslatorC.from_expr, + ExprOp('X', *args[:3])) if __name__ == '__main__': testsuite = unittest.TestLoader().loadTestsFromTestCase(TestIrIr2C) diff --git a/test/test_all.py b/test/test_all.py index 44dd75fa..db4c2c6d 100644 --- a/test/test_all.py +++ b/test/test_all.py @@ -155,6 +155,7 @@ for script in [["symbol_exec.py"], ["expression/expr_grapher.py"], ["expression/simplification_add.py"], ["expression/expr_random.py"], + ["expression/expr_translate.py"], ]: testset += Example(script) ## Jitter |