AndroidFridaManager 1.0__tar.gz → 1.6__tar.gz

androidfridamanager-1.6/AndroidFridaManager/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+__version__ = "1.6"

androidfridamanager-1.6/AndroidFridaManager/job.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import threading
+import frida
+import uuid
+
+# Define a custom exception for handling frida based exceptions
+class FridaBasedException(Exception):
+    pass
+
+class Job:
+    def __init__(self, frida_script_name, custom_hooking_handler, process):
+        self.frida_script_name = frida_script_name
+        self.job_id = str(uuid.uuid4())
+        self.state = "initialized"
+        self.custom_hooking_handler = custom_hooking_handler
+        self.script = None
+        self.stop_event = threading.Event()
+        self.process_session = process
+        self.thread = None
+
+
+    def run_job(self):
+        #self.is_running_as_thread = True
+        self.run_job_as_thread()
+
+
+    def run_job_as_thread(self):
+        self.thread = threading.Thread(target=self.invoke_handle_hooking)
+        self.thread.start()
+
+
+    def invoke_handle_hooking(self):
+        self.instrument(self.process_session)
+        self.script.on("message", self.wrap_custom_hooking_handler_with_job_id(self.custom_hooking_handler))
+        self.script.load()
+        self.state = "running"
+        print("[+] hooks succesfully loaded")
+
+        #if self.is_running_as_thread:
+        # Keep the thread alive to handle messages until stop_event is set
+        while not self.stop_event.is_set():
+            self.stop_event.wait(1) # Sleep for 1 second and check again
+
+
+    def wrap_custom_hooking_handler_with_job_id(self, handler):
+
+        def wrapped_handler(message, data):
+            # Add job_id to the message
+            message['job_id'] = self.job_id
+            handler(message, data)
+
+        return wrapped_handler
+
+
+    def instrument(self, process_session,runtime="qjs"):
+            try:
+                with open(self.frida_script_name, encoding='utf8', newline='\n') as f:
+                    script_string = f.read()
+                    self.script = process_session.create_script(script_string, runtime=runtime)
+                    return self.script
+                
+            except frida.ProcessNotFoundError:
+                raise FridaBasedException("Unable to find target process")
+            except frida.InvalidOperationError:
+                raise FridaBasedException("Invalid operation! Please run in debug mode in order to understand the source of this error and report it.")
+            except frida.TransportError:
+                raise FridaBasedException("Timeout error due to some internal frida error's. Try to restart frida-server again.")
+            except frida.ProtocolError:
+                raise FridaBasedException("Connection is closed. Probably the target app crashed")
+
+
+    def close_job(self):
+        self.state = "stopping"
+        self.stop_event.set()
+        if self.thread:
+            self.thread.join()
+        if self.script:
+            self.script.unload()
+        
+        print(f"Job {self.job_id} stopped")
+
+
+    def get_id(self):
+        return self.job_id

androidfridamanager-1.6/AndroidFridaManager/job_manager.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import atexit
+import subprocess
+import frida
+from typing import Optional, Dict, Union
+from job import Job, FridaBasedException
+import time
+import re
+
+class JobManager(object):
+    """  A class representing the current Job manager. """
+
+
+    def __init__(self,host="", enable_spawn_gating=False) -> None:
+        """
+            Init a new job manager. This method will also
+            register an atexit(), ensuring that cleanup operations
+            are performed on jobs when this class is GC'd.
+        """
+
+        self.jobs = {}
+        self.is_first_job = True
+        self.process_session = None
+        self.host = host
+        self.pid = -1
+        self.device = None
+        self.package_name = ""
+        self.enable_spawn_gating = enable_spawn_gating
+        self.first_instrumenation_script = None
+        atexit.register(self.cleanup)
+
+
+    def cleanup(self) -> None:
+        """
+            Clean up all of the job in the job manager.
+
+            This method is typical called when at the end of an
+            session.
+
+            :return:
+        """
+        if len(self.jobs) > 0:
+            print("[*] Program closed. Stopping active jobs...")
+            self.stop_jobs()
+
+        print("\n[*] Have a nice day!")
+    
+
+    def job_list(self):
+        return list(self.jobs.keys())
+
+
+    def running_jobs(self):
+        return [job_id for job_id, job in self.jobs.items() if job.state == "running"]
+
+    '''
+    # only used for debugging
+    def running_jobs2(self):
+        tuple_jobs = [job for job in self.jobs.items()]
+        for job_id, job in tuple_jobs:
+            print(f"Job state of Job {job_id} in state {job.state}")
+        return tuple_jobs
+    '''
+
+    def spawn(self, target_process):
+        self.package_name = target_process
+        print("[*] spawning app: "+ target_process)
+        pid = self.device.spawn(target_process)
+        self.process_session = self.device.attach(pid)
+        print(f"Spawned {target_process} with PID {pid}")
+        return pid
+
+
+    def start_android_app(self, package_name: str, main_activity: Optional[str] = None, extras: Optional[Dict[str, Union[str, bool]]] = None):
+        """
+        Start an Android app using adb.
+
+        :param package_name: The package name of the app.
+        :param main_activity: The main activity of the app (optional).
+        :param extras: A dictionary of extras to pass to the intent (optional).
+        """
+        if main_activity:
+            self.package_name = package_name
+            # Prepare the base command for starting the app with main activity
+            cmd = ['adb', 'shell', 'am', 'start', '-n', f'{package_name}/{main_activity}']
+            
+            # Add extras if provided
+            if extras:
+                for key, value in extras.items():
+                    if isinstance(value, bool):
+                        cmd.extend(['--ez', key, 'true' if value else 'false'])
+                    elif isinstance(value, str):
+                        cmd.extend(['--es', key, value])
+        else:
+            # Command to start the app using monkey if no main activity is provided
+            cmd = ['adb', 'shell', 'monkey', '-p', package_name, '-c', 'android.intent.category.LAUNCHER', '1']
+        
+        # Run the command and capture the output
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+    
+        # Extract the PID from the output
+        pid = None
+        if 'ThisTime' in result.stdout:
+            # `am start` command includes the PID in the output
+            pid_match = re.search(r'(?<=ThisTime: \d+\s)Proc=\w+,\s(\d+)', result.stdout)
+            if pid_match:
+                pid = int(pid_match.group(1))
+        elif 'Events injected' in result.stdout:
+            # `monkey` command does not provide PID directly, need to get it separately
+            pid_cmd = ['adb', 'shell', 'pidof', package_name]
+            pid_result = subprocess.run(pid_cmd, capture_output=True, text=True, check=True)
+            if pid_result.stdout:
+                pid = int(pid_result.stdout.split()[0])
+
+        if pid is None:
+            raise RuntimeError("Failed to get PID of the started app")
+
+        return pid
+
+
+    def attach_app(self, target_process, foreground=False):
+        self.package_name = target_process
+
+        if foreground:
+            target_process = self.device.get_frontmost_application()
+            if target_process is None or len(target_process.identifier) < 2:
+                print("[-] unable to attach to the frontmost application. Aborting ...")
+
+            target_process = target_process.identifier
+
+        if isinstance(target_process, int):
+            print(f"[*] attaching to PID: {target_process}")
+            self.process_session = self.device.attach(target_process)
+        else:
+            print(f"[*] attaching to app: {target_process}")
+            self.process_session = self.device.attach(int(target_process) if target_process.isnumeric() else target_process)
+
+             
+
+
+    def setup_frida_session(self, target_process, custom_hooking_handler_name, should_spawn=True,foreground=False):
+        self.first_instrumenation_script = custom_hooking_handler_name
+        self.device = self.setup_frida_handler(self.host, self.enable_spawn_gating)
+
+        try:  
+            if should_spawn:
+                self.pid = self.spawn(target_process)
+            else:
+                self.attach_app(target_process,foreground)
+        except frida.TimedOutError as te:
+            raise FridaBasedException(f"TimeOutError: {te}")
+        except frida.ProcessNotFoundError as pe:
+            raise FridaBasedException(f"ProcessNotFoundError: {pe}")
+        
+    
+    def start_job(self,frida_script_name, custom_hooking_handler_name):
+        try:
+
+            if self.process_session:
+                job = Job(frida_script_name, custom_hooking_handler_name, self.process_session)
+                print(f"[*] created job: {job.job_id}")
+                self.jobs[job.job_id] = job
+                job.run_job()
+                if self.is_first_job:
+                    self.is_first_job = False
+                    self.first_instrumenation_script = custom_hooking_handler_name
+                    if self.pid != -1:
+                        self.device.resume(self.pid)
+                        time.sleep(1) # without it Java.perform silently fails
+
+            else:
+                print("[-] no frida session. Aborting...")
+
+        except frida.TransportError as fe:
+            raise FridaBasedException(f"Problems while attaching to frida-server: {fe}")
+        except FridaBasedException as e:
+            raise FridaBasedException(f"Frida based error: {e}")
+        except frida.TimedOutError as te:
+            raise FridaBasedException(f"TimeOutError: {te}")
+        except frida.ProcessNotFoundError as pe:
+            raise FridaBasedException(f"ProcessNotFoundError: {pe}")
+        except KeyboardInterrupt:
+            self.stop_app_with_last_job(job,self.package_name)
+            pass
+
+    
+    def stop_jobs(self):
+        jobs_to_stop = [job_id for job_id, job in self.jobs.items() if job.state == "running"]
+        for job_id in jobs_to_stop:
+            try:
+                print('[job manager] Job: {0} - Stopping'.format(job_id))
+                self.stop_job_with_id(job_id)
+            except frida.InvalidOperationError:
+                print('[job manager] Job: {0} - An error occurred stopping job. Device may '
+                             'no longer be available.'.format(job_id))
+    
+    
+    def stop_job_with_id(self,job_id):
+        if job_id in self.jobs:
+            job = self.jobs[job_id]
+            job.close_job()
+            del self.jobs[job_id]
+
+
+    def detach_from_app(self):
+        if self.process_session:
+            self.process_session.detach()
+
+
+    def stop_app(self, app_package):
+        subprocess.run(["adb", "shell", "am", "force-stop", app_package])
+
+
+    def stop_app_with_last_job(self, last_job, app_package):
+        last_job.close_job()
+        self.stop_app(app_package)
+        
+
+
+    def stop_app_with_closing_frida(self, app_package):
+        jobs_to_stop = [job_id for job_id, job in self.jobs.items() if job.state == "running"]
+        for job_id in jobs_to_stop:
+            print(f"[*] trying to close job: {job_id}")
+            self.stop_job_with_id(job_id)
+        
+        self.detach_from_app()
+        subprocess.run(["adb", "shell", "am", "force-stop", app_package])
+
+
+    def kill_app(self, pid):
+        subprocess.run(["adb", "shell", "kill", str(pid)])
+
+    
+    def setup_frida_handler(self,host="", enable_spawn_gating=False):
+        try:
+            if len(host) > 4:
+                # we can also use the IP address ot the target machine instead of using USB - e.g. when we have multpile AVDs
+                device = frida.get_device_manager().add_remote_device(host)
+            else:
+                device = frida.get_usb_device()
+
+            # to handle forks
+            def on_child_added(child):
+                print(f"Attached to child process with pid {child.pid}")
+                self.first_instrumenation_script(device.attach(child.pid))
+                device.resume(child.pid)
+
+            # if the target process is starting another process 
+            def on_spawn_added(spawn):
+                print(f"Process spawned with pid {spawn.pid}. Name: {spawn.identifier}")
+                self.first_instrumenation_script(device.attach(spawn.pid))
+                device.resume(spawn.pid)
+
+            device.on("child_added", on_child_added)
+            if enable_spawn_gating:
+                device.enable_spawn_gating()
+                device.on("spawn_added", on_spawn_added)
+            
+            return device
+
+        except frida.InvalidArgumentError:
+            raise FridaBasedException("Unable to find device")
+        except frida.ServerNotRunningError:
+            raise FridaBasedException("Frida server not running. Start frida-server and try it again.")

androidfridamanager-1.6/AndroidFridaManager.egg-info/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.1
+Name: AndroidFridaManager
+Version: 1.6
+Summary: A python API in order to install and run the frida-server on an Android device.
+Home-page: https://github.com/fkie-cad/AndroidFridaManager
+Author: Daniel Baier
+Author-email: daniel.baier@fkie.fraunhofer.de
+License: GPL v3
+Keywords: mobile,instrumentation,frida,hook,android
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: JavaScript
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Debuggers
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: frida>=15.0.0
+Requires-Dist: colorlog
+
+# AndroidFridaManager
+
+AndroidFridaManager is a Python API designed to simplify the installation and management of Frida on Android devices. It provides an easy-to-use interface for installing and running the latest Frida server, as well as the flexibility to install specific versions as needed.
+
+Key Features
+
+    Frida Server Management: Seamlessly install and run the latest Frida server on your Android device, or choose to install a specific version as required.
+    Job Management: Execute Frida scripts as independent jobs, managed by the `JobManager()`. This feature allows for concurrent execution of multiple Frida scripts, with each job running in its own thread.
+    `afrim` Tool Integration: Utilize the `afrim` tool to check for existing Frida server installations on your device and ensure you are always running the latest version.
+
+
+The project was inspired by [Frida-Python-Binding](https://github.com/Mind0xP/Frida-Python-Binding/tree/master).
+
+## Install
+
+Just install it via pip:
+```bash
+pip install AndroidFridaManager
+```
+
+This will install the `afrim`-command to your system.
+
+## Usage
+
+In order to easily install the latest frida-server version to your Android device just run the following command:
+
+```bash
+$ afrim 
+```
+
+
+In order to check only if frida-server is running invoke it with the `-r`-parameter:
+
+```bash
+$ afrim -r
+```
+
+
+## API Usage
+
+In order to install and run Frida on your Android device use the `FridaManager`-API:
+```python
+from AndroidFridaManager import FridaManager
+...
+afm_obj = FridaManager(is_remote=False, socket="ip:port", verbose=False, frida_install_dst="/data/local/tmp/")
+afm_obj.install_frida_server()
+afm_obj.run_frida_server()
+```
+
+For running Frida scripts as jobs use the `JobManager`-API:
+```python
+from AndroidFridaManager import JobManager
+...
+app_package = "net.classwindexampleyear.bookseapiececountry"
+frida_script_path = "./frida_script1.js"
+job_manager = JobManager()
+job_manager.setup_frida_session(app_package, myAwesomeHookingHandler)
+job_manager.start_job(frida_script_path, myAwesomeHookingHandler)
+print("Running jobs:", job_manager.running_jobs())
+job_manager.stop_app_with_closing_frida(app_package)
+``` 
+
+The `setup_frida_session()` function accepts a callback function as its second parameter, typically provided by `script.on('message', on_message)`. This initializes the first job and, by default, is the only job where you can activate [child_gating and spawn_gating](https://frida.re/news/#child-gating). To execute the job, you must invoke the `start_job()` function.
+
+## API
+
+```python
+install_frida_server(dst_dir="/data/local/tmp/", version="latest")
+run_frida_server()
+is_frida_server_running()
+stop_frida_server()
+remove_frida_server()
+
+# JobManager
+JobManager(host="", enable_spawn_gating=False)
+running_jobs() # list running jobs
+start_android_app(package_name, main_activity = None, extras = None) # returns the PID of the start app
+setup_frida_session(target_process, frida_callback_function, should_spawn=True,foreground=False)
+start_job(frida_script_name, frida_callback_function)
+stop_jobs() # stops all running jobs
+stop_job_with_id(job_id) # stop only job with job_id
+detach_from_app() # will also be invoked when running stop_app_with_closing_frida()
+stop_app_with_closing_frida(app_package)
+stop_app(app_package)
+kill_app(pid)
+setup_frida_handler(host="", enable_spawn_gating=False) # returns the device object and is used by setup_frida_session()
+
+# setup_frida_handler,setup_frida_session will raise the FridaBasedException(Exception). Ensure to handle it
+```

{AndroidFridaManager-1.0 → androidfridamanager-1.6}/AndroidFridaManager.egg-info/SOURCES.txt

@@ -1,8 +1,12 @@
 LICENSE
+MANIFEST.in
 README.md
+requirements.txt
 setup.py
-AndroidFridaManager/AndroidFridaManager.py
+AndroidFridaManager/FridaManager.py
 AndroidFridaManager/__init__.py
+AndroidFridaManager/job.py
+AndroidFridaManager/job_manager.py
 AndroidFridaManager.egg-info/PKG-INFO
 AndroidFridaManager.egg-info/SOURCES.txt
 AndroidFridaManager.egg-info/dependency_links.txt

androidfridamanager-1.6/AndroidFridaManager.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+afrim = AndroidFridaManager.FridaManager:main

androidfridamanager-1.6/MANIFEST.in

@@ -0,0 +1 @@
+include requirements.txt

androidfridamanager-1.6/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.1
+Name: AndroidFridaManager
+Version: 1.6
+Summary: A python API in order to install and run the frida-server on an Android device.
+Home-page: https://github.com/fkie-cad/AndroidFridaManager
+Author: Daniel Baier
+Author-email: daniel.baier@fkie.fraunhofer.de
+License: GPL v3
+Keywords: mobile,instrumentation,frida,hook,android
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: JavaScript
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Debuggers
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: frida>=15.0.0
+Requires-Dist: colorlog
+
+# AndroidFridaManager
+
+AndroidFridaManager is a Python API designed to simplify the installation and management of Frida on Android devices. It provides an easy-to-use interface for installing and running the latest Frida server, as well as the flexibility to install specific versions as needed.
+
+Key Features
+
+    Frida Server Management: Seamlessly install and run the latest Frida server on your Android device, or choose to install a specific version as required.
+    Job Management: Execute Frida scripts as independent jobs, managed by the `JobManager()`. This feature allows for concurrent execution of multiple Frida scripts, with each job running in its own thread.
+    `afrim` Tool Integration: Utilize the `afrim` tool to check for existing Frida server installations on your device and ensure you are always running the latest version.
+
+
+The project was inspired by [Frida-Python-Binding](https://github.com/Mind0xP/Frida-Python-Binding/tree/master).
+
+## Install
+
+Just install it via pip:
+```bash
+pip install AndroidFridaManager
+```
+
+This will install the `afrim`-command to your system.
+
+## Usage
+
+In order to easily install the latest frida-server version to your Android device just run the following command:
+
+```bash
+$ afrim 
+```
+
+
+In order to check only if frida-server is running invoke it with the `-r`-parameter:
+
+```bash
+$ afrim -r
+```
+
+
+## API Usage
+
+In order to install and run Frida on your Android device use the `FridaManager`-API:
+```python
+from AndroidFridaManager import FridaManager
+...
+afm_obj = FridaManager(is_remote=False, socket="ip:port", verbose=False, frida_install_dst="/data/local/tmp/")
+afm_obj.install_frida_server()
+afm_obj.run_frida_server()
+```
+
+For running Frida scripts as jobs use the `JobManager`-API:
+```python
+from AndroidFridaManager import JobManager
+...
+app_package = "net.classwindexampleyear.bookseapiececountry"
+frida_script_path = "./frida_script1.js"
+job_manager = JobManager()
+job_manager.setup_frida_session(app_package, myAwesomeHookingHandler)
+job_manager.start_job(frida_script_path, myAwesomeHookingHandler)
+print("Running jobs:", job_manager.running_jobs())
+job_manager.stop_app_with_closing_frida(app_package)
+``` 
+
+The `setup_frida_session()` function accepts a callback function as its second parameter, typically provided by `script.on('message', on_message)`. This initializes the first job and, by default, is the only job where you can activate [child_gating and spawn_gating](https://frida.re/news/#child-gating). To execute the job, you must invoke the `start_job()` function.
+
+## API
+
+```python
+install_frida_server(dst_dir="/data/local/tmp/", version="latest")
+run_frida_server()
+is_frida_server_running()
+stop_frida_server()
+remove_frida_server()
+
+# JobManager
+JobManager(host="", enable_spawn_gating=False)
+running_jobs() # list running jobs
+start_android_app(package_name, main_activity = None, extras = None) # returns the PID of the start app
+setup_frida_session(target_process, frida_callback_function, should_spawn=True,foreground=False)
+start_job(frida_script_name, frida_callback_function)
+stop_jobs() # stops all running jobs
+stop_job_with_id(job_id) # stop only job with job_id
+detach_from_app() # will also be invoked when running stop_app_with_closing_frida()
+stop_app_with_closing_frida(app_package)
+stop_app(app_package)
+kill_app(pid)
+setup_frida_handler(host="", enable_spawn_gating=False) # returns the device object and is used by setup_frida_session()
+
+# setup_frida_handler,setup_frida_session will raise the FridaBasedException(Exception). Ensure to handle it
+```

androidfridamanager-1.6/README.md

@@ -0,0 +1,89 @@
+# AndroidFridaManager
+
+AndroidFridaManager is a Python API designed to simplify the installation and management of Frida on Android devices. It provides an easy-to-use interface for installing and running the latest Frida server, as well as the flexibility to install specific versions as needed.
+
+Key Features
+
+    Frida Server Management: Seamlessly install and run the latest Frida server on your Android device, or choose to install a specific version as required.
+    Job Management: Execute Frida scripts as independent jobs, managed by the `JobManager()`. This feature allows for concurrent execution of multiple Frida scripts, with each job running in its own thread.
+    `afrim` Tool Integration: Utilize the `afrim` tool to check for existing Frida server installations on your device and ensure you are always running the latest version.
+
+
+The project was inspired by [Frida-Python-Binding](https://github.com/Mind0xP/Frida-Python-Binding/tree/master).
+
+## Install
+
+Just install it via pip:
+```bash
+pip install AndroidFridaManager
+```
+
+This will install the `afrim`-command to your system.
+
+## Usage
+
+In order to easily install the latest frida-server version to your Android device just run the following command:
+
+```bash
+$ afrim 
+```
+
+
+In order to check only if frida-server is running invoke it with the `-r`-parameter:
+
+```bash
+$ afrim -r
+```
+
+
+## API Usage
+
+In order to install and run Frida on your Android device use the `FridaManager`-API:
+```python
+from AndroidFridaManager import FridaManager
+...
+afm_obj = FridaManager(is_remote=False, socket="ip:port", verbose=False, frida_install_dst="/data/local/tmp/")
+afm_obj.install_frida_server()
+afm_obj.run_frida_server()
+```
+
+For running Frida scripts as jobs use the `JobManager`-API:
+```python
+from AndroidFridaManager import JobManager
+...
+app_package = "net.classwindexampleyear.bookseapiececountry"
+frida_script_path = "./frida_script1.js"
+job_manager = JobManager()
+job_manager.setup_frida_session(app_package, myAwesomeHookingHandler)
+job_manager.start_job(frida_script_path, myAwesomeHookingHandler)
+print("Running jobs:", job_manager.running_jobs())
+job_manager.stop_app_with_closing_frida(app_package)
+``` 
+
+The `setup_frida_session()` function accepts a callback function as its second parameter, typically provided by `script.on('message', on_message)`. This initializes the first job and, by default, is the only job where you can activate [child_gating and spawn_gating](https://frida.re/news/#child-gating). To execute the job, you must invoke the `start_job()` function.
+
+## API
+
+```python
+install_frida_server(dst_dir="/data/local/tmp/", version="latest")
+run_frida_server()
+is_frida_server_running()
+stop_frida_server()
+remove_frida_server()
+
+# JobManager
+JobManager(host="", enable_spawn_gating=False)
+running_jobs() # list running jobs
+start_android_app(package_name, main_activity = None, extras = None) # returns the PID of the start app
+setup_frida_session(target_process, frida_callback_function, should_spawn=True,foreground=False)
+start_job(frida_script_name, frida_callback_function)
+stop_jobs() # stops all running jobs
+stop_job_with_id(job_id) # stop only job with job_id
+detach_from_app() # will also be invoked when running stop_app_with_closing_frida()
+stop_app_with_closing_frida(app_package)
+stop_app(app_package)
+kill_app(pid)
+setup_frida_handler(host="", enable_spawn_gating=False) # returns the device object and is used by setup_frida_session()
+
+# setup_frida_handler,setup_frida_session will raise the FridaBasedException(Exception). Ensure to handle it
+```

androidfridamanager-1.6/requirements.txt

@@ -0,0 +1,3 @@
+frida>=15.0.0
+colorlog
+

{AndroidFridaManager-1.0 → androidfridamanager-1.6}/setup.py

@@ -72,7 +72,7 @@ setup(
 
     entry_points={
             'console_scripts': [
-                'afrim=AndroidFridaManager.AndroidFridaManager:main',
+                'afrim=AndroidFridaManager.FridaManager:main',
         ],
     },
 )

AndroidFridaManager-1.0/AndroidFridaManager/__init__.py

@@ -1,6 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-from AndroidFridaManager.AndroidFridaManager import FridaManager
-
-__version__ = "1.0"

AndroidFridaManager-1.0/AndroidFridaManager.egg-info/PKG-INFO

@@ -1,69 +0,0 @@
-Metadata-Version: 2.1
-Name: AndroidFridaManager
-Version: 1.0
-Summary: A python API in order to install and run the frida-server on an Android device.
-Home-page: https://github.com/fkie-cad/AndroidFridaManager
-Author: Daniel Baier
-Author-email: daniel.baier@fkie.fraunhofer.de
-License: GPL v3
-Keywords: mobile,instrumentation,frida,hook,android
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Operating System :: OS Independent
-Classifier: Natural Language :: English
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: JavaScript
-Classifier: Topic :: Security
-Classifier: Topic :: Software Development :: Debuggers
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# AndroidFridaManager
-
-A python API in order to install and run the frida-server on an Android device. The project was inspired by [Frida-Python-Binding](https://github.com/Mind0xP/Frida-Python-Binding/tree/master).
-
-## Install
-
-Just install it via pip:
-```bash
-pip install AndroidFridaManager
-```
-
-This will install the `afrim`-command to your system.
-
-## Usage
-
-In order to easily install the latest frida-server version to your Android device just run the following command:
-
-```bash
-$ afrim 
-```
-
-
-In order to check only if frida-server is running invoke it with the `-r`-parameter:
-
-```bash
-$ afrim -r
-```
-
-
-## API Usage
-
-```python
-from AndroidFridaManager import FridaManager
-...
-afm_obj = FridaManager(is_remote=False, socket="ip:port", verbose=False, frida_install_dst="/data/local/tmp/")
-afm_obj.install_frida_server()
-afm_obj.run_frida_server()
-```
-
-
-## API
-
-```python
-install_frida_server(dst_dir="/data/local/tmp/", version="latest")
-run_frida_server()
-is_frida_server_running()
-stop_frida_server()
-remove_frida_server()
-```

AndroidFridaManager-1.0/AndroidFridaManager.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-afrim = AndroidFridaManager.AndroidFridaManager:main

AndroidFridaManager-1.0/PKG-INFO

@@ -1,69 +0,0 @@
-Metadata-Version: 2.1
-Name: AndroidFridaManager
-Version: 1.0
-Summary: A python API in order to install and run the frida-server on an Android device.
-Home-page: https://github.com/fkie-cad/AndroidFridaManager
-Author: Daniel Baier
-Author-email: daniel.baier@fkie.fraunhofer.de
-License: GPL v3
-Keywords: mobile,instrumentation,frida,hook,android
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Operating System :: OS Independent
-Classifier: Natural Language :: English
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: JavaScript
-Classifier: Topic :: Security
-Classifier: Topic :: Software Development :: Debuggers
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# AndroidFridaManager
-
-A python API in order to install and run the frida-server on an Android device. The project was inspired by [Frida-Python-Binding](https://github.com/Mind0xP/Frida-Python-Binding/tree/master).
-
-## Install
-
-Just install it via pip:
-```bash
-pip install AndroidFridaManager
-```
-
-This will install the `afrim`-command to your system.
-
-## Usage
-
-In order to easily install the latest frida-server version to your Android device just run the following command:
-
-```bash
-$ afrim 
-```
-
-
-In order to check only if frida-server is running invoke it with the `-r`-parameter:
-
-```bash
-$ afrim -r
-```
-
-
-## API Usage
-
-```python
-from AndroidFridaManager import FridaManager
-...
-afm_obj = FridaManager(is_remote=False, socket="ip:port", verbose=False, frida_install_dst="/data/local/tmp/")
-afm_obj.install_frida_server()
-afm_obj.run_frida_server()
-```
-
-
-## API
-
-```python
-install_frida_server(dst_dir="/data/local/tmp/", version="latest")
-run_frida_server()
-is_frida_server_running()
-stop_frida_server()
-remove_frida_server()
-```

AndroidFridaManager-1.0/README.md

@@ -1,49 +0,0 @@
-# AndroidFridaManager
-
-A python API in order to install and run the frida-server on an Android device. The project was inspired by [Frida-Python-Binding](https://github.com/Mind0xP/Frida-Python-Binding/tree/master).
-
-## Install
-
-Just install it via pip:
-```bash
-pip install AndroidFridaManager
-```
-
-This will install the `afrim`-command to your system.
-
-## Usage
-
-In order to easily install the latest frida-server version to your Android device just run the following command:
-
-```bash
-$ afrim 
-```
-
-
-In order to check only if frida-server is running invoke it with the `-r`-parameter:
-
-```bash
-$ afrim -r
-```
-
-
-## API Usage
-
-```python
-from AndroidFridaManager import FridaManager
-...
-afm_obj = FridaManager(is_remote=False, socket="ip:port", verbose=False, frida_install_dst="/data/local/tmp/")
-afm_obj.install_frida_server()
-afm_obj.run_frida_server()
-```
-
-
-## API
-
-```python
-install_frida_server(dst_dir="/data/local/tmp/", version="latest")
-run_frida_server()
-is_frida_server_running()
-stop_frida_server()
-remove_frida_server()
-```