def __init__(self, lifter, jit_type="gcc"):
"""Init an instance of jitter.
@lifter: Lifter instance for this architecture
@jit_type: JiT backend to use. Available options are:
- "gcc"
- "llvm"
- "python"
"""
self.arch = lifter.arch
self.attrib = lifter.attrib
arch_name = lifter.arch.name # (lifter.arch.name, lifter.attrib)
try:
if arch_name == "x86":
from miasm.jitter.arch import JitCore_x86 as jcore
elif arch_name == "arm":
from miasm.jitter.arch import JitCore_arm as jcore
elif arch_name == "armt":
from miasm.jitter.arch import JitCore_arm as jcore
lifter.arch.name = 'arm'
elif arch_name == "aarch64":
from miasm.jitter.arch import JitCore_aarch64 as jcore
elif arch_name == "msp430":
from miasm.jitter.arch import JitCore_msp430 as jcore
elif arch_name == "mips32":
from miasm.jitter.arch import JitCore_mips32 as jcore
elif arch_name == "ppc32":
from miasm.jitter.arch import JitCore_ppc32 as jcore
elif arch_name == "mep":
from miasm.jitter.arch import JitCore_mep as jcore
else:
raise ValueError("unknown jit arch: %s" % arch_name)
except ImportError:
raise RuntimeError('Unsupported jit arch: %s' % arch_name)
self.vm = VmMngr.Vm()
self.cpu = jcore.JitCpu()
self.lifter = lifter
self.bs = bin_stream_vm(self.vm)
self.ircfg = self.lifter.new_ircfg()
self.symbexec = EmulatedSymbExec(
self.cpu, self.vm, self.lifter, {}
)
self.symbexec.reset_regs()
try:
if jit_type == "llvm":
from miasm.jitter.jitcore_llvm import JitCore_LLVM as JitCore
elif jit_type == "python":
from miasm.jitter.jitcore_python import JitCore_Python as JitCore
elif jit_type == "gcc":
from miasm.jitter.jitcore_gcc import JitCore_Gcc as JitCore
else:
raise ValueError("Unknown jitter %s" % jit_type)
except ImportError:
raise RuntimeError('Unsupported jitter: %s' % jit_type)
self.jit = JitCore(self.lifter, self.bs)
if isinstance(self.jit, JitCore_Cc_Base):
self.jit.init_codegen(self.C_Gen(self.lifter))
elif jit_type == "python":
self.jit.set_cpu_vm(self.cpu, self.vm)
self.cpu.init_regs()
self.vm.init_memory_page_pool()
self.vm.init_code_bloc_pool()
self.vm.init_memory_breakpoint()
self.jit.load()
self.cpu.vmmngr = self.vm
self.cpu.jitter = self.jit
self.stack_size = 0x10000
self.stack_base = 0x1230000
# Init callback handler
self.breakpoints_handler = CallbackHandler()
self.exceptions_handler = CallbackHandlerBitflag()
self.init_exceptions_handler()
self.exec_cb = None
def __init__(self, ir_arch, jit_type="gcc"):
"""Init an instance of jitter.
@ir_arch: ir instance for this architecture
@jit_type: JiT backend to use. Available options are:
- "gcc"
- "llvm"
- "python"
"""
self.arch = ir_arch.arch
self.attrib = ir_arch.attrib
arch_name = ir_arch.arch.name # (ir_arch.arch.name, ir_arch.attrib)
try:
if arch_name == "x86":
from miasm.jitter.arch import JitCore_x86 as jcore
elif arch_name == "arm":
from miasm.jitter.arch import JitCore_arm as jcore
elif arch_name == "armt":
from miasm.jitter.arch import JitCore_arm as jcore
ir_arch.arch.name = 'arm'
elif arch_name == "aarch64":
from miasm.jitter.arch import JitCore_aarch64 as jcore
elif arch_name == "msp430":
from miasm.jitter.arch import JitCore_msp430 as jcore
elif arch_name == "mips32":
from miasm.jitter.arch import JitCore_mips32 as jcore
elif arch_name == "ppc32":
from miasm.jitter.arch import JitCore_ppc32 as jcore
elif arch_name == "mep":
from miasm.jitter.arch import JitCore_mep as jcore
else:
raise ValueError("unknown jit arch: %s" % arch_name)
except ImportError:
raise RuntimeError('Unsupported jit arch: %s' % arch_name)
self.vm = VmMngr.Vm()
self.cpu = jcore.JitCpu()
self.ir_arch = ir_arch
self.bs = bin_stream_vm(self.vm)
self.ircfg = self.ir_arch.new_ircfg()
self.symbexec = EmulatedSymbExec(
self.cpu, self.vm, self.ir_arch, {}
)
self.symbexec.reset_regs()
try:
if jit_type == "llvm":
from miasm.jitter.jitcore_llvm import JitCore_LLVM as JitCore
elif jit_type == "python":
from miasm.jitter.jitcore_python import JitCore_Python as JitCore
elif jit_type == "gcc":
from miasm.jitter.jitcore_gcc import JitCore_Gcc as JitCore
else:
raise ValueError("Unknown jitter %s" % jit_type)
except ImportError:
raise RuntimeError('Unsupported jitter: %s' % jit_type)
self.jit = JitCore(self.ir_arch, self.bs)
if isinstance(self.jit, JitCore_Cc_Base):
self.jit.init_codegen(self.C_Gen(self.ir_arch))
elif jit_type == "python":
self.jit.set_cpu_vm(self.cpu, self.vm)
self.cpu.init_regs()
self.vm.init_memory_page_pool()
self.vm.init_code_bloc_pool()
self.vm.init_memory_breakpoint()
self.jit.load()
self.cpu.vmmngr = self.vm
self.cpu.jitter = self.jit
self.stack_size = 0x10000
self.stack_base = 0x1230000
# Init callback handler
self.breakpoints_handler = CallbackHandler()
self.exceptions_handler = CallbackHandlerBitflag()
self.init_exceptions_handler()
self.exec_cb = None
class Jitter(object):
"Main class for JIT handling"
C_Gen = CGen
def __init__(self, lifter, jit_type="gcc"):
"""Init an instance of jitter.
@lifter: Lifter instance for this architecture
@jit_type: JiT backend to use. Available options are:
- "gcc"
- "llvm"
- "python"
"""
self.arch = lifter.arch
self.attrib = lifter.attrib
arch_name = lifter.arch.name # (lifter.arch.name, lifter.attrib)
try:
if arch_name == "x86":
from miasm.jitter.arch import JitCore_x86 as jcore
elif arch_name == "arm":
from miasm.jitter.arch import JitCore_arm as jcore
elif arch_name == "armt":
from miasm.jitter.arch import JitCore_arm as jcore
lifter.arch.name = 'arm'
elif arch_name == "aarch64":
from miasm.jitter.arch import JitCore_aarch64 as jcore
elif arch_name == "msp430":
from miasm.jitter.arch import JitCore_msp430 as jcore
elif arch_name == "mips32":
from miasm.jitter.arch import JitCore_mips32 as jcore
elif arch_name == "ppc32":
from miasm.jitter.arch import JitCore_ppc32 as jcore
elif arch_name == "mep":
from miasm.jitter.arch import JitCore_mep as jcore
else:
raise ValueError("unknown jit arch: %s" % arch_name)
except ImportError:
raise RuntimeError('Unsupported jit arch: %s' % arch_name)
self.vm = VmMngr.Vm()
self.cpu = jcore.JitCpu()
self.lifter = lifter
self.bs = bin_stream_vm(self.vm)
self.ircfg = self.lifter.new_ircfg()
self.symbexec = EmulatedSymbExec(
self.cpu, self.vm, self.lifter, {}
)
self.symbexec.reset_regs()
try:
if jit_type == "llvm":
from miasm.jitter.jitcore_llvm import JitCore_LLVM as JitCore
elif jit_type == "python":
from miasm.jitter.jitcore_python import JitCore_Python as JitCore
elif jit_type == "gcc":
from miasm.jitter.jitcore_gcc import JitCore_Gcc as JitCore
else:
raise ValueError("Unknown jitter %s" % jit_type)
except ImportError:
raise RuntimeError('Unsupported jitter: %s' % jit_type)
self.jit = JitCore(self.lifter, self.bs)
if isinstance(self.jit, JitCore_Cc_Base):
self.jit.init_codegen(self.C_Gen(self.lifter))
elif jit_type == "python":
self.jit.set_cpu_vm(self.cpu, self.vm)
self.cpu.init_regs()
self.vm.init_memory_page_pool()
self.vm.init_code_bloc_pool()
self.vm.init_memory_breakpoint()
self.jit.load()
self.cpu.vmmngr = self.vm
self.cpu.jitter = self.jit
self.stack_size = 0x10000
self.stack_base = 0x1230000
# Init callback handler
self.breakpoints_handler = CallbackHandler()
self.exceptions_handler = CallbackHandlerBitflag()
self.init_exceptions_handler()
self.exec_cb = None
def init_exceptions_handler(self):
"Add common exceptions handlers"
def exception_automod(jitter):
"Tell the JiT backend to update blocks modified"
self.jit.updt_automod_code(jitter.vm)
self.vm.set_exception(0)
return True
def exception_memory_breakpoint(jitter):
"Stop the execution and return an identifier"
return ExceptionHandle.memoryBreakpoint()
self.add_exception_handler(EXCEPT_CODE_AUTOMOD, exception_automod)
self.add_exception_handler(EXCEPT_BREAKPOINT_MEMORY,
exception_memory_breakpoint)
def add_breakpoint(self, addr, callback):
"""Add a callback associated with addr.
@addr: breakpoint address
@callback: function with definition (jitter instance)
"""
self.breakpoints_handler.add_callback(addr, callback)
self.jit.add_disassembly_splits(addr)
# De-jit previously jitted blocks
self.jit.updt_automod_code_range(self.vm, [(addr, addr)])
def set_breakpoint(self, addr, *args):
"""Set callbacks associated with addr.
@addr: breakpoint address
@args: functions with definition (jitter instance)
"""
self.breakpoints_handler.set_callback(addr, *args)
self.jit.add_disassembly_splits(addr)
def get_breakpoint(self, addr):
"""
Return breakpoints handlers for address @addr
@addr: integer
"""
return self.breakpoints_handler.get_callbacks(addr)
def remove_breakpoints_by_callback(self, callback):
"""Remove callbacks associated with breakpoint.
@callback: callback to remove
"""
empty_keys = self.breakpoints_handler.remove_callback(callback)
for key in empty_keys:
self.jit.remove_disassembly_splits(key)
def remove_breakpoints_by_address(self, address):
"""Remove all breakpoints associated with @address.
@address: address of breakpoints to remove
"""
callbacks = self.breakpoints_handler.remove_key(address)
if callbacks:
self.jit.remove_disassembly_splits(address)
def add_exception_handler(self, flag, callback):
"""Add a callback associated with an exception flag.
@flag: bitflag
@callback: function with definition (jitter instance)
"""
self.exceptions_handler.add_callback(flag, callback)
def run_at(self, pc):
"""Wrapper on JiT backend. Run the code at PC and return the next PC.
@pc: address of code to run"""
return self.jit.run_at(
self.cpu, pc,
set(self.breakpoints_handler.callbacks)
)
def runiter_once(self, pc):
"""Iterator on callbacks results on code running from PC.
Check exceptions before breakpoints."""
self.pc = pc
# Callback called before exec
if self.exec_cb is not None:
res = self.exec_cb(self)
if res is not True:
yield res
# Check breakpoints
old_pc = self.pc
for res in self.breakpoints_handler.call_callbacks(self.pc, self):
if res is not True:
if isinstance(res, collections.Iterator):
# If the breakpoint is a generator, yield it step by step
for tmp in res:
yield tmp
else:
yield res
# Check exceptions (raised by breakpoints)
exception_flag = self.get_exception()
for res in self.exceptions_handler(exception_flag, self):
if res is not True:
if isinstance(res, collections.Iterator):
for tmp in res:
yield tmp
else:
yield res
# If a callback changed pc, re call every callback
if old_pc != self.pc:
return
# Exceptions should never be activated before run
exception_flag = self.get_exception()
if exception_flag:
raise JitterException(exception_flag)
# Run the block at PC
self.pc = self.run_at(self.pc)
# Check exceptions (raised by the execution of the block)
exception_flag = self.get_exception()
for res in self.exceptions_handler(exception_flag, self):
if res is not True:
if isinstance(res, collections.Iterator):
for tmp in res:
yield tmp
else:
yield res
def init_run(self, pc):
"""Create an iterator on pc with runiter.
@pc: address of code to run
"""
self.run_iterator = self.runiter_once(pc)
self.pc = pc
self.run = True
def continue_run(self, step=False, trace=False):
"""PRE: init_run.
Continue the run of the current session until iterator returns or run is
set to False.
If step is True, run only one time.
If trace is True, activate trace log option until execution stops
Return the iterator value"""
if trace:
self.set_trace_log()
while self.run:
try:
return next(self.run_iterator)
except StopIteration:
pass
self.run_iterator = self.runiter_once(self.pc)
if step is True:
break
if trace:
self.set_trace_log(False, False, False)
return None
def run(self, addr):
"""
Launch emulation
@addr: (int) start address
"""
self.init_run(addr)
return self.continue_run()
def run_until(self, addr, trace=False):
"""PRE: init_run.
Continue the run of the current session until iterator returns, run is
set to False or addr is reached.
If trace is True, activate trace log option until execution stops
Return the iterator value"""
def stop_exec(jitter):
jitter.remove_breakpoints_by_callback(stop_exec)
return False
self.add_breakpoint(addr, stop_exec)
return self.continue_run(trace=trace)
def init_stack(self):
self.vm.add_memory_page(
self.stack_base,
PAGE_READ | PAGE_WRITE,
b"\x00" * self.stack_size,
"Stack")
sp = self.arch.getsp(self.attrib)
setattr(self.cpu, sp.name, self.stack_base + self.stack_size)
# regs = self.cpu.get_gpreg()
# regs[sp.name] = self.stack_base+self.stack_size
# self.cpu.set_gpreg(regs)
def get_exception(self):
return self.cpu.get_exception() | self.vm.get_exception()
# commun functions
def get_c_str(self, addr, max_char=None):
"""Get C str from vm.
@addr: address in memory
@max_char: maximum len"""
l = 0
tmp = addr
while ((max_char is None or l < max_char) and
self.vm.get_mem(tmp, 1) != b"\x00"):
tmp += 1
l += 1
value = self.vm.get_mem(addr, l)
value = force_str(value)
return value
def set_c_str(self, addr, value):
"""Set C str str from vm.
@addr: address in memory
@value: str"""
value = force_bytes(value)
self.vm.set_mem(addr, value + b'\x00')
def get_str_ansi(self, addr, max_char=None):
raise NotImplementedError("Deprecated: use os_dep.win_api_x86_32.get_win_str_a")
def get_str_unic(self, addr, max_char=None):
raise NotImplementedError("Deprecated: use os_dep.win_api_x86_32.get_win_str_a")
@staticmethod
def handle_lib(jitter):
"""Resolve the name of the function which cause the handler call. Then
call the corresponding handler from users callback.
"""
fname = jitter.libs.fad2cname[jitter.pc]
if fname in jitter.user_globals:
func = jitter.user_globals[fname]
else:
log.debug('%r', fname)
raise ValueError('unknown api', hex(jitter.pc), repr(fname))
ret = func(jitter)
jitter.pc = getattr(jitter.cpu, jitter.lifter.pc.name)
# Don't break on a None return
if ret is None:
return True
else:
return ret
def handle_function(self, f_addr):
"""Add a breakpoint which will trigger the function handler"""
self.add_breakpoint(f_addr, self.handle_lib)
def add_lib_handler(self, libs, user_globals=None):
"""Add a function to handle libs call with breakpoints
@libs: libimp instance
@user_globals: dictionary for defined user function
"""
if user_globals is None:
user_globals = {}
self.libs = libs
out = {}
for name, func in viewitems(user_globals):
out[name] = func
self.user_globals = out
for f_addr in libs.fad2cname:
self.handle_function(f_addr)
def eval_expr(self, expr):
"""Eval expression @expr in the context of the current instance. Side
effects are passed on it"""
self.symbexec.update_engine_from_cpu()
ret = self.symbexec.eval_updt_expr(expr)
self.symbexec.update_cpu_from_engine()
return ret
def set_trace_log(self,
trace_instr=True, trace_regs=True,
trace_new_blocks=False):
"""
Activate/Deactivate trace log options
@trace_instr: activate instructions tracing log
@trace_regs: activate registers tracing log
@trace_new_blocks: dump new code blocks log
"""
# As trace state changes, clear already jitted blocks
self.jit.clear_jitted_blocks()
self.jit.log_mn = trace_instr
self.jit.log_regs = trace_regs
self.jit.log_newbloc = trace_new_blocks
class Jitter(object):
"Main class for JIT handling"
C_Gen = CGen
def __init__(self, ir_arch, jit_type="gcc"):
"""Init an instance of jitter.
@ir_arch: ir instance for this architecture
@jit_type: JiT backend to use. Available options are:
- "gcc"
- "llvm"
- "python"
"""
self.arch = ir_arch.arch
self.attrib = ir_arch.attrib
arch_name = ir_arch.arch.name # (ir_arch.arch.name, ir_arch.attrib)
try:
if arch_name == "x86":
from miasm.jitter.arch import JitCore_x86 as jcore
elif arch_name == "arm":
from miasm.jitter.arch import JitCore_arm as jcore
elif arch_name == "armt":
from miasm.jitter.arch import JitCore_arm as jcore
ir_arch.arch.name = 'arm'
elif arch_name == "aarch64":
from miasm.jitter.arch import JitCore_aarch64 as jcore
elif arch_name == "msp430":
from miasm.jitter.arch import JitCore_msp430 as jcore
elif arch_name == "mips32":
from miasm.jitter.arch import JitCore_mips32 as jcore
elif arch_name == "ppc32":
from miasm.jitter.arch import JitCore_ppc32 as jcore
elif arch_name == "mep":
from miasm.jitter.arch import JitCore_mep as jcore
else:
raise ValueError("unknown jit arch: %s" % arch_name)
except ImportError:
raise RuntimeError('Unsupported jit arch: %s' % arch_name)
self.vm = VmMngr.Vm()
self.cpu = jcore.JitCpu()
self.ir_arch = ir_arch
self.bs = bin_stream_vm(self.vm)
self.ircfg = self.ir_arch.new_ircfg()
self.symbexec = EmulatedSymbExec(
self.cpu, self.vm, self.ir_arch, {}
)
self.symbexec.reset_regs()
try:
if jit_type == "llvm":
from miasm.jitter.jitcore_llvm import JitCore_LLVM as JitCore
elif jit_type == "python":
from miasm.jitter.jitcore_python import JitCore_Python as JitCore
elif jit_type == "gcc":
from miasm.jitter.jitcore_gcc import JitCore_Gcc as JitCore
else:
raise ValueError("Unknown jitter %s" % jit_type)
except ImportError:
raise RuntimeError('Unsupported jitter: %s' % jit_type)
self.jit = JitCore(self.ir_arch, self.bs)
if isinstance(self.jit, JitCore_Cc_Base):
self.jit.init_codegen(self.C_Gen(self.ir_arch))
elif jit_type == "python":
self.jit.set_cpu_vm(self.cpu, self.vm)
self.cpu.init_regs()
self.vm.init_memory_page_pool()
self.vm.init_code_bloc_pool()
self.vm.init_memory_breakpoint()
self.jit.load()
self.cpu.vmmngr = self.vm
self.cpu.jitter = self.jit
self.stack_size = 0x10000
self.stack_base = 0x1230000
# Init callback handler
self.breakpoints_handler = CallbackHandler()
self.exceptions_handler = CallbackHandlerBitflag()
self.init_exceptions_handler()
self.exec_cb = None
def init_exceptions_handler(self):
"Add common exceptions handlers"
def exception_automod(jitter):
"Tell the JiT backend to update blocks modified"
self.jit.updt_automod_code(jitter.vm)
self.vm.set_exception(0)
return True
def exception_memory_breakpoint(jitter):
"Stop the execution and return an identifier"
return ExceptionHandle.memoryBreakpoint()
self.add_exception_handler(EXCEPT_CODE_AUTOMOD, exception_automod)
self.add_exception_handler(EXCEPT_BREAKPOINT_MEMORY,
exception_memory_breakpoint)
def add_breakpoint(self, addr, callback):
"""Add a callback associated with addr.
@addr: breakpoint address
@callback: function with definition (jitter instance)
"""
self.breakpoints_handler.add_callback(addr, callback)
self.jit.add_disassembly_splits(addr)
# De-jit previously jitted blocks
self.jit.updt_automod_code_range(self.vm, [(addr, addr)])
def set_breakpoint(self, addr, *args):
"""Set callbacks associated with addr.
@addr: breakpoint address
@args: functions with definition (jitter instance)
"""
self.breakpoints_handler.set_callback(addr, *args)
self.jit.add_disassembly_splits(addr)
def get_breakpoint(self, addr):
"""
Return breakpoints handlers for address @addr
@addr: integer
"""
return self.breakpoints_handler.get_callbacks(addr)
def remove_breakpoints_by_callback(self, callback):
"""Remove callbacks associated with breakpoint.
@callback: callback to remove
"""
empty_keys = self.breakpoints_handler.remove_callback(callback)
for key in empty_keys:
self.jit.remove_disassembly_splits(key)
def remove_breakpoints_by_address(self, address):
"""Remove all breakpoints associated with @address.
@address: address of breakpoints to remove
"""
callbacks = self.breakpoints_handler.remove_key(address)
if callbacks:
self.jit.remove_disassembly_splits(address)
def add_exception_handler(self, flag, callback):
"""Add a callback associated with an exception flag.
@flag: bitflag
@callback: function with definition (jitter instance)
"""
self.exceptions_handler.add_callback(flag, callback)
def run_at(self, pc):
"""Wrapper on JiT backend. Run the code at PC and return the next PC.
@pc: address of code to run"""
return self.jit.run_at(
self.cpu, pc,
set(self.breakpoints_handler.callbacks)
)
def runiter_once(self, pc):
"""Iterator on callbacks results on code running from PC.
Check exceptions before breakpoints."""
self.pc = pc
# Callback called before exec
if self.exec_cb is not None:
res = self.exec_cb(self)
if res is not True:
yield res
# Check breakpoints
old_pc = self.pc
for res in self.breakpoints_handler.call_callbacks(self.pc, self):
if res is not True:
if isinstance(res, collections.Iterator):
# If the breakpoint is a generator, yield it step by step
for tmp in res:
yield tmp
else:
yield res
# Check exceptions (raised by breakpoints)
exception_flag = self.get_exception()
for res in self.exceptions_handler(exception_flag, self):
if res is not True:
if isinstance(res, collections.Iterator):
for tmp in res:
yield tmp
else:
yield res
# If a callback changed pc, re call every callback
if old_pc != self.pc:
return
# Exceptions should never be activated before run
assert(self.get_exception() == 0)
# Run the bloc at PC
self.pc = self.run_at(self.pc)
# Check exceptions (raised by the execution of the block)
exception_flag = self.get_exception()
for res in self.exceptions_handler(exception_flag, self):
if res is not True:
if isinstance(res, collections.Iterator):
for tmp in res:
yield tmp
else:
yield res
def init_run(self, pc):
"""Create an iterator on pc with runiter.
@pc: address of code to run
"""
self.run_iterator = self.runiter_once(pc)
self.pc = pc
self.run = True
def continue_run(self, step=False):
"""PRE: init_run.
Continue the run of the current session until iterator returns or run is
set to False.
If step is True, run only one time.
Return the iterator value"""
while self.run:
try:
return next(self.run_iterator)
except StopIteration:
pass
self.run_iterator = self.runiter_once(self.pc)
if step is True:
return None
return None
def init_stack(self):
self.vm.add_memory_page(
self.stack_base,
PAGE_READ | PAGE_WRITE,
b"\x00" * self.stack_size,
"Stack")
sp = self.arch.getsp(self.attrib)
setattr(self.cpu, sp.name, self.stack_base + self.stack_size)
# regs = self.cpu.get_gpreg()
# regs[sp.name] = self.stack_base+self.stack_size
# self.cpu.set_gpreg(regs)
def get_exception(self):
return self.cpu.get_exception() | self.vm.get_exception()
# commun functions
def get_str_ansi(self, addr, max_char=None):
"""Get ansi str from vm.
@addr: address in memory
@max_char: maximum len"""
l = 0
tmp = addr
while ((max_char is None or l < max_char) and
self.vm.get_mem(tmp, 1) != b"\x00"):
tmp += 1
l += 1
return self.vm.get_mem(addr, l)
def get_str_unic(self, addr, max_char=None):
"""Get unicode str from vm.
@addr: address in memory
@max_char: maximum len"""
l = 0
tmp = addr
while ((max_char is None or l < max_char) and
self.vm.get_mem(tmp, 2) != b"\x00\x00"):
tmp += 2
l += 2
s = self.vm.get_mem(addr, l)
s = s.decode("utf-16le")
return s
def set_str_ansi(self, addr, s):
"""Set an ansi string in memory"""
s = s + b"\x00"
self.vm.set_mem(addr, s)
def set_str_unic(self, addr, s):
"""Set an unicode string in memory"""
s = b"\x00".join(list(s)) + b'\x00' * 3
self.vm.set_mem(addr, s)
@staticmethod
def handle_lib(jitter):
"""Resolve the name of the function which cause the handler call. Then
call the corresponding handler from users callback.
"""
fname = jitter.libs.fad2cname[jitter.pc]
if fname in jitter.user_globals:
func = jitter.user_globals[fname]
else:
log.debug('%r', fname)
raise ValueError('unknown api', hex(jitter.pc), repr(fname))
ret = func(jitter)
jitter.pc = getattr(jitter.cpu, jitter.ir_arch.pc.name)
# Don't break on a None return
if ret is None:
return True
else:
return ret
def handle_function(self, f_addr):
"""Add a breakpoint which will trigger the function handler"""
self.add_breakpoint(f_addr, self.handle_lib)
def add_lib_handler(self, libs, user_globals=None):
"""Add a function to handle libs call with breakpoints
@libs: libimp instance
@user_globals: dictionary for defined user function
"""
if user_globals is None:
user_globals = {}
self.libs = libs
out = {}
for name, func in viewitems(user_globals):
name = force_bytes(name)
out[name] = func
self.user_globals = out
for f_addr in libs.fad2cname:
self.handle_function(f_addr)
def eval_expr(self, expr):
"""Eval expression @expr in the context of the current instance. Side
effects are passed on it"""
self.symbexec.update_engine_from_cpu()
ret = self.symbexec.eval_updt_expr(expr)
self.symbexec.update_cpu_from_engine()
return ret
def set_trace_log(self,
trace_instr=True, trace_regs=True,
trace_new_blocks=False):
"""
Activate/Deactivate trace log options
@trace_instr: activate instructions tracing log
@trace_regs: activate registers tracing log
@trace_new_blocks: dump new code blocks log
"""
# As trace state changes, clear already jitted blocks
self.jit.clear_jitted_blocks()
self.jit.log_mn = trace_instr
self.jit.log_regs = trace_regs
self.jit.log_newbloc = trace_new_blocks