def __init__(self, serial=None): super(Frida, self).__init__() self._logger = logger.get_logger(self.__class__.__name__) self._frida_server_factory = FridaServerFactory(serial=serial) self._serial = serial self._frida_server = None self._device = None self._session = None found = False while not found: try: if serial is not None: self._logger.info('Frida using device with serial "%s"', serial) device = frida.get_device_manager().get_device(serial) else: self._logger.info( 'No device serial given; using default USB device') device = frida.get_device_manager().get_usb_device() found = True except frida.InvalidArgumentError as exception: self._logger.info('Frida exception "%s"; retrying in 2 secs.', str(exception)) time.sleep(2) self._logger.info('Found device "%s" (%s) over %s', device.name, device.id, device.type.upper()) self._device = device
def __init__(self, app, *__args): super().__init__(*__args) self.app = app self.startup_script = '' self.setup_ui() self.updated_frida_version = '' self.updated_frida_assets_url = {} self.frida_update_thread = None self.devices_thread = None self.procs_update_thread = None self.spawns_update_thread = None self.update_commits_thread = None self.update_dwarf_thread = None self.setup_threads() frida.get_device_manager().on('added', self.update_device_ui) frida.get_device_manager().on('removed', self.update_device_ui) if not self.app.get_adb().available(): # additional check for null local device if frida.get_local_device() is None: utils.show_message_box( 'adb/device/emu not found or not rooted! see details or output', self.app.get_adb().get_states_string()) self.update_ui_sync()
def find_app(app_name_or_id, device_id, device_ip): if device_id is None: if device_ip is None: dev = frida.get_usb_device() else: frida.get_device_manager().add_remote_device(device_ip) dev = frida.get_device("tcp@" + device_ip) else: try: dev = next(dev for dev in frida.enumerate_devices() if dev.id.startswith(device_id)) except StopIteration: fatal('device id %s not found' % device_id) if dev.type not in ('tether', 'remote', 'usb'): fatal('unable to find device') try: app = next( app for app in dev.enumerate_applications() if app_name_or_id == app.identifier or app_name_or_id == app.name) except: print('app "%s" not found' % app_name_or_id) print('installed app:') for app in dev.enumerate_applications(): print('%s (%s)' % (app.name, app.identifier)) fatal('') return dev, app
def main(): device = frida.get_device_manager().enumerate_devices()[-1] package_name = "com.skymoons.hqg.uc" # find and kill process. pid = get_process_pid(device, package_name) if pid != -1: print("killing {0}".format(pid)) device.kill(pid) time.sleep(0.3) os.system("adb shell am start -n {0}/{1}".format(package_name, "com.onektower.sdk.tgame.SplashActivity")) time.sleep(0.2) pid = get_process_pid(device, package_name) if pid == -1: print("{0} is not found...".format(package_name)) return session = None try: session = frida.get_device_manager().enumerate_devices()[-1].attach(pid) script_content = open("payload.js").read() script = session.create_script(script_content) script.on("message", on_message) script.load() sys.stdin.read() except KeyboardInterrupt as e: if session is not None: session.detach() sys.exit(0)
def main(): device = frida.get_device_manager().enumerate_devices()[-1] package_name = "com.skymoons.hqg.uc" # find and kill process. pid = get_process_pid(device, package_name) if pid != -1: print("killing {0}".format(pid)) device.kill(pid) time.sleep(0.3) os.system("adb shell am start -n {0}/{1}".format( package_name, "com.onektower.sdk.tgame.SplashActivity")) time.sleep(0.2) pid = get_process_pid(device, package_name) if pid == -1: print("{0} is not found...".format(package_name)) return session = None try: session = frida.get_device_manager().enumerate_devices()[-1].attach( pid) script_content = open("payload.js").read() script = session.create_script(script_content) script.on("message", on_message) script.load() sys.stdin.read() except KeyboardInterrupt as e: if session is not None: session.detach() sys.exit(0)
def __init__(self, parent=None, device_type='usb'): super().__init__(parent=parent) # dont show for local if device_type != 'usb': return self.parent = parent self.wait_for_devtype = device_type self.is_waiting = True self._adb = Adb() if not self._adb.min_required: raise Exception('Adb missing or no Device') self._git = Git() self.setAutoFillBackground(True) self.setStyleSheet( 'background-color: crimson; color: white; font-weight: bold; margin: 0; padding: 10px;' ) self.setup() self._timer = QTimer() self._timer.setInterval(500) self._timer.timeout.connect(self._on_timer) self._timer.start() self._timer_step = 0 frida.get_device_manager().on('added', self._on_device) frida.get_device_manager().on('removed', self._on_device) self.devices_thread = DevicesUpdateThread(self) self.devices_thread.onAddDevice.connect(self.on_add_deviceitem) self.devices_thread.onDevicesUpdated.connect(self._on_devices_finished) self._update_thread = FridaUpdateThread(self) self._update_thread._adb = self._adb self._update_thread.onStatusUpdate.connect(self._update_statuslbl) self._update_thread.onFinished.connect(self._frida_updated) self._update_thread.onError.connect(self._on_download_error) self.updated_frida_version = '' self.updated_frida_assets_url = {} self._device_id = None self._devices = [] remote_frida = self._git.get_frida_version() if remote_frida is None: self.updated_frida_version = '' self.updated_frida_assets_url.clear() else: remote_frida = remote_frida[0] self.updated_frida_version = remote_frida['tag_name'] for asset in remote_frida['assets']: if 'android-' not in asset: continue try: name = asset['name'] tag_start = name.index('android-') if name.index('server') >= 0: tag = name[tag_start + 8:-3] self.updated_frida_assets_url[tag] = asset[ 'browser_download_url'] except ValueError: pass
def run_instrumentation(self): """ Select and run instrumentation function using the Frida instrumentation toolkit """ while True: print(t.green("[{0}] ".format(datetime.now()) + t.cyan("Enter 'quit' to exit Frida module!"))) print(t.green("[{0}] ".format(datetime.now()) + t.yellow("Available Frida functions: ") + "activities, webview")) function = raw_input(t.green("[{0}] ".format(datetime.now()) + t.yellow("Enter Frida function: "))) if function == "quit": break try: if function == "activities": # adb forward just # in case # Popen("adb forward tcp:27042 tcp:27042", shell=True).wait() process = frida.get_device_manager().enumerate_devices()[-1].attach(self.apk.get_package()) script = process.create_script(self.do_activities()) script.on('message', self.on_message) script.load() sys.stdin.read() elif function == "webview": # adb forward just # in case # Popen("adb forward tcp:27042 tcp:27042", shell=True).wait() process = frida.get_device_manager().enumerate_devices()[-1].attach(self.apk.get_package()) script = process.create_script(self.do_webview()) script.on('message', self.on_message) script.load() sys.stdin.read() except frida.ProcessNotFoundError as e: print(t.red("[{0}] ".format(datetime.now()) + "Could not connect to target process!")) Logger.run_logger(e.message) except frida.ServerNotRunningError as e: print(t.red("[{0}] ".format(datetime.now()) + "The frida-server is not running!")) Logger.run_logger(e.message) except frida.TransportError as e: print(t.red("[{0}] ".format(datetime.now()) + "Connection was closed!")) Logger.run_logger(e.message) except KeyboardInterrupt: pass
def main(): args = parse_args() if args.command == "run": script_file = args.script package_name = args.package if os.path.isabs(script_file) is False: script_file = os.path.abspath(script_file) device = frida.get_device_manager().enumerate_devices()[-1] pid = get_process_pid(device, package_name) if pid != -1: print("[+] killing {0}".format(pid)) device.kill(pid) time.sleep(0.3) # Pause for 3s. os.system( r"adb shell su -c \"echo 4 > /data/data/{0}/files/.pause\"".format( package_name)) os.system( r"adb shell monkey -p {0} -c android.intent.category.LAUNCHER 1". format(package_name)) pid = -1 for i in range(10): pid = get_process_pid(device, package_name) if pid != -1: break time.sleep(0.1) if pid == -1: print("[-] Run package {0} failed.".format(package_name)) return print("[+] Injecting {0} to {1}({2})".format(script_file, package_name, pid)) session = None try: session = frida.get_device_manager().enumerate_devices( )[-1].attach(pid) script_content = open(script_file).read() # Update some consts. script_content = script_content.replace("__PACKAGE_NAME__", package_name) script = session.create_script(script_content) script.on("message", on_message) script.load() sys.stdin.read() except KeyboardInterrupt as e: if session is not None: session.detach() sys.exit(0) else: pass
def attach(target): packageName = target if is_number(target): #pid packageName = getPidMap()[target] online_session = None online_script = None rdev = None remoteDriver = run_env.getRemoteDriver() #ip:port try: if remoteDriver: rdev = frida.get_device_manager().add_remote_device(remoteDriver) elif platform.system().find("Windows") != -1: warn("推荐使用linux或mac操作系统获得更好的兼容性.") rdev = frida.get_remote_device() else: rdev = frida.get_usb_device(1000) #print(f"attach {target}") if is_number(target): pid = int(target) online_session = frida.core.Session(rdev._impl.attach(pid)) else: online_session = rdev.attach(target) if online_session == None: warn("attaching fail to " + target) online_script = online_session.create_script(run_env.rpc_jscode) online_script.on('message', on_message) online_script.load() checkRadarDex(packageName, online_script) createHookingEnverment(packageName, online_script.exports.mainactivity()) except Exception: warn(traceback.format_exc()) return online_session, online_script, packageName
def __init__(self, name, target_dict): self.name = name self.frida_session = None self.frida_script = None self.process_name = None self.process_pid = None self.remote_frida = False self.frida_port = 27042 self.modules = None # Modules which are loaded in the process self.modules_to_watch = None # Modules which where given in the config file # for which the coverage should be tracked self.watched_modules = None # intersection of self.modules and self.modules_to_watch if "function" in target_dict: self.function = target_dict["function"] else: log.warn("No 'function' in target-section '%s'!" % name) return False if "process_name" in target_dict: self.process_name = target_dict["process_name"] if "process_pid" in target_dict: self.process_pid = target_dict["process_pid"] if "remote_frida" in target_dict: self.remote_frida = target_dict["remote_frida"] if "frida_port" in target_dict: self.frida_port = target_dict["frida_port"] if "modules" in target_dict: self.modules_to_watch = target_dict["modules"] if self.remote_frida: self.frida_instance = frida.get_device_manager().add_remote_device('%s:%d' % ('localhost', self.frida_port)) else: self.frida_instance = frida
def _get_device() -> frida.core.Device: """ Attempt to get a handle on a device. :return: """ if state_connection.get_comms_type() == state_connection.TYPE_USB: if state_connection.device_serial: device = frida.get_device(state_connection.device_serial) click.secho('Using USB device `{n}`'.format(n=device.name), bold=True) return device else: device = frida.get_usb_device(5) click.secho('Using USB device `{n}`'.format(n=device.name), bold=True) return device if state_connection.get_comms_type() == state_connection.TYPE_REMOTE: device = frida.get_device_manager().add_remote_device( '{host}:{port}'.format(host=state_connection.host, port=state_connection.port)) click.secho('Using networked device @`{n}`'.format(n=device.name), bold=True) return device raise Exception('Failed to find a device to attach to!')
def module_pre(self): # Run FridaModule setup function FridaModule.module_pre(self) # Get an handle to the device import frida if self.device.is_usb(): self.printer.debug("Connected over USB") device = frida.get_usb_device() else: self.printer.debug("Connected over Wi-Fi") device = frida.get_device_manager().enumerate_devices()[1] # Launching the app self.printer.info("Launching the app...") self.device.app.open(self.APP_METADATA['bundle_id']) pid = int(self.device.app.search_pid(self.APP_METADATA['name'])) # Attaching to the process self.printer.info("Attaching to process: %s" % pid) self.session = device.attach(pid) # Preparing results self.results = [] return 1
def frida_runner(app_name, script_name, verbose, host): """ Attach Frida script to an app running on a device """ try: content = open(script_name, 'r').read() device_id = DEVICE_ID_PLACEHOLDER script_text = SCRIPT_WRAPPER % locals() script_text = script_text % 1 if verbose: _print_with_line_no(script_text) print('Starting session...') if host: remote_device = frida.get_device_manager().add_remote_device(host) session = remote_device.attach(app_name) else: session = frida.get_usb_device().attach(app_name) script = session.create_script(script_text) script.on('message', on_message) script.load() print('Connected') sys.stdin.read() except Exception as e: print(e)
def inject(self, traffic_sniffer): Popen(["adb forward tcp:27042 tcp:27042"], shell=True).wait() device = frida.get_device_manager().enumerate_devices()[-1] process = device.attach(self.proc) script = process.create_script(traffic_sniffer.get_sniffer_js()) script.on('message', traffic_sniffer.on_message) script.load()
def start_hook(self, script_path, udid=""): """ 直接hook进程 :param udid: :param script_path: :return: """ try: # signal.signal(signal.SIGINT, quit) # signal.signal(signal.SIGTERM, quit) # 加载Frida with open(script_path, encoding='utf-8') as f: jscode = f.read() if udid == "": device = frida.get_usb_device() else: device = frida.get_device_manager().get_device(udid) self.process = device.attach(self.package_name) self.process.enable_debugger() self.script = self.process.create_script(jscode, runtime="v8") self.script.on('message', self.on_message) print('[*] Running App') self.script.load() # sys.stdin.read() except Exception as e: print(e.args) pass
def test_get_existing_device(self): device = frida.get_device_matching(lambda d: d.id == 'local') self.assertEqual(device.name, "Local System") device = frida.get_device_manager().get_device_matching( lambda d: d.id == 'local') self.assertEqual(device.name, "Local System")
def show_packages(): global device global remote try: remote = request.args.get('remote') if device == None: if len(remote) != 0: # check remote ip address try: socket.inet_aton(remote) print("adding remote device to device manager : ", remote) device=frida.get_device_manager().add_remote_device(remote) print("remote device : ", device) except socket.error: return render_template('intro.html') else: device = frida.get_remote_device() # get list of apps packages=device.enumerate_processes() print(packages) except frida.ServerNotRunningError : return render_template('error.html',error="cannot connect to remote :(") return render_template('packages_list.html', packages=packages)
def attach_lastdevice(processname): print("[*] Enumerate devices and attach the app on the last device") manager = frida.get_device_manager() device = manager.enumerate_devices()[-1] session = device.attach(processname) waitinterrupt(session)
def _try_start(self): if self._device is not None: return if self._device_id is not None: try: self._device = frida.get_device(self._device_id) except: self._update_status("Device '%s' not found" % self._device_id) self._exit(1) return elif self._device_type is not None: self._device = find_device(self._device_type) if self._device is None: return elif self._host is not None: self._device = frida.get_device_manager().add_remote_device( self._host) else: self._device = frida.get_local_device() self._device.on('output', self._schedule_on_output) self._device.on('lost', self._schedule_on_device_lost) if self._target is not None: spawning = True try: target_type, target_value = self._target if target_type == 'file': argv = target_value if not self._quiet: self._update_status("Spawning `%s`..." % " ".join(argv)) self._spawned_pid = self._device.spawn(argv) self._spawned_argv = argv attach_target = self._spawned_pid else: attach_target = target_value if not self._quiet: self._update_status("Attaching...") spawning = False self._session = self._device.attach(attach_target) if self._enable_jit: self._session.enable_jit() if self._enable_debugger: self._session.enable_debugger() if self._enable_jit: self._print( "Chrome Inspector server listening on port 9229\n") else: self._print( "Duktape debugger listening on port 5858\n") self._session.on('detached', self._schedule_on_session_detached) except Exception as e: if spawning: self._update_status("Failed to spawn: %s" % e) else: self._update_status("Failed to attach: %s" % e) self._exit(1) return self._start() self._started = True
def inject_process(package_name, js_path, is_reboot=False, ip=default_ip, port=default_port, frida_server=default_frida_server_name, is_clear_data=False): start_server(frida_server, ip, port) # 清除数据 if is_clear_data: clear_application_data(package_name) # 获取设备 device = frida.get_device_manager().add_remote_device( '{host}:{port}'.format(host=ip, port=port)) # 注入进程 if is_reboot: pid = device.spawn(package_name) process = device.attach(pid) else: process = device.attach(package_name) # 创建脚本 js = open(js_path, 'r', encoding='UTF-8').read() script = process.create_script(js) # 绑定函数 script.on('message', on_message) # 加载脚本 script.load() if is_reboot: device.resume(pid) print("common_enabled_debug running....") # 执行脚本 sys.stdin.read()
def get_usb_iphone(device_id=None): Type = 'usb' if int(frida.__version__.split('.')[0]) < 12: Type = 'tether' device_manager = frida.get_device_manager() changed = threading.Event() def on_changed(): changed.set() device_manager.on('changed', on_changed) device = None while device is None: for dev in device_manager.enumerate_devices(): if dev.type != Type: continue if device_id is not None and dev.id != device_id: continue device = dev break if device is None: print('Waiting for USB device...') changed.wait() device_manager.off('changed', on_changed) return device
def cli(package_name, library, output): global script global device global pid devices = frida.get_device_manager().enumerate_devices() device = get_device(devices) pid = device.spawn([package_name]) process = device.attach(pid) js = resource_string("trace_registernatives.build", "_agent.js").decode() script = process.create_script(js, runtime="v8") script.on("message", process_message) script.load() device.resume(pid) script.post({"type": "library", "name": library}) input() print("Stopped tracing...") if output: print("Saving output to file...") json.dump(registernatives, output)
def main(): process = frida.get_device_manager().enumerate_devices()[-1].attach( package_name) script = process.create_script(hook_log_on_resume()) script.on('message', get_messages_from_js) script.load() sys.stdin.read()
def parse_args(): parser = OptionParser(usage='usage: %prog [options] BundleID', version='%prog 0.1') parser.add_option('-L', '--local', action='store_true', default=False, help='Connect to local device') parser.add_option('-U', '--usb', action='store_true', default=False, help='Connect to USB device') parser.add_option('-R', '--remote', action='store', metavar='HOST', help='Connect to remote device') (options, args) = parser.parse_args() if options.local: device = frida.get_local_device() elif options.usb: device = frida.get_usb_device() elif options.remote: device = frida.get_device_manager().add_remote_device(options.remote) else: parser.print_help() sys.exit(0) if len(args) != 1: parser.print_help() sys.exit(0) return device, args[0]
def run(self): mgr = frida.get_device_manager() on_devices_changed = lambda: self._reactor.schedule(self._try_start) mgr.on('changed', on_devices_changed) self._reactor.schedule(self._try_start) self._reactor.schedule(self._show_message_if_no_device, delay=1) old_sigterm_handler = signal.signal(signal.SIGTERM, lambda n, f: self._exit(0)) self._reactor.run() signal.signal(signal.SIGTERM, old_sigterm_handler) if self._started: self._stop() if self._session is not None: self._session.off('detached', self._schedule_on_session_detached) self._session.detach() self._session = None if self._device is not None: self._device.off('output', self._schedule_on_output) self._device.off('lost', self._schedule_on_device_lost) mgr.off('changed', on_devices_changed) frida.shutdown() sys.exit(self._exit_status)
def get_usb_iphone(): Type = 'usb' if int(frida.__version__.split('.')[0]) < 12: Type = 'tether' device_manager = frida.get_device_manager() changed = threading.Event() def on_changed(): changed.set() device_manager.on('changed', on_changed) device = None while device is None: devices = [ dev for dev in device_manager.enumerate_devices() if dev.type == Type ] if len(devices) == 0: print('Waiting for USB device...') changed.wait() else: device = devices[0] device_manager.off('changed', on_changed) return device
def set_device(self): """ Set's the target device to work with. :return: """ if self.config.device_id is not None: self.device = frida.get_device(self.config.device_id) elif (self.config.host is not None) or (self.config.device_type == 'remote'): if self.config.host is None: self.device = frida.get_remote_device() else: host = self.config.host port = self.config.port self.device = frida.get_device_manager() \ .add_remote_device(f'{host}:{port}' if host is not None else f'127.0.0.1:{port}') elif self.config.device_type is not None: for dev in frida.enumerate_devices(): if dev.type == self.config.device_type: self.device = dev else: self.device = frida.get_local_device() # surely we have a device by now? if self.device is None: raise Exception('Unable to find a device') self.device.on('output', self.handlers.device_output) self.device.on('lost', self.handlers.device_lost) debug_print(f'device determined as: {self.device}')
def get_iphone(): device_manager = frida.get_device_manager() device_manager.add_remote_device(Host) changed = threading.Event() def on_changed(): changed.set() device_manager.on('changed', on_changed) device = None while device is None: devices = device_manager.enumerate_devices() if len(devices) < 1: print('Waiting for device...') changed.wait() else: print('Choose your device:') for i, d in enumerate(devices): print('{}) name={} type={}'.format(i, d.name, d.type)) print('x) Rescan devices') choice = input() if choice.isdigit(): device = devices[int(choice)] device_manager.off('changed', on_changed) return device
def attach(packageName): online_session = None online_script = None rdev = None remoteDriver = run_env.getRemoteDriver() #ip:port try: if remoteDriver: rdev = frida.get_device_manager().add_remote_device(remoteDriver) elif platform.system().find("Windows") != -1: warn("推荐使用linux或mac操作系统获得更好的兼容性.") rdev = frida.get_remote_device() else: rdev = frida.get_usb_device(1000) online_session = rdev.attach(packageName) if online_session == None: warn("attaching fail to " + packageName) online_script = online_session.create_script(run_env.rpc_jscode) online_script.on('message', on_message) online_script.load() checkRadarDex(packageName, online_script) createHookingEnverment(packageName, online_script.exports.mainactivity()) except Exception: warn(traceback.format_exc()) return online_session, online_script
def get_usb_iphone(): device_type = 'usb' if int(frida.__version__.split('.')[0]) < 12: device_type = 'tether' device_manager = frida.get_device_manager() changed = threading.Event() def on_changed(): changed.set() device_manager.on('changed', on_changed) device = None while device is None: devices = [ dev for dev in device_manager.enumerate_devices() if dev.type == device_type and dev.id == '6d824076de766cf571c81a4600dbc2cdd9ad4869' ] if len(devices) == 0: print('Waiting for USB device...') changed.wait() else: device = devices[0] device_manager.off('changed', on_changed) return device
def run(self): mgr = frida.get_device_manager() on_devices_changed = lambda: self._reactor.schedule(self._try_start) mgr.on('changed', on_devices_changed) self._reactor.schedule(self._try_start) self._reactor.schedule(self._show_message_if_no_device, delay=1) signal.signal(signal.SIGTERM, self._on_sigterm) self._reactor.run() if self._started: try: self._perform_on_background_thread(self._stop) except frida.OperationCancelledError: pass if self._session is not None: self._session.off('detached', self._schedule_on_session_detached) try: self._perform_on_background_thread(self._session.detach) except frida.OperationCancelledError: pass self._session = None if self._device is not None: self._device.off('output', self._schedule_on_output) self._device.off('lost', self._schedule_on_device_lost) mgr.off('changed', on_devices_changed) frida.shutdown() sys.exit(self._exit_status)
def attach(packageName, hookerDriverFridaServer, runningTime): hasException = False online_session = None online_script = None try: rdev = frida.get_device_manager().add_remote_device( hookerDriverFridaServer) online_session = rdev.attach(packageName) if online_session == None: warn("attaching fail to " + packageName) online_script = online_session.create_script(jscode) online_script.on('message', on_message) online_script.load() for i in range(1, runningTime): if i % 2 == 0: online_script.exports.log(mobileIP + " spider has running been " + str(i) + " seconds.") time.sleep(1) except Exception: hasException = True warn(traceback.format_exc()) finally: if online_session != None and hasException == False: online_session.detach() return online_session, online_script
def main(): if args.show_devices: for i,device in enumerate(frida.get_device_manager().enumerate_devices()): print "Index: {} | {}".format(i,device) return #Get device if args.device is None: #no args supplied, use USB device = frida.get_usb_device() else: #use device_id if supplied device = get_device(args.device) printlog("Device Connected: {}".format(device.name), 'ok') try: pid = device.spawn([package_name]) #spawned process with pid at suspended state except (frida.TransportError, frida.NotSupportedError, frida.ExecutableNotFoundError) as e: printlog(e.message, 'error') return except Exception: raise printlog("Spawned target with PID: {}".format(pid), 'debug') process = device.attach(pid) #get a debug session from pid printlog("Process attached!", 'ok') device.resume(pid) #resume process from suspended state #Create dumps directory, if it does not exist if not os.path.exists(dump_directory_location): os.makedirs(dump_directory_location) printlog( "Created Dumps Directory: {}".format(dump_directory_location), 'debug') else: printlog( "Dumps Directory: {}".format(dump_directory_location), 'debug') script = process.create_script(instrument_debugger_checks()) script.on('message',get_messages_from_js) printlog("Hook script start!", 'debug') script.load() try: sys.stdin.read() except KeyboardInterrupt: printlog("\r", 'raw') printlog("Abort script acknowledged, cleaning up...".format(pid)) device.kill(pid) printlog("Killed target with PID: {}".format(pid), 'debug') printlog("Script Exit.") return except Exception: raise
def _try_start(self): if self._device is not None: return if self._device_id is not None: try: self._device = frida.get_device(self._device_id) except: self._update_status("Device '%s' not found" % self._device_id) self._exit(1) return elif self._device_type is not None: self._device = find_device(self._device_type) if self._device is None: return elif self._host is not None: self._device = frida.get_device_manager().add_remote_device(self._host) else: self._device = frida.get_local_device() self._device.on('output', self._schedule_on_output) self._device.on('lost', self._schedule_on_device_lost) if self._target is not None: spawning = True try: target_type, target_value = self._target if target_type == 'file': argv = target_value self._update_status("Spawning `%s`..." % " ".join(argv)) self._spawned_pid = self._device.spawn(argv) self._spawned_argv = argv attach_target = self._spawned_pid else: attach_target = target_value self._update_status("Attaching...") spawning = False self._session = self._device.attach(attach_target) if self._disable_jit: self._session.disable_jit() if self._enable_debugger: self._session.enable_debugger() self._print("Debugger listening on port 5858\n") self._session.on('detached', self._schedule_on_session_detached) except Exception as e: if spawning: self._update_status("Failed to spawn: %s" % e) else: self._update_status("Failed to attach: %s" % e) self._exit(1) return self._start() self._started = True
def windowDidLoad(self): NSWindowController.windowDidLoad(self) device = [device for device in frida.get_device_manager().enumerate_devices() if device.type == 'local'][0] self.processList = ProcessList(device) self.capture = Capture(device) self.processCombo.setUsesDataSource_(True) self.processCombo.setDataSource_(self.processList) self.capture.setDelegate_(self) self.callTableView.setDataSource_(self.capture.calls) self.capture.calls.setDelegate_(self) self.loadDefaults() self.updateAttachForm_(self)
def run(self): mgr = frida.get_device_manager() on_devices_changed = lambda: self._reactor.schedule(self._try_start) mgr.on('changed', on_devices_changed) self._reactor.schedule(self._try_start) self._reactor.schedule(self._show_message_if_no_device, delay=0.1) self._reactor.run() if self._started: self._stop() if self._process is not None: self._process.off('detached', self._schedule_on_process_detached) self._process.detach() self._process = None if self._device is not None: self._device.off('lost', self._schedule_on_device_lost) mgr.off('changed', on_devices_changed) frida.shutdown() sys.exit(self._exit_status)
def module_pre(self): def launch_spawn(): # Launching the app self.printer.info("Spawning the app...") pid = device.spawn([self.APP_METADATA['bundle_id']]) # Attaching to the process self.printer.info("Attaching to process: %s" % pid) self.session = device.attach(pid) if self.options['resume']: self.printer.verbose("Resuming the app's process...") device.resume(pid) def launch_attach(): # Launching the app self.printer.info("Launching the app...") self.device.app.open(self.APP_METADATA['bundle_id']) pid = int(self.device.app.search_pid(self.APP_METADATA['binary_name'])) # Attaching to the process self.printer.info("Attaching to process: %s" % pid) self.session = device.attach(pid) # Run FridaModule setup function FridaModule.module_pre(self) # Get an handle to the device import frida if self.device.is_usb(): self.printer.debug("Connected over USB") device = frida.get_usb_device() else: self.printer.debug("Connected over Wi-Fi") device = frida.get_device_manager().enumerate_devices()[1] # Spawn/attach to the process if self.options['spawn']: launch_spawn() else: launch_attach() # Prepare results self.results = [] return 1
def run(self): mgr = frida.get_device_manager() on_devices_changed = lambda: self._reactor.schedule(self._try_start) mgr.on('changed', on_devices_changed) self._reactor.schedule(self._try_start) self._reactor.schedule(self._show_message_if_no_device, delay=0.1) self._reactor.run() if self._started: self._stop() if self._session is not None: self._session.off('detached', self._schedule_on_session_detached) self._session.detach() self._session = None if self._spawned_pid is not None: try: self._device.kill(self._spawned_pid) except: pass if self._device is not None: self._device.off('lost', self._schedule_on_device_lost) mgr.off('changed', on_devices_changed) frida.shutdown() sys.exit(self._exit_status)
def show_packages(): global device try: remote = request.args.get('remote') if device == None: if len(remote) != 0: # check remote ip address try: socket.inet_aton(remote) print "adding remote device to device manager : ",remote device=frida.get_device_manager().add_remote_device(remote) print "remote device : ", device except socket.error: return render_template('intro.html') else: device = frida.get_usb_device() # get list of apps packages=device.enumerate_processes() print packages except frida.ServerNotRunningError : return render_template('error.html',error="cannot connect to remote :(") return render_template('packages_list.html', packages=packages)
def test_enumerate_devices(self): devices = frida.get_device_manager().enumerate_devices() self.assertTrue(len(devices) > 0)
offset: 0, length: this.bufLen, header: true, ansi: true })); console.log("RESULT (1000 BYTES):"); var buf = Memory.readByteArray(retval, 1000); send({name:'result'},buf); console.log(hexdump(buf, { offset: 0, length: 1000, header: true, ansi: true })); } }); """ return hook_code deviceManager = frida.get_device_manager() devices = deviceManager.enumerate_devices() deviceMobile = devices[args.device] process = deviceMobile.attach(package_name) script = process.create_script(instrument_debugger_checks()) script.on('message',get_messages_from_js) script.load() sys.stdin.read()
def instrument_load_url(): hook_code = """ setTimeout(function(){ Dalvik.perform(function () { var TM = Dalvik.use("android.telephony.TelephonyManager"); TM.getDeviceId.implementation = function () { send("Called - deviceID()"); return "pwn3d"; }; }); },0); """ return hook_code process = frida.get_device_manager().enumerate_devices()[-1].attach(package_name) script = process.create_script(instrument_load_url()) script.on('message',get_messages_from_js) script.load() sys.stdin.read()
def get_device(device_idx): device_manager = frida.get_device_manager() devices = device_manager.enumerate_devices() return devices[device_idx]
Dalvik.perform(function () { var SSLPinning = Dalvik.use("com.onlycoin.android.secure.SSLPinning"); SSLPinning.a.overload("android.content.Context", "[Ljava.lang.String;", "java.lang.String").implementation = function (c, s, ss) { send("SSLPinning"); send(c.toString()); send(s.toString()); send(ss.toString()); this.a.overload("android.content.Context", "[Ljava.lang.String;", "java.lang.String").call(this, c, s, ss); }; }); """ return ssl if __name__ == "__main__": try: Popen(["adb forward tcp:27042 tcp:27042"], shell=True).wait() process = frida.get_device_manager().enumerate_devices()[-1].attach("com.onlycoin.android") script = process.create_script(do_ssl()) script.on('message', on_message) script.load() sys.stdin.read() except KeyboardInterrupt as e: sys.exit(0)
def find_device(type): for device in frida.get_device_manager().enumerate_devices(): if device.type == type: return device return None