diff --git a/README_cn.md b/README_cn.md index 0d39530..87ffc82 100644 --- a/README_cn.md +++ b/README_cn.md @@ -63,7 +63,7 @@ class XGorgen(metaclass=JavaClassDef, jvm_name='com/ss/sys/ces/a'): pass @java_method_def(name='leviathan', signature='(I[B)[B', native=True) - def leviathan(self, mu): + def leviathan(self, uc): pass def test(self): diff --git a/examples/debug_utils.py b/examples/debug_utils.py index 573c278..611ffe1 100644 --- a/examples/debug_utils.py +++ b/examples/debug_utils.py @@ -5,29 +5,29 @@ logger = logging.getLogger(__name__) -def hook_code(mu, address, size, user_data): - instruction = mu.mem_read(address, size) +def hook_code(uc, address, size, user_data): + instruction = uc.mem_read(address, size) instruction_str = ''.join('{:02x} '.format(x) for x in instruction) logger.debug('# Tracing instruction at 0x%x, instruction size = 0x%x, instruction = %s' % (address, size, instruction_str)) if instruction == b"\x00\x00\x00\x00": logger.error("Uh oh, we messed up.") - mu.emu_stop() + uc.emu_stop() -def hook_block(mu, address, size, user_data): - instruction = mu.mem_read(address, size) +def hook_block(uc, address, size, user_data): + instruction = uc.mem_read(address, size) instruction_str = ''.join('{:02x} '.format(x) for x in instruction) logger.debug('# Block at 0x%x, instruction size = 0x%x, instruction = %s' % (address, size, instruction_str)) -def hook_unmapped(mu, access, address, length, value, context): - pc = mu.reg_read(UC_ARM_REG_PC) +def hook_unmapped(uc, access, address, length, value, context): + pc = uc.reg_read(UC_ARM_REG_PC) logger.debug("mem unmapped: pc: %x access: %x address: %x length: %x value: %x" % (pc, access, address, length, value)) - mu.emu_stop() + uc.emu_stop() return True diff --git a/examples/example.py b/examples/example.py index 98f098b..0d29fc0 100644 --- a/examples/example.py +++ b/examples/example.py @@ -28,16 +28,16 @@ # Add debugging. -def hook_code(mu, address, size, user_data): - instruction = mu.mem_read(address, size) +def hook_code(uc, address, size, user_data): + instruction = uc.mem_read(address, size) instruction_str = ''.join('{:02x} '.format(x) for x in instruction) print('# Tracing instruction at 0x%x, instruction size = 0x%x, instruction = %s' % (address, size, instruction_str)) -emulator.mu.hook_add(UC_HOOK_CODE, hook_code) +emulator.uc.hook_add(UC_HOOK_CODE, hook_code) # Runs a method of "libnative-lib.so" that calls an imported function "strlen" from "libc.so". emulator.call_symbol(lib_module, '_Z4testv') -print("String length is: %i" % emulator.mu.reg_read(UC_ARM_REG_R0)) +print("String length is: %i" % emulator.uc.reg_read(UC_ARM_REG_R0)) diff --git a/examples/example_douyin.py b/examples/example_douyin.py index b96f2fa..7497a67 100644 --- a/examples/example_douyin.py +++ b/examples/example_douyin.py @@ -18,7 +18,7 @@ def __init__(self): pass @java_method_def(name='leviathan', signature='(I[B)[B', native=True) - def leviathan(self, mu): + def leviathan(self, uc): pass def test(self): @@ -30,11 +30,11 @@ def __init__(self): pass @java_method_def(name='n0', signature='(Landroid/content/Context;)[B', native=True) - def n0(self, mu): + def n0(self, uc): pass @java_method_def(name='n1', signature='(Landroid/content/Context;Ljava/lang/String;)I', native=True) - def n1(self, mu): + def n1(self, uc): pass @@ -131,10 +131,10 @@ def getStackTrace(self, *args, **kwargs): logger.info("=> 0x%08x - %s" % (module.base, module.filename)) # Debug -# emulator.mu.hook_add(UC_HOOK_CODE, debug_utils.hook_code) -emulator.mu.hook_add(UC_HOOK_MEM_UNMAPPED, debug_utils.hook_unmapped) -# emulator.mu.hook_add(UC_HOOK_MEM_WRITE, debug_utils.hook_mem_write) -# emulator.mu.hook_add(UC_HOOK_MEM_READ, debug_utils.hook_mem_read) +# emulator.uc.hook_add(UC_HOOK_CODE, debug_utils.hook_code) +emulator.uc.hook_add(UC_HOOK_MEM_UNMAPPED, debug_utils.hook_unmapped) +# emulator.uc.hook_add(UC_HOOK_MEM_WRITE, debug_utils.hook_mem_write) +# emulator.uc.hook_add(UC_HOOK_MEM_READ, debug_utils.hook_mem_read) try: # Run JNI_OnLoad. @@ -145,8 +145,8 @@ def getStackTrace(self, *args, **kwargs): with open("./misc/app_process32", 'rb') as ap: data = ap.read() len1 = len(data) + 1024 - (len(data) % 1024) - emulator.mu.mem_map(0xab006000, len1) - emulator.mu.mem_write(0xab006000, data) + emulator.uc.mem_map(0xab006000, len1) + emulator.uc.mem_write(0xab006000, data) x = XGorgen() data = 'acde74a94e6b493a3399fac83c7c08b35D58B21D9582AF77647FC9902E36AE70f9c001e9334e6e94916682224fbe4e5f00000000000000000000000000000000' @@ -167,5 +167,5 @@ def getStackTrace(self, *args, **kwargs): # if method.native: # logger.info("- [0x%08x] %s - %s" % (method.native_addr, method.name, method.signature)) except UcError as e: - print("Exit at %x" % emulator.mu.reg_read(UC_ARM_REG_PC)) + print("Exit at %x" % emulator.uc.reg_read(UC_ARM_REG_PC)) raise diff --git a/examples/example_jiagu.py b/examples/example_jiagu.py index 0e15889..da6c909 100644 --- a/examples/example_jiagu.py +++ b/examples/example_jiagu.py @@ -19,7 +19,7 @@ def __init__(self): pass @java_method_def(name='stringFromJNI', signature='()Ljava/lang/String;', native=True) - def string_from_jni(self, mu): + def string_from_jni(self, uc): pass def test(self): @@ -58,19 +58,19 @@ def test(self): logger.info("=> 0x%08x - %s" % (module.base, module.filename)) # Debug -# emulator.mu.hook_add(UC_HOOK_CODE, debug_utils.hook_code) -# emulator.mu.hook_add(UC_HOOK_MEM_UNMAPPED, debug_utils.hook_unmapped) -# emulator.mu.hook_add(UC_HOOK_MEM_WRITE, debug_utils.hook_mem_write) -# emulator.mu.hook_add(UC_HOOK_MEM_READ, debug_utils.hook_mem_read) +# emulator.uc.hook_add(UC_HOOK_CODE, debug_utils.hook_code) +# emulator.uc.hook_add(UC_HOOK_MEM_UNMAPPED, debug_utils.hook_unmapped) +# emulator.uc.hook_add(UC_HOOK_MEM_WRITE, debug_utils.hook_mem_write) +# emulator.uc.hook_add(UC_HOOK_MEM_READ, debug_utils.hook_mem_read) try: # Run JNI_OnLoad. # JNI_OnLoad will call 'RegisterNatives'. emulator.call_symbol(lib_module, 'JNI_OnLoad', emulator.java_vm.address_ptr, 0x00) - emulator.mu.hook_add(UC_HOOK_MEM_UNMAPPED, debug_utils.hook_unmapped) + emulator.uc.hook_add(UC_HOOK_MEM_UNMAPPED, debug_utils.hook_unmapped) # Do native stuff. - emulator.mu.hook_add(UC_HOOK_CODE, debug_utils.hook_code) + emulator.uc.hook_add(UC_HOOK_CODE, debug_utils.hook_code) main_activity = MainActivity() logger.info("Response from JNI call: %s" % main_activity.string_from_jni(emulator)) @@ -82,5 +82,5 @@ def test(self): if method.native: logger.info("- [0x%08x] %s - %s" % (method.native_addr, method.name, method.signature)) except UcError as e: - print("Exit at %x" % emulator.mu.reg_read(UC_ARM_REG_PC)) + print("Exit at %x" % emulator.uc.reg_read(UC_ARM_REG_PC)) raise diff --git a/examples/example_jni.py b/examples/example_jni.py index 83db3f4..672c2ac 100644 --- a/examples/example_jni.py +++ b/examples/example_jni.py @@ -19,7 +19,7 @@ def __init__(self): pass @java_method_def(name='stringFromJNI', signature='()Ljava/lang/String;', native=True) - def string_from_jni(self, mu): + def string_from_jni(self, uc): pass def test(self): @@ -41,8 +41,8 @@ def test(self): vfs_root=posixpath.join(posixpath.dirname(__file__), "vfs") ) -# emulator.mu.hook_add(UC_HOOK_CODE, debug_utils.hook_code) -# emulator.mu.hook_add(UC_HOOK_MEM_UNMAPPED, debug_utils.hook_unmapped) +# emulator.uc.hook_add(UC_HOOK_CODE, debug_utils.hook_code) +# emulator.uc.hook_add(UC_HOOK_MEM_UNMAPPED, debug_utils.hook_unmapped) # Register Java class. emulator.java_classloader.add_class(MainActivity) @@ -61,10 +61,10 @@ def test(self): logger.info("=> 0x%08x - %s" % (module.base, module.filename)) # Debug -# emulator.mu.hook_add(UC_HOOK_CODE, debug_utils.hook_code) -# emulator.mu.hook_add(UC_HOOK_MEM_UNMAPPED, debug_utils.hook_unmapped) -# emulator.mu.hook_add(UC_HOOK_MEM_WRITE, debug_utils.hook_mem_write) -# emulator.mu.hook_add(UC_HOOK_MEM_READ, debug_utils.hook_mem_read) +# emulator.uc.hook_add(UC_HOOK_CODE, debug_utils.hook_code) +# emulator.uc.hook_add(UC_HOOK_MEM_UNMAPPED, debug_utils.hook_unmapped) +# emulator.uc.hook_add(UC_HOOK_MEM_WRITE, debug_utils.hook_mem_write) +# emulator.uc.hook_add(UC_HOOK_MEM_READ, debug_utils.hook_mem_read) try: # Run JNI_OnLoad. @@ -83,5 +83,5 @@ def test(self): if method.native: logger.info("- [0x%08x] %s - %s" % (method.native_addr, method.name, method.signature)) except UcError as e: - print("Exit at %x" % emulator.mu.reg_read(UC_ARM_REG_PC)) + print("Exit at %x" % emulator.uc.reg_read(UC_ARM_REG_PC)) raise diff --git a/src/androidemu/cpu/interrupt_handler.py b/src/androidemu/cpu/interrupt_handler.py index 2b707cf..aa3b320 100644 --- a/src/androidemu/cpu/interrupt_handler.py +++ b/src/androidemu/cpu/interrupt_handler.py @@ -9,19 +9,19 @@ class InterruptHandler: """ - :type mu Uc + :type uc Uc """ - def __init__(self, mu): - self._mu = mu - self._mu.hook_add(UC_HOOK_INTR, self._hook_interrupt) + def __init__(self, uc): + self._uc = uc + self._uc.hook_add(UC_HOOK_INTR, self._hook_interrupt) self._handlers = dict() def _hook_interrupt(self, uc, intno, data): if intno in self._handlers: self._handlers[intno](uc) else: - logger.error("Unhandled interrupt %d at %x, stopping emulation" % (intno, self._mu.reg_read(UC_ARM_REG_PC))) - self._mu.emu_stop() + logger.error("Unhandled interrupt %d at %x, stopping emulation" % (intno, self._uc.reg_read(UC_ARM_REG_PC))) + self._uc.emu_stop() def set_handler(self, intno, handler): self._handlers[intno] = handler diff --git a/src/androidemu/cpu/syscall_handlers.py b/src/androidemu/cpu/syscall_handlers.py index 57a192d..d905ba6 100644 --- a/src/androidemu/cpu/syscall_handlers.py +++ b/src/androidemu/cpu/syscall_handlers.py @@ -22,29 +22,29 @@ def __init__(self, interrupt_handler): def set_handler(self, idx, name, arg_count, callback): self._handlers[idx] = SyscallHandler(idx, name, arg_count, callback) - def _handle_syscall(self, mu): - idx = mu.reg_read(UC_ARM_REG_R7) - args = [mu.reg_read(reg_idx) for reg_idx in range(UC_ARM_REG_R0, UC_ARM_REG_R6 + 1)] + def _handle_syscall(self, uc): + idx = uc.reg_read(UC_ARM_REG_R7) + args = [uc.reg_read(reg_idx) for reg_idx in range(UC_ARM_REG_R0, UC_ARM_REG_R6 + 1)] if idx in self._handlers: handler = self._handlers[idx] args = args[:handler.arg_count] args_formatted = ", ".join(["%08x" % arg for arg in args]) logger.debug("Executing syscall %s(%s) at 0x%x" % (handler.name, args_formatted, - mu.reg_read(UC_ARM_REG_PC))) + uc.reg_read(UC_ARM_REG_PC))) try: - result = handler.callback(mu, *args) + result = handler.callback(uc, *args) except: logger.error("An error occured during in %x syscall hander, stopping emulation" % idx) - mu.emu_stop() + uc.emu_stop() raise if result is not None: - mu.reg_write(UC_ARM_REG_R0, result) + uc.reg_write(UC_ARM_REG_R0, result) else: error = "Unhandled syscall 0x%x (%u) at 0x%x, stopping emulation" % (idx, idx, - mu.reg_read(UC_ARM_REG_PC)) - mu.emu_stop() + uc.reg_read(UC_ARM_REG_PC)) + uc.emu_stop() raise RuntimeError(error) diff --git a/src/androidemu/cpu/syscall_hooks.py b/src/androidemu/cpu/syscall_hooks.py index 9a15f3a..952f6de 100644 --- a/src/androidemu/cpu/syscall_hooks.py +++ b/src/androidemu/cpu/syscall_hooks.py @@ -30,11 +30,11 @@ class SyscallHooks: """ - :type mu Uc + :type uc Uc :type syscall_handler SyscallHandlers """ - def __init__(self, mu, syscall_handler, modules: Modules): - self._mu = mu + def __init__(self, uc, syscall_handler, modules: Modules): + self._uc = uc self._syscall_handler = syscall_handler self._syscall_handler.set_handler(0xB, "execve", 3, self._handle_execve) self._syscall_handler.set_handler(0x43, "sigaction", 3, self._null) @@ -66,42 +66,42 @@ def __init__(self, mu, syscall_handler, modules: Modules): self._sockets = dict() self._fork = None - def _getpid(self, mu): + def _getpid(self, uc): return 21458 - def _handle_execve(self, mu, pathname_ptr, argv, envp): - pathname = memory_helpers.read_utf8(mu, pathname_ptr) + def _handle_execve(self, uc, pathname_ptr, argv, envp): + pathname = memory_helpers.read_utf8(uc, pathname_ptr) args = [] while True: - arg_ptr = int.from_bytes(mu.mem_read(argv, 4), byteorder='little') + arg_ptr = int.from_bytes(uc.mem_read(argv, 4), byteorder='little') if arg_ptr == 0: break - args.append(memory_helpers.read_utf8(mu, arg_ptr)) + args.append(memory_helpers.read_utf8(uc, arg_ptr)) argv = argv + 4 # Set errno. errno_ptr = self._modules.find_symbol_name('__errno') - mu.mem_write(errno_ptr, int(13).to_bytes(4, byteorder='little')) + uc.mem_write(errno_ptr, int(13).to_bytes(4, byteorder='little')) logger.warning('Exec %s %s' % (pathname, args)) return 0 - def _null(self, mu, *args): + def _null(self, uc, *args): logger.warning('Skipping syscall, returning 0') return 0 - def _gettid(self, mu): + def _gettid(self, uc): return 0x2211 - def _faccessat(self, mu, filename, pathname, mode, flag): - file = memory_helpers.read_utf8(mu, pathname) + def _faccessat(self, uc, filename, pathname, mode, flag): + file = memory_helpers.read_utf8(uc, pathname) return 0 - def _getcpu(self, mu, _cpu, node, cache): + def _getcpu(self, uc, _cpu, node, cache): if _cpu != 0: - mu.mem_write(_cpu, int(1).to_bytes(4, byteorder='little')) + uc.mem_write(_cpu, int(1).to_bytes(4, byteorder='little')) return 0 def _handle_gettimeofday(self, uc, tv, tz): @@ -127,13 +127,13 @@ def _handle_gettimeofday(self, uc, tv, tz): return 0 - def _handle_wait4(self, mu, upid, stat_addr, options, ru): + def _handle_wait4(self, uc, upid, stat_addr, options, ru): """ on success, returns the process ID of the terminated child; on error, -1 is returned. """ return upid - def _handle_prctl(self, mu, option, arg2, arg3, arg4, arg5): + def _handle_prctl(self, uc, option, arg2, arg3, arg4, arg5): """ int prctl(int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5); See: @@ -151,7 +151,7 @@ def _handle_prctl(self, mu, option, arg2, arg3, arg4, arg5): else: raise NotImplementedError("Unsupported prctl option %d (0x%x)" % (option, option)) - def _handle_vfork(self, mu): + def _handle_vfork(self, uc): """ Upon successful completion, vfork() shall return 0 to the child process and return the process ID of the child process to the parent process. @@ -162,7 +162,7 @@ def _handle_vfork(self, mu): if self._fork is not None: raise NotImplementedError('Already forked.') - self._fork = ForkInfo(mu, self._getpid(mu) + 1) + self._fork = ForkInfo(uc, self._getpid(uc) + 1) # Current execution becomes the fork, save all registers so we can return to vfork later for the main process. # See exit_group. @@ -170,7 +170,7 @@ def _handle_vfork(self, mu): return 0 - def _handle_futex(self, mu, uaddr, op, val, timeout, uaddr2, val3): + def _handle_futex(self, uc, uaddr, op, val, timeout, uaddr2, val3): """ See: https://linux.die.net/man/2/futex """ @@ -189,7 +189,7 @@ def _handle_futex(self, mu, uaddr, op, val, timeout, uaddr2, val3): return 0 - def _exit_group(self, mu, status): + def _exit_group(self, uc, status): if self._fork is not None: pid = self._fork.pid @@ -201,7 +201,7 @@ def _exit_group(self, mu, status): raise Exception('Application shutdown all threads, status %u' % status) - def _handle_clock_gettime(self, mu, clk_id, tp_ptr): + def _handle_clock_gettime(self, uc, clk_id, tp_ptr): """ The functions clock_gettime() retrieve the time of the specified clock clk_id. @@ -216,23 +216,23 @@ def _handle_clock_gettime(self, mu, clk_id, tp_ptr): # Its time represents seconds and nanoseconds since the Epoch. clock_real = calendar.timegm(time.gmtime()) - mu.mem_write(tp_ptr + 0, int(clock_real).to_bytes(4, byteorder='little')) - mu.mem_write(tp_ptr + 4, int(0).to_bytes(4, byteorder='little')) + uc.mem_write(tp_ptr + 0, int(clock_real).to_bytes(4, byteorder='little')) + uc.mem_write(tp_ptr + 4, int(0).to_bytes(4, byteorder='little')) return 0 elif clk_id == CLOCK_MONOTONIC or clk_id == CLOCK_MONOTONIC_COARSE: if OVERRIDE_CLOCK: - mu.mem_write(tp_ptr + 0, int(OVERRIDE_CLOCK_TIME).to_bytes(4, byteorder='little')) - mu.mem_write(tp_ptr + 4, int(0).to_bytes(4, byteorder='little')) + uc.mem_write(tp_ptr + 0, int(OVERRIDE_CLOCK_TIME).to_bytes(4, byteorder='little')) + uc.mem_write(tp_ptr + 4, int(0).to_bytes(4, byteorder='little')) else: clock_add = time.time() - self._clock_start # Seconds passed since clock_start was set. - mu.mem_write(tp_ptr + 0, int(self._clock_start + clock_add).to_bytes(4, byteorder='little')) - mu.mem_write(tp_ptr + 4, int(0).to_bytes(4, byteorder='little')) + uc.mem_write(tp_ptr + 0, int(self._clock_start + clock_add).to_bytes(4, byteorder='little')) + uc.mem_write(tp_ptr + 4, int(0).to_bytes(4, byteorder='little')) return 0 else: raise NotImplementedError("Unsupported clk_id: %d (%x)" % (clk_id, clk_id)) - def _socket(self, mu, family, type_in, protocol): + def _socket(self, uc, family, type_in, protocol): socket_id = self._socket_id + 1 socket = SocketInfo() socket.domain = family @@ -244,7 +244,7 @@ def _socket(self, mu, family, type_in, protocol): return socket_id - def _bind(self, mu, fd, addr, addr_len): + def _bind(self, uc, fd, addr, addr_len): socket = self._sockets.get(fd, None) if socket is None: @@ -254,22 +254,22 @@ def _bind(self, mu, fd, addr, addr_len): raise Exception('Unexpected socket domain / type.') # The struct is confusing.. - socket.addr = mu.mem_read(addr + 3, addr_len - 3).decode(encoding="utf-8") + socket.addr = uc.mem_read(addr + 3, addr_len - 3).decode(encoding="utf-8") logger.info('Binding socket to ://%s' % socket.addr) return 0 - def _connect(self, mu, fd, addr, addr_len): + def _connect(self, uc, fd, addr, addr_len): """ If the connection or binding succeeds, zero is returned. On error, -1 is returned, and errno is set appropriately. """ - hexdump.hexdump(mu.mem_read(addr, addr_len)) + hexdump.hexdump(uc.mem_read(addr, addr_len)) # return 0 raise NotImplementedError() - def _getrandom(self, mu, buf, count, flags): - mu.mem_write(buf, b"\x01" * count) + def _getrandom(self, uc, buf, count, flags): + uc.mem_write(buf, b"\x01" * count) return count diff --git a/src/androidemu/emulator.py b/src/androidemu/emulator.py index 4d31283..6684434 100644 --- a/src/androidemu/emulator.py +++ b/src/androidemu/emulator.py @@ -27,12 +27,12 @@ class Emulator: """ - :type mu Uc + :type uc Uc :type modules Modules """ def __init__(self, vfs_root: str = None, vfp_inst_set: bool = False): # Unicorn. - self.mu = Uc(UC_ARCH_ARM, UC_MODE_ARM) + self.uc = Uc(UC_ARCH_ARM, UC_MODE_ARM) if vfp_inst_set: self._enable_vfp() @@ -41,18 +41,18 @@ def __init__(self, vfs_root: str = None, vfp_inst_set: bool = False): self.system_properties = {"libc.debug.malloc.options": ""} # Stack. - self.mu.mem_map(STACK_ADDR, STACK_SIZE) - self.mu.reg_write(UC_ARM_REG_SP, STACK_ADDR + STACK_SIZE) + self.uc.mem_map(STACK_ADDR, STACK_SIZE) + self.uc.reg_write(UC_ARM_REG_SP, STACK_ADDR + STACK_SIZE) # Executable data. self.modules = Modules(self) - self.memory_manager = MemoryManager(self.mu) + self.memory_manager = MemoryManager(self.uc) # CPU - self.interrupt_handler = InterruptHandler(self.mu) + self.interrupt_handler = InterruptHandler(self.uc) self.syscall_handler = SyscallHandlers(self.interrupt_handler) - self.syscall_hooks = SyscallHooks(self.mu, self.syscall_handler, self.modules) - self.syscall_hooks_memory = SyscallHooksMemory(self.mu, self.memory_manager, self.syscall_handler) + self.syscall_hooks = SyscallHooks(self.uc, self.syscall_handler, self.modules) + self.syscall_hooks_memory = SyscallHooksMemory(self.uc, self.memory_manager, self.syscall_handler) # File System if vfs_root is not None: @@ -61,7 +61,7 @@ def __init__(self, vfs_root: str = None, vfp_inst_set: bool = False): self.vfs = None # Hooker - self.mu.mem_map(HOOK_MEMORY_BASE, HOOK_MEMORY_SIZE) + self.uc.mem_map(HOOK_MEMORY_BASE, HOOK_MEMORY_SIZE) self.hooker = Hooker(self, HOOK_MEMORY_BASE, HOOK_MEMORY_SIZE) # JavaVM @@ -72,7 +72,7 @@ def __init__(self, vfs_root: str = None, vfp_inst_set: bool = False): self.native_hooks = NativeHooks(self, self.memory_manager, self.modules, self.hooker) # Tracer - self.tracer = Tracer(self.mu, self.modules) + self.tracer = Tracer(self.uc, self.modules) # Thread. self._setup_thread_register() @@ -101,13 +101,13 @@ def _enable_vfp(self): code_bytes = bytes.fromhex(code) try: - self.mu.mem_map(address, mem_size) - self.mu.mem_write(address, code_bytes) - self.mu.reg_write(UC_ARM_REG_SP, address + mem_size) + self.uc.mem_map(address, mem_size) + self.uc.mem_write(address, code_bytes) + self.uc.reg_write(UC_ARM_REG_SP, address + mem_size) - self.mu.emu_start(address | 1, address + len(code_bytes)) + self.uc.emu_start(address | 1, address + len(code_bytes)) finally: - self.mu.mem_unmap(address, mem_size) + self.uc.mem_unmap(address, mem_size) def _setup_thread_register(self): """ @@ -126,16 +126,16 @@ def _setup_thread_register(self): thread_info_5 = thread_info + (thread_info_size * 4) # Thread name - write_utf8(self.mu, thread_info_5, "AndroidNativeEmu") + write_utf8(self.uc, thread_info_5, "AndroidNativeEmu") # R4 - self.mu.mem_write(thread_info_2 + 0x4, int(thread_info_5).to_bytes(4, byteorder='little')) - self.mu.mem_write(thread_info_2 + 0xC, int(thread_info_3).to_bytes(4, byteorder='little')) + self.uc.mem_write(thread_info_2 + 0x4, int(thread_info_5).to_bytes(4, byteorder='little')) + self.uc.mem_write(thread_info_2 + 0xC, int(thread_info_3).to_bytes(4, byteorder='little')) # R1 - self.mu.mem_write(thread_info_1 + 0x4, int(thread_info_4).to_bytes(4, byteorder='little')) - self.mu.mem_write(thread_info_1 + 0xC, int(thread_info_2).to_bytes(4, byteorder='little')) - self.mu.reg_write(UC_ARM_REG_C13_C0_3, thread_info_1) + self.uc.mem_write(thread_info_1 + 0x4, int(thread_info_4).to_bytes(4, byteorder='little')) + self.uc.mem_write(thread_info_1 + 0xC, int(thread_info_2).to_bytes(4, byteorder='little')) + self.uc.reg_write(UC_ARM_REG_C13_C0_3, thread_info_1) def load_library(self, filename, do_init=True): libmod = self.modules.load_module(filename) @@ -166,15 +166,15 @@ def call_native(self, addr, *argv, is_return_jobject=True): try: # Execute native call. - self.mu.reg_write(UC_ARM_REG_SP, STACK_ADDR + STACK_SIZE) + self.uc.reg_write(UC_ARM_REG_SP, STACK_ADDR + STACK_SIZE) native_write_args(self, *argv) stop_pos = randint(HOOK_MEMORY_BASE, HOOK_MEMORY_BASE + HOOK_MEMORY_SIZE) | 1 - self.mu.reg_write(UC_ARM_REG_LR, stop_pos) - self.mu.emu_start(addr, stop_pos - 1) + self.uc.reg_write(UC_ARM_REG_LR, stop_pos) + self.uc.emu_start(addr, stop_pos - 1) # Read result from locals if jni. if is_jni and is_return_jobject: - result_idx = self.mu.reg_read(UC_ARM_REG_R0) + result_idx = self.uc.reg_read(UC_ARM_REG_R0) result = self.java_vm.jni_env.get_local_reference(result_idx) if result is None: @@ -182,7 +182,7 @@ def call_native(self, addr, *argv, is_return_jobject=True): return result.value else: - return self.mu.reg_read(UC_ARM_REG_R0) + return self.uc.reg_read(UC_ARM_REG_R0) finally: # Clear locals if jni. if is_jni: @@ -191,8 +191,8 @@ def call_native(self, addr, *argv, is_return_jobject=True): def dump(self, out_dir): os.makedirs(out_dir) - for begin, end, prot in [reg for reg in self.mu.mem_regions()]: + for begin, end, prot in [reg for reg in self.uc.mem_regions()]: filename = "{:#010x}-{:#010x}.bin".format(begin, end) pathname = os.path.join(out_dir, filename) with open(pathname, "w") as f: - f.write(hexdump.hexdump(self.mu.mem_read(begin, end - begin), result='return')) + f.write(hexdump.hexdump(self.uc.mem_read(begin, end - begin), result='return')) diff --git a/src/androidemu/hooker.py b/src/androidemu/hooker.py index e4b8cfd..f3e57f2 100644 --- a/src/androidemu/hooker.py +++ b/src/androidemu/hooker.py @@ -20,7 +20,7 @@ def __init__(self, emu, base_addr, size): self._hook_magic = base_addr self._hook_start = base_addr + 4 self._hook_current = self._hook_start - self._emu.mu.hook_add(UC_HOOK_CODE, self._hook, None, self._hook_start, self._hook_start + size) + self._emu.uc.hook_add(UC_HOOK_CODE, self._hook, None, self._hook_start, self._hook_start + size) def _get_next_id(self): idx = self._current_id @@ -45,7 +45,7 @@ def write_function(self, func): raise ValueError("Expected asm_count to be 4 instead of %u." % asm_count) # Write assembly code to the emulator. - self._emu.mu.mem_write(hook_addr, bytes(asm_bytes_list)) + self._emu.uc.mem_write(hook_addr, bytes(asm_bytes_list)) # Save results. self._hook_current += len(asm_bytes_list) @@ -73,23 +73,23 @@ def write_function_table(self, table): address = hook_map[index] if index in hook_map else 0 table_bytes += int(address + 1).to_bytes(4, byteorder='little') # + 1 because THUMB. - self._emu.mu.mem_write(table_address, table_bytes) + self._emu.uc.mem_write(table_address, table_bytes) self._hook_current += len(table_bytes) # Then we write the a pointer to the table. ptr_address = self._hook_current - self._emu.mu.mem_write(ptr_address, table_address.to_bytes(4, byteorder='little')) + self._emu.uc.mem_write(ptr_address, table_address.to_bytes(4, byteorder='little')) self._hook_current += 4 return ptr_address, table_address - def _hook(self, mu, address, size, user_data): + def _hook(self, uc, address, size, user_data): # Check if instruction is "MOV R4, R4" - if size != 2 or self._emu.mu.mem_read(address, size) != b"\x24\x46": + if size != 2 or self._emu.uc.mem_read(address, size) != b"\x24\x46": return # Find hook. - hook_id = self._emu.mu.reg_read(UC_ARM_REG_R4) + hook_id = self._emu.uc.reg_read(UC_ARM_REG_R4) hook_func = self._hooks[hook_id] # Call hook. @@ -97,5 +97,5 @@ def _hook(self, mu, address, size, user_data): hook_func(self._emu) except: # Make sure we catch exceptions inside hooks and stop emulation. - mu.emu_stop() + uc.emu_stop() raise diff --git a/src/androidemu/internal/modules.py b/src/androidemu/internal/modules.py index ca50f3b..3605dfe 100644 --- a/src/androidemu/internal/modules.py +++ b/src/androidemu/internal/modules.py @@ -87,8 +87,8 @@ def load_module(self, filename): (seg_addr, seg_size) = align(load_base + segment.header.p_vaddr, segment.header.p_memsz, True) - self.emu.mu.mem_map(seg_addr, seg_size, prot) - self.emu.mu.mem_write(load_base + segment.header.p_vaddr, segment.data()) + self.emu.uc.mem_map(seg_addr, seg_size, prot) + self.emu.uc.mem_write(load_base + segment.header.p_vaddr, segment.data()) rel_section = None for section in elf.iter_sections(): @@ -168,14 +168,14 @@ def load_module(self, filename): # Relocation table for ARM if rel_info_type == arm.R_ARM_ABS32: # Read value. - offset = int.from_bytes(self.emu.mu.mem_read(rel_addr, 4), byteorder='little') + offset = int.from_bytes(self.emu.uc.mem_read(rel_addr, 4), byteorder='little') # Create the new value. value = load_base + sym_value + offset # Check thumb. if sym['st_info']['type'] == 'STT_FUNC': value = value | 1 # Write the new value - self.emu.mu.mem_write(rel_addr, value.to_bytes(4, byteorder='little')) + self.emu.uc.mem_write(rel_addr, value.to_bytes(4, byteorder='little')) elif rel_info_type == arm.R_ARM_GLOB_DAT or \ rel_info_type == arm.R_ARM_JUMP_SLOT: # Resolve the symbol. @@ -183,18 +183,18 @@ def load_module(self, filename): value = symbols_resolved[sym.name].address # Write the new value - self.emu.mu.mem_write(rel_addr, value.to_bytes(4, byteorder='little')) + self.emu.uc.mem_write(rel_addr, value.to_bytes(4, byteorder='little')) elif rel_info_type == arm.R_ARM_RELATIVE: if sym_value == 0: # Load address at which it was linked originally. - value_orig_bytes = self.emu.mu.mem_read(rel_addr, 4) + value_orig_bytes = self.emu.uc.mem_read(rel_addr, 4) value_orig = int.from_bytes(value_orig_bytes, byteorder='little') # Create the new value value = load_base + value_orig # Write the new value - self.emu.mu.mem_write(rel_addr, value.to_bytes(4, byteorder='little')) + self.emu.uc.mem_write(rel_addr, value.to_bytes(4, byteorder='little')) else: raise NotImplementedError() else: diff --git a/src/androidemu/java/helpers/native_method.py b/src/androidemu/java/helpers/native_method.py index 6a30524..2d4af31 100644 --- a/src/androidemu/java/helpers/native_method.py +++ b/src/androidemu/java/helpers/native_method.py @@ -28,39 +28,39 @@ def native_write_args(emu, *argv): native_write_arg_register(emu, UC_ARM_REG_R3, argv[3]) if amount >= 5: - sp_start = emu.mu.reg_read(UC_ARM_REG_SP) + sp_start = emu.uc.reg_read(UC_ARM_REG_SP) sp_current = sp_start - STACK_OFFSET # Need to offset because our hook pushes one register on the stack. sp_current = sp_current - (4 * (amount - 4)) # Reserve space for arguments. sp_end = sp_current for arg in argv[4:]: - emu.mu.mem_write(sp_current, native_translate_arg(emu, arg).to_bytes(4, byteorder='little')) + emu.uc.mem_write(sp_current, native_translate_arg(emu, arg).to_bytes(4, byteorder='little')) sp_current = sp_current + 4 - emu.mu.reg_write(UC_ARM_REG_SP, sp_end) + emu.uc.reg_write(UC_ARM_REG_SP, sp_end) -def native_read_args(mu, args_count): +def native_read_args(uc, args_count): native_args = [] if args_count >= 1: - native_args.append(mu.reg_read(UC_ARM_REG_R0)) + native_args.append(uc.reg_read(UC_ARM_REG_R0)) if args_count >= 2: - native_args.append(mu.reg_read(UC_ARM_REG_R1)) + native_args.append(uc.reg_read(UC_ARM_REG_R1)) if args_count >= 3: - native_args.append(mu.reg_read(UC_ARM_REG_R2)) + native_args.append(uc.reg_read(UC_ARM_REG_R2)) if args_count >= 4: - native_args.append(mu.reg_read(UC_ARM_REG_R3)) + native_args.append(uc.reg_read(UC_ARM_REG_R3)) - sp = mu.reg_read(UC_ARM_REG_SP) + sp = uc.reg_read(UC_ARM_REG_SP) sp = sp + STACK_OFFSET # Need to offset by 4 because our hook pushes one register on the stack. if args_count >= 5: for x in range(0, args_count - 4): - native_args.append(int.from_bytes(mu.mem_read(sp + (x * 4), 4), byteorder='little')) + native_args.append(int.from_bytes(uc.mem_read(sp + (x * 4), 4), byteorder='little')) return native_args @@ -84,7 +84,7 @@ def native_translate_arg(emu, val): def native_write_arg_register(emu, reg, val): - emu.mu.reg_write(reg, native_translate_arg(emu, val)) + emu.uc.reg_write(reg, native_translate_arg(emu, val)) def native_method(func): @@ -92,28 +92,28 @@ def native_method_wrapper(*argv): """ :type self :type emu androidemu.emulator.Emulator - :type mu Uc + :type uc Uc """ emu = argv[1] if len(argv) == 2 else argv[0] - mu = emu.mu + uc = emu.uc args = inspect.getfullargspec(func).args args_count = len(args) - (2 if 'self' in args else 1) if args_count < 0: - raise RuntimeError("NativeMethod accept at least (self, mu) or (mu).") + raise RuntimeError("NativeMethod accept at least (self, uc) or (uc).") - native_args = native_read_args(mu, args_count) + native_args = native_read_args(uc, args_count) if len(argv) == 1: - result = func(mu, *native_args) + result = func(uc, *native_args) else: - result = func(argv[0], mu, *native_args) + result = func(argv[0], uc, *native_args) if result is not None: native_write_arg_register(emu, UC_ARM_REG_R0, result) else: - mu.reg_write(UC_ARM_REG_R0, JNI_ERR) + uc.reg_write(UC_ARM_REG_R0, JNI_ERR) return native_method_wrapper diff --git a/src/androidemu/java/java_vm.py b/src/androidemu/java/java_vm.py index bb96648..87d2281 100644 --- a/src/androidemu/java/java_vm.py +++ b/src/androidemu/java/java_vm.py @@ -29,30 +29,30 @@ def __init__(self, emu, class_loader, hooker): self.jni_env = JNIEnv(emu, class_loader, hooker) @native_method - def destroy_java_vm(self, mu): + def destroy_java_vm(self, uc): raise NotImplementedError() @native_method - def attach_current_thread(self, mu): + def attach_current_thread(self, uc): raise NotImplementedError() @native_method - def detach_current_thread(self, mu): + def detach_current_thread(self, uc): # TODO: NooOO idea. pass @native_method - def get_env(self, mu, java_vm, env, version): + def get_env(self, uc, java_vm, env, version): logger.debug("java_vm: 0x%08x" % java_vm) logger.debug("env: 0x%08x" % env) logger.debug("version: 0x%08x" % version) - mu.mem_write(env, self.jni_env.address_ptr.to_bytes(4, byteorder='little')) + uc.mem_write(env, self.jni_env.address_ptr.to_bytes(4, byteorder='little')) logger.debug("JavaVM->GetENV() was called!") return JNI_OK @native_method - def attach_current_thread_as_daemon(self, mu): + def attach_current_thread_as_daemon(self, uc): raise NotImplementedError() diff --git a/src/androidemu/java/jni_env.py b/src/androidemu/java/jni_env.py index 0a85465..c58f9c9 100644 --- a/src/androidemu/java/jni_env.py +++ b/src/androidemu/java/jni_env.py @@ -310,7 +310,7 @@ def delete_global_reference(self, obj): return self._globals.remove(obj) - def read_args_v(self, mu, args_ptr, args_list): + def read_args_v(self, uc, args_ptr, args_list): if args_list is None: return [] @@ -318,19 +318,19 @@ def read_args_v(self, mu, args_ptr, args_list): for arg_name in args_list: if arg_name == 'jint': - ref = int.from_bytes(mu.mem_read(args_ptr, 4), byteorder='little') + ref = int.from_bytes(uc.mem_read(args_ptr, 4), byteorder='little') result.append(ref) args_ptr = args_ptr + 4 elif arg_name == 'jstring': - ref = int.from_bytes(mu.mem_read(args_ptr, 4), byteorder='little') + ref = int.from_bytes(uc.mem_read(args_ptr, 4), byteorder='little') result.append(self.get_reference(ref)) args_ptr = args_ptr + 4 elif arg_name == 'jobject': - ref = int.from_bytes(mu.mem_read(args_ptr, 4), byteorder='little') + ref = int.from_bytes(uc.mem_read(args_ptr, 4), byteorder='little') result.append(self.get_reference(ref)) args_ptr = args_ptr + 4 elif arg_name == 'jbyteArray': - ref = int.from_bytes(mu.mem_read(args_ptr, 4), byteorder='little') + ref = int.from_bytes(uc.mem_read(args_ptr, 4), byteorder='little') result.append(self.get_reference(ref)) args_ptr = args_ptr + 4 else: @@ -338,13 +338,13 @@ def read_args_v(self, mu, args_ptr, args_list): return result - def read_args(self, mu, params_count, args_list): + def read_args(self, uc, params_count, args_list): if args_list is None: return [] result = [] args_count = len(args_list) - args_ptrs = native_read_args(mu, params_count + args_count) + args_ptrs = native_read_args(uc, params_count + args_count) for ref in args_ptrs[params_count:params_count+args_count]: result.append(self.get_reference(ref)) @@ -352,19 +352,19 @@ def read_args(self, mu, params_count, args_list): return result @native_method - def get_version(self, mu, env): + def get_version(self, uc, env): raise NotImplementedError() @native_method - def define_class(self, mu, env): + def define_class(self, uc, env): raise NotImplementedError() @native_method - def find_class(self, mu, env, name_ptr): + def find_class(self, uc, env, name_ptr): """ Returns a class object from a fully-qualified name, or NULL if the class cannot be found. """ - name = memory_helpers.read_utf8(mu, name_ptr) + name = memory_helpers.read_utf8(uc, name_ptr) logger.debug("JNIEnv->FindClass(%s) was called" % name) if name.startswith('['): @@ -382,15 +382,15 @@ def find_class(self, mu, env, name_ptr): return self.add_local_reference(jclass(clazz)) @native_method - def from_reflected_method(self, mu, env): + def from_reflected_method(self, uc, env): raise NotImplementedError() @native_method - def from_reflected_field(self, mu, env): + def from_reflected_field(self, uc, env): raise NotImplementedError() @native_method - def to_reflected_method(self, mu, env, class_idx, method_id, is_static): + def to_reflected_method(self, uc, env, class_idx, method_id, is_static): """ Converts a method ID derived from cls to a java.lang.reflect.Method or java.lang.reflect.Constructor object. isStatic must be set to JNI_TRUE if the method ID refers to a static field, and JNI_FALSE otherwise. @@ -407,9 +407,9 @@ def to_reflected_method(self, mu, env, class_idx, method_id, is_static): raise RuntimeError("Could not find method ('%u') in class %s." % (method_id, clazz.value.jvm_name)) if method.modifier & MODIFIER_STATIC: - mu.mem_write(is_static, int(JNI_TRUE).to_bytes(4, byteorder='little')) + uc.mem_write(is_static, int(JNI_TRUE).to_bytes(4, byteorder='little')) else: - mu.mem_write(is_static, int(JNI_FALSE).to_bytes(4, byteorder='little')) + uc.mem_write(is_static, int(JNI_FALSE).to_bytes(4, byteorder='little')) logger.debug("JNIEnv->ToReflectedMethod(%s, %s, %u) was called" % (clazz.value.jvm_name, method.name, @@ -421,35 +421,35 @@ def to_reflected_method(self, mu, env, class_idx, method_id, is_static): return Method(clazz.value, method) @native_method - def get_superclass(self, mu, env): + def get_superclass(self, uc, env): raise NotImplementedError() @native_method - def is_assignable_from(self, mu, env): + def is_assignable_from(self, uc, env): raise NotImplementedError() @native_method - def to_reflected_field(self, mu, env): + def to_reflected_field(self, uc, env): raise NotImplementedError() @native_method - def throw(self, mu, env): + def throw(self, uc, env): raise NotImplementedError() @native_method - def throw_new(self, mu, env): + def throw_new(self, uc, env): raise NotImplementedError() @native_method - def exception_occurred(self, mu, env): + def exception_occurred(self, uc, env): raise NotImplementedError() @native_method - def exception_describe(self, mu, env): + def exception_describe(self, uc, env): raise NotImplementedError() @native_method - def exception_clear(self, mu, env): + def exception_clear(self, uc, env): """ Clears any exception that is currently being thrown. If no exception is currently being thrown, this routine has no effect. @@ -459,19 +459,19 @@ def exception_clear(self, mu, env): return None @native_method - def fatal_error(self, mu, env): + def fatal_error(self, uc, env): raise NotImplementedError() @native_method - def push_local_frame(self, mu, env): + def push_local_frame(self, uc, env): raise NotImplementedError() @native_method - def pop_local_frame(self, mu, env): + def pop_local_frame(self, uc, env): raise NotImplementedError() @native_method - def new_global_ref(self, mu, env, obj): + def new_global_ref(self, uc, env, obj): """ Creates a new global reference to the object referred to by the obj argument. The obj argument may be a global or local reference. Global references must be explicitly disposed of by calling DeleteGlobalRef(). @@ -490,7 +490,7 @@ def new_global_ref(self, mu, env, obj): return self.add_global_reference(obj) @native_method - def delete_global_ref(self, mu, env, idx): + def delete_global_ref(self, uc, env, idx): """ Deletes the global reference pointed to by globalRef. """ @@ -503,7 +503,7 @@ def delete_global_ref(self, mu, env, idx): self.delete_global_reference(obj) @native_method - def delete_local_ref(self, mu, env, idx): + def delete_local_ref(self, uc, env, idx): """ Deletes the local reference pointed to by localRef. """ @@ -516,7 +516,7 @@ def delete_local_ref(self, mu, env, idx): self.delete_local_reference(obj) @native_method - def is_same_object(self, mu, env, ref1, ref2): + def is_same_object(self, uc, env, ref1, ref2): """ Returns JNI_TRUE if ref1 and ref2 refer to the same Java object, or are both NULL; otherwise, returns JNI_FALSE. """ @@ -534,7 +534,7 @@ def is_same_object(self, mu, env, ref1, ref2): return JNI_FALSE @native_method - def new_local_ref(self, mu, env, ref): + def new_local_ref(self, uc, env, ref): """ Creates a new local reference that refers to the same object as ref. The given ref may be a global or local reference. Returns NULL if ref refers to null. @@ -549,19 +549,19 @@ def new_local_ref(self, mu, env, ref): return self.add_local_reference(obj) @native_method - def ensure_local_capacity(self, mu, env): + def ensure_local_capacity(self, uc, env): raise NotImplementedError() @native_method - def alloc_object(self, mu, env): + def alloc_object(self, uc, env): raise NotImplementedError() @native_method - def new_object(self, mu, env): + def new_object(self, uc, env): raise NotImplementedError() @native_method - def new_object_v(self, mu, env, clazz_idx, method_id, args): + def new_object_v(self, uc, env, clazz_idx, method_id, args): # Get class reference. clazz = self.get_reference(clazz_idx) if not isinstance(clazz, jclass): @@ -578,7 +578,7 @@ def new_object_v(self, mu, env, clazz_idx, method_id, args): logger.debug("JNIEnv->NewObjectV(%s, %s, 0x%x) was called" % (clazz.value.jvm_name, method.name, args)) # Parse arguments. - constructor_args = self.read_args_v(mu, args, method.args_list) + constructor_args = self.read_args_v(uc, args, method.args_list) # Execute function. method.func(obj, self._emu, *constructor_args) @@ -586,11 +586,11 @@ def new_object_v(self, mu, env, clazz_idx, method_id, args): return self.add_local_reference(jobject(obj)) @native_method - def new_object_a(self, mu, env): + def new_object_a(self, uc, env): raise NotImplementedError() @native_method - def get_object_class(self, mu, env, jobj): # when you call this function 0xFA(defined in androidemu.java.java_method_def.java_method_def) + def get_object_class(self, uc, env, jobj): # when you call this function 0xFA(defined in androidemu.java.java_method_def.java_method_def) # always cast to jobj, this is a bug right? # logger.debug("JNIEnv->GetObjectClass(%s) was called" % jobj) ref = self.get_reference(jobj) @@ -601,7 +601,7 @@ def get_object_class(self, mu, env, jobj): # when you call this function 0xFA(de raise NotImplementedError() @native_method - def is_instance_of(self, mu, env, obj_idx, class_idx): + def is_instance_of(self, uc, env, obj_idx, class_idx): """ Tests whether an object is an instance of a class. Returns JNI_TRUE if obj can be cast to clazz; otherwise, returns JNI_FALSE. A NULL object can be cast to any class. @@ -619,13 +619,13 @@ def is_instance_of(self, mu, env, obj_idx, class_idx): return JNI_TRUE if obj.value.jvm_id == clazz.value.jvm_id else JNI_FALSE @native_method - def get_method_id(self, mu, env, clazz_idx, name_ptr, sig_ptr): + def get_method_id(self, uc, env, clazz_idx, name_ptr, sig_ptr): """ Returns the method ID for an instance (nonstatic) method of a class or interface. The method may be defined in one of the clazz’s superclasses and inherited by clazz. The method is determined by its name and signature. """ - name = memory_helpers.read_utf8(mu, name_ptr) - sig = memory_helpers.read_utf8(mu, sig_ptr) + name = memory_helpers.read_utf8(uc, name_ptr) + sig = memory_helpers.read_utf8(uc, sig_ptr) clazz = self.get_reference(clazz_idx) logger.debug("JNIEnv->GetMethodId(%d, %s, %s) was called" % (clazz_idx, name, sig)) @@ -641,11 +641,11 @@ def get_method_id(self, mu, env, clazz_idx, name_ptr, sig_ptr): return method.jvm_id @native_method - def call_object_method(self, mu, env): + def call_object_method(self, uc, env): raise NotImplementedError() @native_method - def call_object_method_v(self, mu, env, obj_idx, method_id, args): + def call_object_method_v(self, uc, env, obj_idx, method_id, args): obj = self.get_reference(obj_idx) if not isinstance(obj, jobject): @@ -662,20 +662,20 @@ def call_object_method_v(self, mu, env, obj_idx, method_id, args): method.signature, args)) # Parse arguments. - constructor_args = self.read_args_v(mu, args, method.args_list) + constructor_args = self.read_args_v(uc, args, method.args_list) return method.func(obj.value, self._emu, *constructor_args) @native_method - def call_object_method_a(self, mu, env): + def call_object_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_boolean_method(self, mu, env): + def call_boolean_method(self, uc, env): raise NotImplementedError() @native_method - def call_boolean_method_v(self, mu, env, obj_idx, method_id, args): + def call_boolean_method_v(self, uc, env, obj_idx, method_id, args): obj = self.get_reference(obj_idx) if not isinstance(obj, jobject): @@ -693,57 +693,57 @@ def call_boolean_method_v(self, mu, env, obj_idx, method_id, args): method.signature, args)) # Parse arguments. - constructor_args = self.read_args_v(mu, args, method.args_list) + constructor_args = self.read_args_v(uc, args, method.args_list) result = method.func(obj.value, self._emu, *constructor_args) return result @native_method - def call_boolean_method_a(self, mu, env): + def call_boolean_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_byte_method(self, mu, env): + def call_byte_method(self, uc, env): raise NotImplementedError() @native_method - def call_byte_method_v(self, mu, env): + def call_byte_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_byte_method_a(self, mu, env): + def call_byte_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_char_method(self, mu, env): + def call_char_method(self, uc, env): raise NotImplementedError() @native_method - def call_char_method_v(self, mu, env): + def call_char_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_char_method_a(self, mu, env): + def call_char_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_short_method(self, mu, env): + def call_short_method(self, uc, env): raise NotImplementedError() @native_method - def call_short_method_v(self, mu, env): + def call_short_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_short_method_a(self, mu, env): + def call_short_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_int_method(self, mu, env): + def call_int_method(self, uc, env): raise NotImplementedError() @native_method - def call_int_method_v(self, mu, env, obj_idx, method_id, args): + def call_int_method_v(self, uc, env, obj_idx, method_id, args): obj = self.get_reference(obj_idx) if not isinstance(obj, jobject): @@ -761,21 +761,21 @@ def call_int_method_v(self, mu, env, obj_idx, method_id, args): method.signature, args)) # Parse arguments. - constructor_args = self.read_args_v(mu, args, method.args_list) + constructor_args = self.read_args_v(uc, args, method.args_list) result = method.func(obj.value, self._emu, *constructor_args) return result @native_method - def call_int_method_a(self, mu, env): + def call_int_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_long_method(self, mu, env): + def call_long_method(self, uc, env): raise NotImplementedError() @native_method - def call_long_method_v(self, mu, env, obj_idx, method_id, args): + def call_long_method_v(self, uc, env, obj_idx, method_id, args): obj = self.get_reference(obj_idx) if not isinstance(obj, jobject): @@ -793,44 +793,44 @@ def call_long_method_v(self, mu, env, obj_idx, method_id, args): method.signature, args)) # Parse arguments. - constructor_args = self.read_args_v(mu, args, method.args_list) + constructor_args = self.read_args_v(uc, args, method.args_list) return method.func(obj.value, self._emu, *constructor_args) @native_method - def call_long_method_a(self, mu, env): + def call_long_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_float_method(self, mu, env): + def call_float_method(self, uc, env): raise NotImplementedError() @native_method - def call_float_method_v(self, mu, env): + def call_float_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_float_method_a(self, mu, env): + def call_float_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_double_method(self, mu, env): + def call_double_method(self, uc, env): raise NotImplementedError() @native_method - def call_double_method_v(self, mu, env): + def call_double_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_double_method_a(self, mu, env): + def call_double_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_void_method(self, mu, env): + def call_void_method(self, uc, env): raise NotImplementedError() @native_method - def call_void_method_v(self, mu, env, obj_idx, method_id, args): + def call_void_method_v(self, uc, env, obj_idx, method_id, args): obj = self.get_reference(obj_idx) if not isinstance(obj, jobject): @@ -852,138 +852,138 @@ def call_void_method_v(self, mu, env, obj_idx, method_id, args): return None @native_method - def call_void_method_a(self, mu, env): + def call_void_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_object_method(self, mu, env): + def call_nonvirtual_object_method(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_object_method_v(self, mu, env): + def call_nonvirtual_object_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_object_method_a(self, mu, env): + def call_nonvirtual_object_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_boolean_method(self, mu, env): + def call_nonvirtual_boolean_method(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_boolean_method_v(self, mu, env): + def call_nonvirtual_boolean_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_boolean_method_a(self, mu, env): + def call_nonvirtual_boolean_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_byte_method(self, mu, env): + def call_nonvirtual_byte_method(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_byte_method_v(self, mu, env): + def call_nonvirtual_byte_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_byte_method_a(self, mu, env): + def call_nonvirtual_byte_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_char_method(self, mu, env): + def call_nonvirtual_char_method(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_char_method_v(self, mu, env): + def call_nonvirtual_char_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_char_method_a(self, mu, env): + def call_nonvirtual_char_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_short_method(self, mu, env): + def call_nonvirtual_short_method(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_short_method_v(self, mu, env): + def call_nonvirtual_short_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_short_method_a(self, mu, env): + def call_nonvirtual_short_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_int_method(self, mu, env): + def call_nonvirtual_int_method(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_int_method_v(self, mu, env): + def call_nonvirtual_int_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_int_method_a(self, mu, env): + def call_nonvirtual_int_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_long_method(self, mu, env): + def call_nonvirtual_long_method(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_long_method_v(self, mu, env): + def call_nonvirtual_long_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_long_method_a(self, mu, env): + def call_nonvirtual_long_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_float_method(self, mu, env): + def call_nonvirtual_float_method(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_float_method_v(self, mu, env): + def call_nonvirtual_float_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_float_method_a(self, mu, env): + def call_nonvirtual_float_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_double_method(self, mu, env): + def call_nonvirtual_double_method(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_double_method_v(self, mu, env): + def call_nonvirtual_double_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_double_method_a(self, mu, env): + def call_nonvirtual_double_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_void_method(self, mu, env): + def call_nonvirtual_void_method(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_void_method_v(self, mu, env): + def call_nonvirtual_void_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_nonvirtual_void_method_a(self, mu, env): + def call_nonvirtual_void_method_a(self, uc, env): raise NotImplementedError() @native_method - def get_field_id(self, mu, env, clazz_idx, name_ptr, sig_ptr): + def get_field_id(self, uc, env, clazz_idx, name_ptr, sig_ptr): """ Returns the field ID for an instance (nonstatic) field of a class. The field is specified by its name and signature. The GetField and SetField families of accessor functions use field IDs to retrieve object fields. """ - name = memory_helpers.read_utf8(mu, name_ptr) - sig = memory_helpers.read_utf8(mu, sig_ptr) + name = memory_helpers.read_utf8(uc, name_ptr) + sig = memory_helpers.read_utf8(uc, sig_ptr) clazz = self.get_reference(clazz_idx) logger.debug("JNIEnv->GetFieldId(%d [%s], %s, %s) was called" % (clazz_idx, clazz.value.jvm_name, name, sig)) @@ -1000,7 +1000,7 @@ def get_field_id(self, mu, env, clazz_idx, name_ptr, sig_ptr): return field.jvm_id @native_method - def get_object_field(self, mu, env, obj_idx, field_id): + def get_object_field(self, uc, env, obj_idx, field_id): obj = self.get_reference(obj_idx) if not isinstance(obj, jobject): @@ -1019,23 +1019,23 @@ def get_object_field(self, mu, env, obj_idx, field_id): return getattr(obj.value, field.name) @native_method - def get_boolean_field(self, mu, env): + def get_boolean_field(self, uc, env): raise NotImplementedError() @native_method - def get_byte_field(self, mu, env): + def get_byte_field(self, uc, env): raise NotImplementedError() @native_method - def get_char_field(self, mu, env): + def get_char_field(self, uc, env): raise NotImplementedError() @native_method - def get_short_field(self, mu, env): + def get_short_field(self, uc, env): raise NotImplementedError() @native_method - def get_int_field(self, mu, env, obj_idx, field_id): + def get_int_field(self, uc, env, obj_idx, field_id): obj = self.get_reference(obj_idx) if not isinstance(obj, jobject): @@ -1054,60 +1054,60 @@ def get_int_field(self, mu, env, obj_idx, field_id): return getattr(obj.value, field.name) @native_method - def get_long_field(self, mu, env): + def get_long_field(self, uc, env): raise NotImplementedError() @native_method - def get_float_field(self, mu, env): + def get_float_field(self, uc, env): raise NotImplementedError() @native_method - def get_double_field(self, mu, env): + def get_double_field(self, uc, env): raise NotImplementedError() @native_method - def set_object_field(self, mu, env): + def set_object_field(self, uc, env): raise NotImplementedError() @native_method - def set_boolean_field(self, mu, env): + def set_boolean_field(self, uc, env): raise NotImplementedError() @native_method - def set_byte_field(self, mu, env): + def set_byte_field(self, uc, env): raise NotImplementedError() @native_method - def set_char_field(self, mu, env): + def set_char_field(self, uc, env): raise NotImplementedError() @native_method - def set_short_field(self, mu, env): + def set_short_field(self, uc, env): raise NotImplementedError() @native_method - def set_int_field(self, mu, env): + def set_int_field(self, uc, env): raise NotImplementedError() @native_method - def set_long_field(self, mu, env): + def set_long_field(self, uc, env): raise NotImplementedError() @native_method - def set_float_field(self, mu, env): + def set_float_field(self, uc, env): raise NotImplementedError() @native_method - def set_double_field(self, mu, env): + def set_double_field(self, uc, env): raise NotImplementedError() @native_method - def get_static_method_id(self, mu, env, clazz_idx, name_ptr, sig_ptr): + def get_static_method_id(self, uc, env, clazz_idx, name_ptr, sig_ptr): """ Returns the method ID for a static method of a class. The method is specified by its name and signature. """ - name = memory_helpers.read_utf8(mu, name_ptr) - sig = memory_helpers.read_utf8(mu, sig_ptr) + name = memory_helpers.read_utf8(uc, name_ptr) + sig = memory_helpers.read_utf8(uc, sig_ptr) clazz = self.get_reference(clazz_idx) logger.debug("JNIEnv->GetStaticMethodId(%d, %s, %s) was called" % (clazz_idx, name, sig)) @@ -1128,7 +1128,7 @@ def get_static_method_id(self, mu, env, clazz_idx, name_ptr, sig_ptr): return method.jvm_id @native_method - def call_static_object_method(self, mu, env, clazz_idx, method_id): + def call_static_object_method(self, uc, env, clazz_idx, method_id): params_count = len(locals()) clazz = self.get_reference(clazz_idx) @@ -1147,11 +1147,11 @@ def call_static_object_method(self, mu, env, clazz_idx, method_id): method.signature)) # Parse arguments. - constructor_args = self.read_args(mu, params_count - 2, method.args_list) + constructor_args = self.read_args(uc, params_count - 2, method.args_list) return method.func(self._emu, *constructor_args) @native_method - def call_static_object_method_v(self, mu, env, clazz_idx, method_id, args): + def call_static_object_method_v(self, uc, env, clazz_idx, method_id, args): clazz = self.get_reference(clazz_idx) if not isinstance(clazz, jclass): @@ -1169,16 +1169,16 @@ def call_static_object_method_v(self, mu, env, clazz_idx, method_id, args): method.signature, args)) # Parse arguments. - constructor_args = self.read_args_v(mu, args, method.args_list) + constructor_args = self.read_args_v(uc, args, method.args_list) return method.func(self._emu, *constructor_args) @native_method - def call_static_object_method_a(self, mu, env): + def call_static_object_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_static_boolean_method(self, mu, env, clazz_idx, method_id): + def call_static_boolean_method(self, uc, env, clazz_idx, method_id): params_count = len(locals()) clazz = self.get_reference(clazz_idx) @@ -1196,11 +1196,11 @@ def call_static_boolean_method(self, mu, env, clazz_idx, method_id): method.signature)) # Parse arguments. - constructor_args = self.read_args(mu, params_count - 2, method.args_list) + constructor_args = self.read_args(uc, params_count - 2, method.args_list) return method.func(self._emu, *constructor_args) @native_method - def call_static_boolean_method_v(self, mu, env, clazz_idx, method_id, args): + def call_static_boolean_method_v(self, uc, env, clazz_idx, method_id, args): clazz = self.get_reference(clazz_idx) if not isinstance(clazz, jclass): @@ -1217,56 +1217,56 @@ def call_static_boolean_method_v(self, mu, env, clazz_idx, method_id, args): method.signature, args)) # Parse arguments. - constructor_args = self.read_args_v(mu, args, method.args_list) + constructor_args = self.read_args_v(uc, args, method.args_list) return method.func(self._emu, *constructor_args) @native_method - def call_static_boolean_method_a(self, mu, env): + def call_static_boolean_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_static_byte_method(self, mu, env): + def call_static_byte_method(self, uc, env): raise NotImplementedError() @native_method - def call_static_byte_method_v(self, mu, env): + def call_static_byte_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_static_byte_method_a(self, mu, env): + def call_static_byte_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_static_char_method(self, mu, env): + def call_static_char_method(self, uc, env): raise NotImplementedError() @native_method - def call_static_char_method_v(self, mu, env): + def call_static_char_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_static_char_method_a(self, mu, env): + def call_static_char_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_static_short_method(self, mu, env): + def call_static_short_method(self, uc, env): raise NotImplementedError() @native_method - def call_static_short_method_v(self, mu, env): + def call_static_short_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_static_short_method_a(self, mu, env): + def call_static_short_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_static_int_method(self, mu, env): + def call_static_int_method(self, uc, env): raise NotImplementedError() @native_method - def call_static_int_method_v(self, mu, env, clazz_idx, method_id, args): + def call_static_int_method_v(self, uc, env, clazz_idx, method_id, args): clazz = self.get_reference(clazz_idx) if not isinstance(clazz, jclass): @@ -1284,71 +1284,71 @@ def call_static_int_method_v(self, mu, env, clazz_idx, method_id, args): method.signature, args)) # Parse arguments. - constructor_args = self.read_args_v(mu, args, method.args_list) + constructor_args = self.read_args_v(uc, args, method.args_list) return method.func(self._emu, *constructor_args) @native_method - def call_static_int_method_a(self, mu, env): + def call_static_int_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_static_long_method(self, mu, env): + def call_static_long_method(self, uc, env): raise NotImplementedError() @native_method - def call_static_long_method_v(self, mu, env): + def call_static_long_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_static_long_method_a(self, mu, env): + def call_static_long_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_static_float_method(self, mu, env): + def call_static_float_method(self, uc, env): raise NotImplementedError() @native_method - def call_static_float_method_v(self, mu, env): + def call_static_float_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_static_float_method_a(self, mu, env): + def call_static_float_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_static_double_method(self, mu, env): + def call_static_double_method(self, uc, env): raise NotImplementedError() @native_method - def call_static_double_method_v(self, mu, env): + def call_static_double_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_static_double_method_a(self, mu, env): + def call_static_double_method_a(self, uc, env): raise NotImplementedError() @native_method - def call_static_void_method(self, mu, env): + def call_static_void_method(self, uc, env): raise NotImplementedError() @native_method - def call_static_void_method_v(self, mu, env): + def call_static_void_method_v(self, uc, env): raise NotImplementedError() @native_method - def call_static_void_method_a(self, mu, env): + def call_static_void_method_a(self, uc, env): raise NotImplementedError() @native_method - def get_static_field_id(self, mu, env, clazz_idx, name_ptr, sig_ptr): + def get_static_field_id(self, uc, env, clazz_idx, name_ptr, sig_ptr): """ Returns the field ID for a static field of a class. The field is specified by its name and signature. The GetStaticField and SetStaticField families of accessor functions use field IDs to retrieve static fields. """ - name = memory_helpers.read_utf8(mu, name_ptr) - sig = memory_helpers.read_utf8(mu, sig_ptr) + name = memory_helpers.read_utf8(uc, name_ptr) + sig = memory_helpers.read_utf8(uc, sig_ptr) clazz = self.get_reference(clazz_idx) logger.debug("JNIEnv->GetStaticFieldId(%d, %s, %s) was called" % (clazz_idx, name, sig)) @@ -1363,7 +1363,7 @@ def get_static_field_id(self, mu, env, clazz_idx, name_ptr, sig_ptr): return field.jvm_id @native_method - def get_static_object_field(self, mu, env, clazz_idx, field_id): + def get_static_object_field(self, uc, env, clazz_idx, field_id): logger.debug("JNIEnv->GetStaticObjectField(%d, %d) was called" % (clazz_idx, field_id)) clazz = self.get_reference(clazz_idx) @@ -1372,23 +1372,23 @@ def get_static_object_field(self, mu, env, clazz_idx, field_id): return field.static_value @native_method - def get_static_boolean_field(self, mu, env): + def get_static_boolean_field(self, uc, env): raise NotImplementedError() @native_method - def get_static_byte_field(self, mu, env): + def get_static_byte_field(self, uc, env): raise NotImplementedError() @native_method - def get_static_char_field(self, mu, env): + def get_static_char_field(self, uc, env): raise NotImplementedError() @native_method - def get_static_short_field(self, mu, env): + def get_static_short_field(self, uc, env): raise NotImplementedError() @native_method - def get_static_int_field(self, mu, env, clazz_idx, field_id): + def get_static_int_field(self, uc, env, clazz_idx, field_id): logger.debug("JNIEnv->GetStaticIntField(%d, %d) was called" % (clazz_idx, field_id)) clazz = self.get_reference(clazz_idx) @@ -1397,82 +1397,82 @@ def get_static_int_field(self, mu, env, clazz_idx, field_id): return field.static_value @native_method - def get_static_long_field(self, mu, env): + def get_static_long_field(self, uc, env): raise NotImplementedError() @native_method - def get_static_float_field(self, mu, env): + def get_static_float_field(self, uc, env): raise NotImplementedError() @native_method - def get_static_double_field(self, mu, env): + def get_static_double_field(self, uc, env): raise NotImplementedError() @native_method - def set_static_object_field(self, mu, env): + def set_static_object_field(self, uc, env): raise NotImplementedError() @native_method - def set_static_boolean_field(self, mu, env): + def set_static_boolean_field(self, uc, env): raise NotImplementedError() @native_method - def set_static_byte_field(self, mu, env): + def set_static_byte_field(self, uc, env): raise NotImplementedError() @native_method - def set_static_char_field(self, mu, env): + def set_static_char_field(self, uc, env): raise NotImplementedError() @native_method - def set_static_short_field(self, mu, env): + def set_static_short_field(self, uc, env): raise NotImplementedError() @native_method - def set_static_int_field(self, mu, env): + def set_static_int_field(self, uc, env): raise NotImplementedError() @native_method - def set_static_long_field(self, mu, env): + def set_static_long_field(self, uc, env): raise NotImplementedError() @native_method - def set_static_float_field(self, mu, env): + def set_static_float_field(self, uc, env): raise NotImplementedError() @native_method - def set_static_double_field(self, mu, env): + def set_static_double_field(self, uc, env): raise NotImplementedError() @native_method - def new_string(self, mu, env): + def new_string(self, uc, env): raise NotImplementedError() @native_method - def get_string_length(self, mu, env): + def get_string_length(self, uc, env): raise NotImplementedError() @native_method - def get_string_chars(self, mu, env): + def get_string_chars(self, uc, env): raise NotImplementedError() @native_method - def release_string_chars(self, mu, env): + def release_string_chars(self, uc, env): raise NotImplementedError() @native_method - def new_string_utf(self, mu, env, bytes_ptr): - string = memory_helpers.read_utf8(mu, bytes_ptr) + def new_string_utf(self, uc, env, bytes_ptr): + string = memory_helpers.read_utf8(uc, bytes_ptr) logger.debug("JNIEnv->NewStringUtf(%s) was called" % string) return self.add_local_reference(jstring(string)) @native_method - def get_string_utf_length(self, mu, env): + def get_string_utf_length(self, uc, env): raise NotImplementedError() @native_method - def get_string_utf_chars(self, mu, env, string, is_copy_ptr): + def get_string_utf_chars(self, uc, env, string, is_copy_ptr): logger.debug("JNIEnv->GetStringUtfChars(%u, %x) was called" % (string, is_copy_ptr)) if is_copy_ptr != 0: @@ -1484,12 +1484,12 @@ def get_string_utf_chars(self, mu, env, string, is_copy_ptr): logger.debug("=> %s" % str_val) - memory_helpers.write_utf8(mu, str_ptr, str_val) + memory_helpers.write_utf8(uc, str_ptr, str_val) return str_ptr @native_method - def release_string_utf_chars(self, mu, env, string, utf_ptr): + def release_string_utf_chars(self, uc, env, string, utf_ptr): logger.debug("JNIEnv->ReleaseStringUTFChars(%x, %x) was called" % (string, utf_ptr)) ref = self.get_local_reference(string) @@ -1499,7 +1499,7 @@ def release_string_utf_chars(self, mu, env, string, utf_ptr): self._emu.memory_manager.free(utf_ptr) @native_method - def get_array_length(self, mu, env, array): + def get_array_length(self, uc, env, array): logger.debug("JNIEnv->GetArrayLength(%u) was called" % array) obj = self.get_reference(array) @@ -1510,11 +1510,11 @@ def get_array_length(self, mu, env, array): return len(obj.value) @native_method - def new_object_array(self, mu, env): + def new_object_array(self, uc, env): raise NotImplementedError() @native_method - def get_object_array_element(self, mu, env, array_idx, item_idx): + def get_object_array_element(self, uc, env, array_idx, item_idx): logger.debug("JNIEnv->GetObjectArrayElement(%u, %u) was called" % (array_idx, item_idx)) obj = self.get_reference(array_idx) @@ -1525,88 +1525,88 @@ def get_object_array_element(self, mu, env, array_idx, item_idx): return obj.value[item_idx] @native_method - def set_object_array_element(self, mu, env): + def set_object_array_element(self, uc, env): raise NotImplementedError() @native_method - def new_boolean_array(self, mu, env): + def new_boolean_array(self, uc, env): raise NotImplementedError() @native_method - def new_byte_array(self, mu, env, bytelen): + def new_byte_array(self, uc, env, bytelen): logger.debug("JNIEnv->NewByteArray(%u) was called" % bytelen) return self.add_local_reference(jbyteArray(bytelen)) #raise NotImplementedError() @native_method - def new_char_array(self, mu, env): + def new_char_array(self, uc, env): raise NotImplementedError() @native_method - def new_short_array(self, mu, env): + def new_short_array(self, uc, env): raise NotImplementedError() @native_method - def new_int_array(self, mu, env): + def new_int_array(self, uc, env): raise NotImplementedError() @native_method - def new_long_array(self, mu, env): + def new_long_array(self, uc, env): raise NotImplementedError() @native_method - def new_float_array(self, mu, env): + def new_float_array(self, uc, env): raise NotImplementedError() @native_method - def new_double_array(self, mu, env): + def new_double_array(self, uc, env): raise NotImplementedError() @native_method - def get_boolean_array_elements(self, mu, env): + def get_boolean_array_elements(self, uc, env): raise NotImplementedError() @native_method - def get_byte_array_elements(self, mu, env, array_idx, is_copy_ptr): + def get_byte_array_elements(self, uc, env, array_idx, is_copy_ptr): ref = self.get_reference(array_idx) if not isinstance(ref, jbyteArray): raise ValueError('Expected a jbyteArray.') alloc_addr = self._emu.memory_manager.allocate(len(ref.value)) - mu.mem_write(alloc_addr, bytes(ref.value)) + uc.mem_write(alloc_addr, bytes(ref.value)) return alloc_addr @native_method - def get_char_array_elements(self, mu, env): + def get_char_array_elements(self, uc, env): raise NotImplementedError() @native_method - def get_short_array_elements(self, mu, env): + def get_short_array_elements(self, uc, env): raise NotImplementedError() @native_method - def get_int_array_elements(self, mu, env): + def get_int_array_elements(self, uc, env): raise NotImplementedError() @native_method - def get_long_array_elements(self, mu, env): + def get_long_array_elements(self, uc, env): raise NotImplementedError() @native_method - def get_float_array_elements(self, mu, env): + def get_float_array_elements(self, uc, env): raise NotImplementedError() @native_method - def get_double_array_elements(self, mu, env): + def get_double_array_elements(self, uc, env): raise NotImplementedError() @native_method - def release_boolean_array_elements(self, mu, env): + def release_boolean_array_elements(self, uc, env): raise NotImplementedError() @native_method - def release_byte_array_elements(self, mu, env, array_idx, buf_ptr, mode): + def release_byte_array_elements(self, uc, env, array_idx, buf_ptr, mode): ref = self.get_local_reference(array_idx) if not isinstance(ref, jbyteArray): @@ -1615,35 +1615,35 @@ def release_byte_array_elements(self, mu, env, array_idx, buf_ptr, mode): self._emu.memory_manager.free(buf_ptr) @native_method - def release_char_array_elements(self, mu, env): + def release_char_array_elements(self, uc, env): raise NotImplementedError() @native_method - def release_short_array_elements(self, mu, env): + def release_short_array_elements(self, uc, env): raise NotImplementedError() @native_method - def release_int_array_elements(self, mu, env): + def release_int_array_elements(self, uc, env): raise NotImplementedError() @native_method - def release_long_array_elements(self, mu, env): + def release_long_array_elements(self, uc, env): raise NotImplementedError() @native_method - def release_float_array_elements(self, mu, env): + def release_float_array_elements(self, uc, env): raise NotImplementedError() @native_method - def release_double_array_elements(self, mu, env): + def release_double_array_elements(self, uc, env): raise NotImplementedError() @native_method - def get_boolean_array_region(self, mu, env): + def get_boolean_array_region(self, uc, env): raise NotImplementedError() @native_method - def get_byte_array_region(self, mu, env, array_idx, start, len_in, buf_ptr): + def get_byte_array_region(self, uc, env, array_idx, start, len_in, buf_ptr): logger.debug("JNIEnv->GetByteArrayRegion(%u, %u, %u, 0x%x) was called" % (array_idx, start, len_in, buf_ptr)) obj = self.get_reference(array_idx) @@ -1651,70 +1651,70 @@ def get_byte_array_region(self, mu, env, array_idx, start, len_in, buf_ptr): if not isinstance(obj, jbyteArray): raise ValueError('Expected a jbyteArray.') - mu.mem_write(buf_ptr, bytes(obj.value[start:start + len_in])) + uc.mem_write(buf_ptr, bytes(obj.value[start:start + len_in])) return None @native_method - def get_char_array_region(self, mu, env): + def get_char_array_region(self, uc, env): raise NotImplementedError() @native_method - def get_short_array_region(self, mu, env): + def get_short_array_region(self, uc, env): raise NotImplementedError() @native_method - def get_int_array_region(self, mu, env): + def get_int_array_region(self, uc, env): raise NotImplementedError() @native_method - def get_long_array_region(self, mu, env): + def get_long_array_region(self, uc, env): raise NotImplementedError() @native_method - def get_float_array_region(self, mu, env): + def get_float_array_region(self, uc, env): raise NotImplementedError() @native_method - def get_double_array_region(self, mu, env): + def get_double_array_region(self, uc, env): raise NotImplementedError() @native_method - def set_boolean_array_region(self, mu, env): + def set_boolean_array_region(self, uc, env): raise NotImplementedError() @native_method - def set_byte_array_region(self, mu, env, arrayJREF, startIndex, length, bufAddress): - string = memory_helpers.read_byte_array(mu, bufAddress, length) + def set_byte_array_region(self, uc, env, arrayJREF, startIndex, length, bufAddress): + string = memory_helpers.read_byte_array(uc, bufAddress, length) logger.debug("JNIEnv->SetByteArrayRegion was called") self.set_local_reference(arrayJREF, jbyteArray(string)) @native_method - def set_char_array_region(self, mu, env): + def set_char_array_region(self, uc, env): raise NotImplementedError() @native_method - def set_short_array_region(self, mu, env): + def set_short_array_region(self, uc, env): raise NotImplementedError() @native_method - def set_int_array_region(self, mu, env): + def set_int_array_region(self, uc, env): raise NotImplementedError() @native_method - def set_long_array_region(self, mu, env): + def set_long_array_region(self, uc, env): raise NotImplementedError() @native_method - def set_float_array_region(self, mu, env): + def set_float_array_region(self, uc, env): raise NotImplementedError() @native_method - def set_double_array_region(self, mu, env): + def set_double_array_region(self, uc, env): raise NotImplementedError() @native_method - def register_natives(self, mu, env, clazz_id, methods, methods_count): + def register_natives(self, uc, env, clazz_id, methods, methods_count): logger.debug("JNIEnv->RegisterNatives(%d, 0x%08x, %d) was called" % (clazz_id, methods, methods_count)) clazz = self.get_local_reference(clazz_id) @@ -1725,71 +1725,71 @@ def register_natives(self, mu, env, clazz_id, methods, methods_count): clazz = clazz.value for i in range(0, methods_count): - ptr_name = memory_helpers.read_ptr(mu, (i * 12) + methods) - ptr_sign = memory_helpers.read_ptr(mu, (i * 12) + methods + 4) - ptr_func = memory_helpers.read_ptr(mu, (i * 12) + methods + 8) + ptr_name = memory_helpers.read_ptr(uc, (i * 12) + methods) + ptr_sign = memory_helpers.read_ptr(uc, (i * 12) + methods + 4) + ptr_func = memory_helpers.read_ptr(uc, (i * 12) + methods + 8) - name = memory_helpers.read_utf8(mu, ptr_name) - signature = memory_helpers.read_utf8(mu, ptr_sign) + name = memory_helpers.read_utf8(uc, ptr_name) + signature = memory_helpers.read_utf8(uc, ptr_sign) clazz.register_native(name, signature, ptr_func) return JNI_OK @native_method - def unregister_natives(self, mu, env): + def unregister_natives(self, uc, env): raise NotImplementedError() @native_method - def monitor_enter(self, mu, env): + def monitor_enter(self, uc, env): raise NotImplementedError() @native_method - def monitor_exit(self, mu, env): + def monitor_exit(self, uc, env): raise NotImplementedError() @native_method - def get_java_vm(self, mu, env, vm): + def get_java_vm(self, uc, env, vm): logger.debug("JNIEnv->GetJavaVM(0x%08x) was called" % vm) - mu.mem_write(vm, self._emu.java_vm.address_ptr.to_bytes(4, byteorder='little')) + uc.mem_write(vm, self._emu.java_vm.address_ptr.to_bytes(4, byteorder='little')) return JNI_OK @native_method - def get_string_region(self, mu, env): + def get_string_region(self, uc, env): raise NotImplementedError() @native_method - def get_string_utf_region(self, mu, env): + def get_string_utf_region(self, uc, env): raise NotImplementedError() @native_method - def get_primitive_array_critical(self, mu, env): + def get_primitive_array_critical(self, uc, env): raise NotImplementedError() @native_method - def release_primitive_array_critical(self, mu, env): + def release_primitive_array_critical(self, uc, env): raise NotImplementedError() @native_method - def get_string_critical(self, mu, env): + def get_string_critical(self, uc, env): raise NotImplementedError() @native_method - def release_string_critical(self, mu, env): + def release_string_critical(self, uc, env): raise NotImplementedError() @native_method - def new_weak_global_ref(self, mu, env): + def new_weak_global_ref(self, uc, env): raise NotImplementedError() @native_method - def delete_weak_global_ref(self, mu, env): + def delete_weak_global_ref(self, uc, env): raise NotImplementedError() @native_method - def exception_check(self, mu, env): + def exception_check(self, uc, env): """ Returns JNI_TRUE when there is a pending exception; otherwise, returns JNI_FALSE. """ @@ -1798,17 +1798,17 @@ def exception_check(self, mu, env): return JNI_FALSE @native_method - def new_direct_byte_buffer(self, mu, env): + def new_direct_byte_buffer(self, uc, env): raise NotImplementedError() @native_method - def get_direct_buffer_address(self, mu, env): + def get_direct_buffer_address(self, uc, env): raise NotImplementedError() @native_method - def get_direct_buffer_capacity(self, mu, env): + def get_direct_buffer_capacity(self, uc, env): raise NotImplementedError() @native_method - def get_object_ref_type(self, mu, env): + def get_object_ref_type(self, uc, env): raise NotImplementedError() diff --git a/src/androidemu/utils/memory_helpers.py b/src/androidemu/utils/memory_helpers.py index d1c9cd0..d86b711 100644 --- a/src/androidemu/utils/memory_helpers.py +++ b/src/androidemu/utils/memory_helpers.py @@ -2,20 +2,20 @@ import struct -def hex_dump(mu, address, size): - data = mu.mem_read(address, size) +def hex_dump(uc, address, size): + data = uc.mem_read(address, size) return hexdump.hexdump(data) -def read_ptr(mu, address): - return int.from_bytes(mu.mem_read(address, 4), byteorder='little') +def read_ptr(uc, address): + return int.from_bytes(uc.mem_read(address, 4), byteorder='little') -def read_byte_array(mu, address, size): - return mu.mem_read(address, size) +def read_byte_array(uc, address, size): + return uc.mem_read(address, size) -def read_utf8(mu, address): +def read_utf8(uc, address): buffer_address = address buffer_read_size = 32 buffer = b"" @@ -23,7 +23,7 @@ def read_utf8(mu, address): # Keep reading until we read something that contains a null terminator. while null_pos is None: - buf_read = mu.mem_read(buffer_address, buffer_read_size) + buf_read = uc.mem_read(buffer_address, buffer_read_size) if b'\x00' in buf_read: null_pos = len(buffer) + buf_read.index(b'\x00') buffer += buf_read @@ -32,7 +32,7 @@ def read_utf8(mu, address): return buffer[:null_pos].decode("utf-8") -def read_cString(mu, address): +def read_cString(uc, address): # read string null-terminated, return string and length buffer_address = address buffer_read_size = 1 @@ -40,7 +40,7 @@ def read_cString(mu, address): null_pos = None while null_pos is None: - buf_read = mu.mem_read(buffer_address, buffer_read_size) + buf_read = uc.mem_read(buffer_address, buffer_read_size) if b'\x00' in buf_read: null_pos = len(buffer) + buf_read.index(b'\x00') buffer += buf_read @@ -49,16 +49,16 @@ def read_cString(mu, address): return buffer[:null_pos].decode("utf-8"),null_pos -def read_uints(mu, address, num=1): - data = mu.mem_read(address, num * 4) +def read_uints(uc, address, num=1): + data = uc.mem_read(address, num * 4) return struct.unpack("I" * num, data) -def write_utf8(mu, address, value): - mu.mem_write(address, value.encode(encoding="utf-8") + b"\x00") +def write_utf8(uc, address, value): + uc.mem_write(address, value.encode(encoding="utf-8") + b"\x00") -def write_uints(mu, address, num): +def write_uints(uc, address, num): l = [] if not isinstance(num, list): l = [num] @@ -66,5 +66,5 @@ def write_uints(mu, address, num): l = num for v in l: - mu.mem_write(address, int(v).to_bytes(4, byteorder='little')) + uc.mem_write(address, int(v).to_bytes(4, byteorder='little')) address += 4 diff --git a/src/androidemu/vfs/file_system.py b/src/androidemu/vfs/file_system.py index ad8b1fc..cf1da4f 100644 --- a/src/androidemu/vfs/file_system.py +++ b/src/androidemu/vfs/file_system.py @@ -94,7 +94,7 @@ def _open_file(self, filename): logger.warning("File does not exist '%s'" % orig_filename) return -1 - def _handle_read(self, mu, fd, buf_addr, count): + def _handle_read(self, uc, fd, buf_addr, count): """ ssize_t read(int fd, void *buf, size_t count); @@ -112,7 +112,7 @@ def _handle_read(self, mu, fd, buf_addr, count): if fd not in self._file_descriptors: logger.warning("No such file descriptor index %s in VirtualFileSystem" % fd) - mu.emu_stop() + uc.emu_stop() file = self._file_descriptors[fd] @@ -127,20 +127,20 @@ def _handle_read(self, mu, fd, buf_addr, count): buf = os.read(file.descriptor, count) result = len(buf) - mu.mem_write(buf_addr, buf) + uc.mem_write(buf_addr, buf) return result - def _handle_open(self, mu, filename_ptr, flags, mode): + def _handle_open(self, uc, filename_ptr, flags, mode): """ int open(const char *pathname, int flags, mode_t mode); return the new file descriptor, or -1 if an error occurred (in which case, errno is set appropriately). """ - filename = memory_helpers.read_utf8(mu, filename_ptr) + filename = memory_helpers.read_utf8(uc, filename_ptr) return self._open_file(filename) - def _handle_close(self, mu, fd): + def _handle_close(self, uc, fd): """ int close(int fd); @@ -157,7 +157,7 @@ def _handle_close(self, mu, fd): if fd <= 2: # if file.name == 'stdin': - # mu.hook_add(UC_HOOK_BLOCK, debug_utils.hook_block) + # uc.hook_add(UC_HOOK_BLOCK, debug_utils.hook_block) logger.info("File closed '%s'" % file.name) return 0 @@ -169,8 +169,8 @@ def _handle_close(self, mu, fd): return 0 - def _handle_access(self, mu, filename_ptr, flags): - filename = memory_helpers.read_utf8(mu, filename_ptr) + def _handle_access(self, uc, filename_ptr, flags): + filename = memory_helpers.read_utf8(uc, filename_ptr) filename_virt = self.translate_path(filename) logger.warning("Path '%s' exists %s" % (filename, os.path.isfile(filename_virt))) @@ -180,12 +180,12 @@ def _handle_access(self, mu, filename_ptr, flags): return -1 - def _handle_writev(self, mu, fd, vec, vlen): + def _handle_writev(self, uc, fd, vec, vlen): if fd == 2: for i in range(0, vlen): - addr = memory_helpers.read_ptr(mu, (i * 8) + vec) - size = memory_helpers.read_ptr(mu, (i * 8) + vec + 4) - data = bytes(mu.mem_read(addr, size)).decode(encoding='UTF-8') + addr = memory_helpers.read_ptr(uc, (i * 8) + vec) + size = memory_helpers.read_ptr(uc, (i * 8) + vec + 4) + data = bytes(uc.mem_read(addr, size)).decode(encoding='UTF-8') logger.error('Writev %s' % data) @@ -193,8 +193,8 @@ def _handle_writev(self, mu, fd, vec, vlen): raise NotImplementedError() - def _handle_stat64(self, mu, filename_ptr, buf_ptr): - filename = memory_helpers.read_utf8(mu, filename_ptr) + def _handle_stat64(self, uc, filename_ptr, buf_ptr): + filename = memory_helpers.read_utf8(uc, filename_ptr) logger.info("File stat64 '%s'" % filename) @@ -208,11 +208,11 @@ def _handle_stat64(self, mu, filename_ptr, buf_ptr): # stat = file_helpers.stat64(path=pathname) # stat = os.stat(path=file_path, dir_fd=None, follow_symlinks=False) - # file_helpers.stat_to_memory(mu, buf_ptr, stat, WRITE_FSTAT_TIMES) + # file_helpers.stat_to_memory(uc, buf_ptr, stat, WRITE_FSTAT_TIMES) return 0 - def _handle_fstat64(self, mu, fd, buf_ptr): + def _handle_fstat64(self, uc, fd, buf_ptr): """ These functions return information about a file. No permissions are required on the file itself, but-in the case of stat() and lstat() - execute (search) permission is required on all of the directories in path that @@ -228,11 +228,11 @@ def _handle_fstat64(self, mu, fd, buf_ptr): stat = file_helpers.stat64(file.name_virt) # stat = os.fstat(file.descriptor) - file_helpers.stat_to_memory(mu, buf_ptr, stat, WRITE_FSTAT_TIMES) + file_helpers.stat_to_memory(uc, buf_ptr, stat, WRITE_FSTAT_TIMES) return 0 - def _handle_openat(self, mu, dfd, filename_ptr, flags, mode): + def _handle_openat(self, uc, dfd, filename_ptr, flags, mode): """ int openat(int dirfd, const char *pathname, int flags, mode_t mode); @@ -244,14 +244,14 @@ def _handle_openat(self, mu, dfd, filename_ptr, flags, mode): ENOTDIR pathname is relative and dirfd is a file descriptor referring to a file other than a directory. """ - filename = memory_helpers.read_utf8(mu, filename_ptr) + filename = memory_helpers.read_utf8(uc, filename_ptr) if not filename.startswith("/") and dfd != 0: raise NotImplementedError("Directory file descriptor has not been implemented yet.") return self._open_file(filename) - def _handle_fstatat64(self, mu, dirfd, pathname_ptr, buf, flags): + def _handle_fstatat64(self, uc, dirfd, pathname_ptr, buf, flags): """ int fstatat(int dirfd, const char *pathname, struct stat *buf, int flags); @@ -268,7 +268,7 @@ def _handle_fstatat64(self, mu, dirfd, pathname_ptr, buf, flags): On success, fstatat() returns 0. On error, -1 is returned and errno is set to indicate the error. """ - pathname = memory_helpers.read_utf8(mu, pathname_ptr) + pathname = memory_helpers.read_utf8(uc, pathname_ptr) if not pathname.startswith('/'): raise NotImplementedError("Directory file descriptor has not been implemented yet.") @@ -291,6 +291,6 @@ def _handle_fstatat64(self, mu, dirfd, pathname_ptr, buf, flags): stat = file_helpers.stat64(path=pathname) # stat = os.stat(path=file_path, dir_fd=None, follow_symlinks=False) - file_helpers.stat_to_memory(mu, buf, stat, WRITE_FSTAT_TIMES) + file_helpers.stat_to_memory(uc, buf, stat, WRITE_FSTAT_TIMES) return 0 diff --git a/tools/gen_jni_env.py b/tools/gen_jni_env.py index 825a063..e5c10a2 100644 --- a/tools/gen_jni_env.py +++ b/tools/gen_jni_env.py @@ -307,5 +307,5 @@ def convert(name): for (index, name) in functions.items(): print(""" @native_method - def %s(self, mu, env): + def %s(self, uc, env): raise NotImplementedError()""" % name)