diff options
Diffstat (limited to 'miasm2/ir/translators')
| -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 |
4 files changed, 358 insertions, 0 deletions
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) + |