AndroidFridaManager 1.9.0__py3-none-any.whl → 1.9.2__py3-none-any.whl

AndroidFridaManager/FridaManager.py

@@ -3,7 +3,7 @@
 
 import frida
 import os
-import sys 
+import sys
 import logging
 from colorlog import ColoredFormatter
 import subprocess
@@ -15,46 +15,76 @@ from shutil import copyfile
 import tempfile
 import argparse
 import shutil
+from typing import Optional, List, Dict, Tuple
 
 # some parts are taken from ttps://github.com/Mind0xP/Frida-Python-Binding/
 
 class FridaManager():
 
-    def __init__(self, is_remote=False, socket="", verbose=False, frida_install_dst="/data/local/tmp/"):
+    def __init__(self, is_remote=False, socket="", verbose=False, frida_install_dst="/data/local/tmp/", device_serial: Optional[str] = None):
         """
         Constructor of the current FridaManager instance
 
-        :param is_remote: The number to multiply.
-        :type number: bool
+        :param is_remote: Whether to use remote Frida connection.
+        :type is_remote: bool
         :param socket: The socket to connect to the remote device. The remote device needs to be set by <ip:port>. By default this string will be empty in order to indicate that FridaManger is working with the first connected USB device.
-        :type number: string
+        :type socket: string
         :param verbose: Set the output to verbose, so that the logging information gets printed. By default set to False.
-        :type number: bool
+        :type verbose: bool
         :param frida_install_dst: The path where the frida server should be installed. By default it will be installed to /data/local/tmp/.
-        :type number: bool
+        :type frida_install_dst: string
+        :param device_serial: Specific device serial to target (e.g., 'emulator-5554'). If None, auto-selects device (prefers emulators when multiple devices connected).
+        :type device_serial: Optional[str]
 
         """
         self.is_remote = is_remote
         self.device_socket = socket
         self.verbose = verbose
         self.is_magisk_mode = False
+        self.is_adb_root_mode = False  # LineageOS adb root mode (adbd runs as root)
         self.frida_install_dst = frida_install_dst
         self._setup_logging()
         self.logger = logging.getLogger(__name__)
 
+        # Multi-device support
+        self._device_serial: Optional[str] = None
+        self._is_rooted: Optional[bool] = None  # Cached root status
+        self._multiple_devices: bool = False
+
         # Check if ADB is available
         self._check_adb_availability()
 
+        # Handle device selection
+        if device_serial:
+            self._device_serial = device_serial
+            self._validate_device(device_serial)
+        else:
+            self._auto_select_device()
+
         if self.is_remote:
             frida.get_device_manager().add_remote_device(self.device_socket)
 
+    @property
+    def device_serial(self) -> Optional[str]:
+        """Get the current target device serial."""
+        return self._device_serial
+
+    @device_serial.setter
+    def device_serial(self, serial: str) -> None:
+        """Set the target device serial."""
+        self._validate_device(serial)
+        self._device_serial = serial
+        # Reset cached root status and mode flags for new device
+        self._is_rooted = None
+        self.is_magisk_mode = False
+        self.is_adb_root_mode = False
 
     def _setup_logging(self):
         """
-        Setup logging for the current instance of FridaManager 
+        Setup logging for the current instance of FridaManager
         """
         logger = logging.getLogger()
-        
+
         # Check if the logger already has handlers (i.e., if another project has set it up)
         if not logger.handlers:
             logger.setLevel(logging.INFO)
@@ -87,37 +117,243 @@ class FridaManager():
             self.logger.info("  - Make sure 'adb' command is accessible from your terminal")
             sys.exit(1)
 
+    # ==================== Multi-Device Support ====================
+
+    @classmethod
+    def get_connected_devices(cls) -> List[Dict[str, str]]:
+        """
+        Get list of all connected Android devices via ADB.
+
+        :return: List of device dictionaries with 'serial', 'state', 'type', and 'model' keys
+        :rtype: List[Dict[str, str]]
+        """
+        try:
+            result = subprocess.run(
+                ['adb', 'devices', '-l'],
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+
+            devices = []
+            for line in result.stdout.strip().split('\n')[1:]:  # Skip header
+                if not line.strip():
+                    continue
+
+                parts = line.split()
+                if len(parts) < 2:
+                    continue
+
+                serial = parts[0]
+                state = parts[1]
+
+                # Parse additional info
+                model = ""
+                product = ""
+                for part in parts[2:]:
+                    if part.startswith("model:"):
+                        model = part.split(":", 1)[1]
+                    elif part.startswith("product:"):
+                        product = part.split(":", 1)[1]
+
+                # Determine device type
+                device_type = "emulator" if serial.startswith("emulator-") else "physical"
+
+                devices.append({
+                    'serial': serial,
+                    'state': state,
+                    'type': device_type,
+                    'model': model or product or serial,
+                })
+
+            return devices
+
+        except subprocess.TimeoutExpired:
+            return []
+        except Exception as e:
+            logging.getLogger(__name__).debug(f"Error getting devices: {e}")
+            return []
+
+    @classmethod
+    def get_frida_devices(cls) -> List[Dict[str, str]]:
+        """
+        Get list of devices visible to Frida.
+
+        :return: List of device dictionaries with 'id', 'name', 'type' keys
+        :rtype: List[Dict[str, str]]
+        """
+        try:
+            devices = []
+            for device in frida.enumerate_devices():
+                if device.type in ('usb', 'remote'):
+                    devices.append({
+                        'id': device.id,
+                        'name': device.name,
+                        'type': device.type,
+                    })
+            return devices
+        except Exception as e:
+            logging.getLogger(__name__).debug(f"Error enumerating Frida devices: {e}")
+            return []
+
+    def _validate_device(self, serial: str) -> bool:
+        """
+        Validate that a device with the given serial is connected.
+
+        :param serial: Device serial to validate
+        :return: True if valid, raises RuntimeError otherwise
+        """
+        devices = self.get_connected_devices()
+        device_serials = [d['serial'] for d in devices]
+
+        if serial not in device_serials:
+            available = ", ".join(device_serials) if device_serials else "none"
+            raise RuntimeError(
+                f"Device '{serial}' not found. Available devices: {available}"
+            )
+
+        # Check device state
+        device = next(d for d in devices if d['serial'] == serial)
+        if device['state'] != 'device':
+            raise RuntimeError(
+                f"Device '{serial}' is not ready (state: {device['state']})"
+            )
+
+        return True
+
+    def _auto_select_device(self) -> None:
+        """
+        Automatically select a device when multiple are connected.
+
+        Priority:
+        1. If only one device, use it
+        2. If multiple devices, prefer emulators (they have root by default)
+        3. If multiple emulators, use the first one
+        """
+        devices = self.get_connected_devices()
+        ready_devices = [d for d in devices if d['state'] == 'device']
+
+        if not ready_devices:
+            self.logger.warning("No Android devices connected")
+            return
+
+        if len(ready_devices) == 1:
+            self._device_serial = ready_devices[0]['serial']
+            self._multiple_devices = False
+            if self.verbose:
+                self.logger.info(f"[*] Using device: {self._device_serial}")
+            return
+
+        # Multiple devices - prefer emulators
+        self._multiple_devices = True
+        emulators = [d for d in ready_devices if d['type'] == 'emulator']
+        physical = [d for d in ready_devices if d['type'] == 'physical']
+
+        if emulators:
+            self._device_serial = emulators[0]['serial']
+            self.logger.info(
+                f"[*] Multiple devices connected. Auto-selected emulator: {self._device_serial}"
+            )
+            if physical:
+                self.logger.info(
+                    f"[*] Physical device(s) also connected: {', '.join(d['serial'] for d in physical)}"
+                )
+        elif physical:
+            # Only physical devices - select first but warn
+            self._device_serial = physical[0]['serial']
+            self.logger.warning(
+                f"[*] Multiple physical devices connected. Selected: {self._device_serial}. "
+                "Note: Physical devices require root for full functionality."
+            )
+
+    def _build_adb_command(self, args: List[str]) -> List[str]:
+        """
+        Build ADB command with device targeting if needed.
+
+        :param args: ADB command arguments (without 'adb' prefix)
+        :return: Complete command list including device targeting
+        """
+        cmd = ['adb']
+        if self._device_serial and self._multiple_devices:
+            cmd.extend(['-s', self._device_serial])
+        cmd.extend(args)
+        return cmd
+
+    def get_frida_device(self):
+        """
+        Get the Frida device object for the current target device.
+
+        :return: Frida Device object
+        :raises RuntimeError: If device cannot be found
+        """
+        if self.is_remote:
+            return frida.get_device_manager().add_remote_device(self.device_socket)
+
+        if self._device_serial:
+            try:
+                # Try to get device by ID (matches ADB serial for USB devices)
+                return frida.get_device(self._device_serial)
+            except frida.InvalidArgumentError:
+                # Fallback: enumerate and find by ID
+                for device in frida.enumerate_devices():
+                    if device.id == self._device_serial:
+                        return device
+                raise RuntimeError(f"Frida device '{self._device_serial}' not found")
+        else:
+            # Fallback to get_usb_device for single device scenario
+            return frida.get_usb_device()
+
+    # ==================== Frida Server Management ====================
+
     def run_frida_server(self, frida_server_path="/data/local/tmp/"):
         # Check if frida-server is already running
         if self.is_frida_server_running():
             if self.verbose:
                 self.logger.info("[*] frida-server is already running, skipping start")
             return True
-            
+
+        # Ensure root access is available
+        if not self.is_device_rooted():
+            self.logger.error("Cannot start frida-server: device is not rooted")
+            return False
+
         if frida_server_path is self.run_frida_server.__defaults__[0]:
-            cmd = self.frida_install_dst + "frida-server &"
+            frida_bin = self.frida_install_dst + "frida-server"
         else:
-            cmd = frida_server_path + "frida-server &"
-
-        if self.is_magisk_mode:
-            command = f"""adb shell "su -c 'sh -c \"{cmd}\"'" """
+            frida_bin = frida_server_path + "frida-server"
+
+        # Build the command based on root mode
+        if self.is_adb_root_mode:
+            # ADB root mode (LineageOS): run directly, adbd is already root
+            shell_cmd = f"{frida_bin} &"
+        elif self.is_magisk_mode:
+            # Magisk mode
+            shell_cmd = f"""su -c 'sh -c "{frida_bin} &"'"""
         else:
-            command = f"""adb shell "su 0 sh -c \\"{cmd}\\"\" """ 
+            # Traditional su mode
+            shell_cmd = f"""su 0 sh -c "{frida_bin} &" """
 
         try:
-            process = subprocess.Popen(command, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
+            adb_cmd = self._build_adb_command(['shell', shell_cmd])
+            process = subprocess.Popen(
+                adb_cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True
+            )
             # Give it a moment to start and potentially fail
             import time
             time.sleep(1)
-            
+
             # Check if process failed immediately
             if process.poll() is not None:
                 stdout, stderr = process.communicate()
-                if "Address already in use" in stderr.decode():
+                stderr_text = stderr.decode() if isinstance(stderr, bytes) else str(stderr or "")
+                if "Address already in use" in stderr_text:
                     self.logger.info("[*] frida-server is already running on the device")
                     return True
                 else:
-                    self.logger.error(f"Failed to start frida-server: {stderr.decode()}")
+                    self.logger.error(f"Failed to start frida-server: {stderr_text}")
                     return False
             else:
                 # Process is still running (background), which is expected for frida-server
@@ -129,40 +365,59 @@ class FridaManager():
             else:
                 self.logger.error("frida-server does not seem to be running after start command")
                 return False
-            
+
         except Exception as e:
             self.logger.error(f"Error starting frida-server: {e}")
             return False
 
 
-    def is_frida_server_running(self):
+    def is_frida_server_running(self) -> bool:
         """
-        Checks if on the connected device a frida server is running. 
-        The test is done by trying multiple methods to detect the frida-server process.
+        Checks if on the connected device a frida server is running.
+
+        This method first tries non-root commands, then falls back to root commands
+        if available. Safe to call on non-rooted devices (returns False).
 
         :return: True if a frida-server is running otherwise False.
         :rtype: bool
         """
-        # Try pidof first (most reliable if available)
-        result = self.run_adb_command_as_root("pidof frida-server")
-        if result.stdout.strip():
-            return True
-            
-        # Fallback to ps grep if pidof doesn't work
-        result = self.run_adb_command_as_root("ps | grep frida-server | grep -v grep")
-        if result.stdout.strip():
-            return True
-            
-        # Try alternative ps command format
-        result = self.run_adb_command_as_root("ps -A | grep frida-server | grep -v grep")
-        if result.stdout.strip():
-            return True
-            
-        return False
+        try:
+            # Method 1: Try pidof without root (works on some devices)
+            result = self._run_adb_shell_command("pidof frida-server")
+            if result.stdout.strip():
+                try:
+                    int(result.stdout.strip().split()[0])  # Validate it's a number
+                    return True
+                except (ValueError, IndexError):
+                    pass
+
+            # Method 2: Try ps -A without root
+            result = self._run_adb_shell_command("ps -A 2>/dev/null | grep frida-server | grep -v grep")
+            if result.stdout.strip():
+                return True
+
+            # Method 3: Try with root if available
+            if self.is_device_rooted():
+                result = self.run_adb_command_as_root("pidof frida-server")
+                if result.stdout.strip():
+                    return True
+
+                result = self.run_adb_command_as_root("ps | grep frida-server | grep -v grep")
+                if result.stdout.strip():
+                    return True
+
+            return False
+
+        except Exception as e:
+            self.logger.debug(f"Error checking frida-server status: {e}")
+            return False
 
 
     def stop_frida_server(self):
-        self.run_adb_command_as_root("/system/bin/killall frida-server")
+        if self.is_device_rooted():
+            self.run_adb_command_as_root("/system/bin/killall frida-server")
+        else:
+            self.logger.warning("Cannot stop frida-server: device not rooted")
 
 
     def remove_frida_server(self, frida_server_path="/data/local/tmp/"):
@@ -170,22 +425,22 @@ class FridaManager():
             cmd = self.frida_install_dst + "frida-server"
         else:
             cmd = frida_server_path + "frida-server"
-        
+
         self.stop_frida_server()
         self._adb_remove_file_if_exist(cmd)
 
 
     def install_frida_server(self, dst_dir="/data/local/tmp/", version="latest"):
         """
-        Install the frida server binary on the Android device. 
+        Install the frida server binary on the Android device.
         This includes downloading the frida-server, decompress it and pushing it to the Android device.
         By default it is pushed into the /data/local/tmp/ directory.
         Further the binary will be set to executable in order to run it.
 
-        :param dst_dir: The destination folder where the frida-server binary should be installed (pushed). 
-        :type number: string
+        :param dst_dir: The destination folder where the frida-server binary should be installed (pushed).
+        :type dst_dir: string
         :param version: The version. By default the latest version will be used.
-        :type number: string
+        :type version: string
 
         """
         if dst_dir is self.install_frida_server.__defaults__[0]:
@@ -214,9 +469,9 @@ class FridaManager():
         If you want to download a specific version you have to provide it trough the version parameter.
 
         :param path: The path where the compressed frida-server should be downloded.
-        :type number: string
+        :type path: string
         :param version: The version. By default the latest version will be used.
-        :type number: string
+        :type version: string
 
         :return: The location of the downloaded frida server in its compressed form.
         :rtype: string
@@ -278,13 +533,13 @@ class FridaManager():
 
         if version == "latest":
             url = "https://api.github.com/repos/frida/frida/releases/"+version
-        
+
             try:
                 res = requests.get(url)
             except requests.exceptions.RequestException as e:
                 self.logger.error(f"Error making request to {url}: {e}")
                 raise RuntimeError(f"Failed to fetch Frida release information: {e}")
-            
+
             with warnings.catch_warnings():
                 warnings.simplefilter("ignore", SyntaxWarning)
                 try:
@@ -315,83 +570,214 @@ class FridaManager():
                 self.logger.info(f"[*] making frida-server executable: {final_cmd}")
 
         self.run_adb_command_as_root(f"chmod +x {cmd}")
- 
 
 
-    ### some functions to work with adb ### 
 
+    ### some functions to work with adb ###
+
+    def _run_adb_shell_command(self, command: str) -> subprocess.CompletedProcess:
+        """
+        Run an ADB shell command (without root) on the target device.
+
+        :param command: Shell command to run
+        :return: subprocess.CompletedProcess with stdout/stderr
+        """
+        adb_cmd = self._build_adb_command(['shell', command])
+        return subprocess.run(adb_cmd, capture_output=True, text=True)
+
+    def run_adb_command_as_root(self, command: str) -> subprocess.CompletedProcess:
+        """
+        Run an ADB command as root on the target device.
+
+        Supports three root modes:
+        1. ADB root mode (LineageOS): Commands run directly (adbd is root)
+        2. Magisk mode: Uses 'su -c command'
+        3. Traditional su: Uses 'su 0 command'
 
-    def run_adb_command_as_root(self,command):
-        if self.adb_check_root() == False:
-            self.logger.error("Device is not rooted. Please root it before using FridaAndroidManager and ensure that you are able to run commands with the su-binary.")
+        :param command: Command to run as root
+        :return: subprocess.CompletedProcess with stdout/stderr
+        :raises RuntimeError: If device is not rooted
+        """
+        if not self.is_device_rooted():
+            self.logger.error("Device is not rooted. Please root it before using FridaAndroidManager and ensure that you are able to run commands with the su-binary or enable ADB root mode.")
             raise RuntimeError("Device not rooted or su binary not accessible")
 
-        if self.is_magisk_mode:
-            output = subprocess.run(['adb', 'shell','su -c '+command], capture_output=True, text=True)
+        if self.is_adb_root_mode:
+            # ADB root mode (LineageOS): adbd runs as root, no su needed
+            adb_cmd = self._build_adb_command(['shell', command])
+        elif self.is_magisk_mode:
+            # Magisk mode: use su -c
+            adb_cmd = self._build_adb_command(['shell', f'su -c {command}'])
         else:
-            output = subprocess.run(['adb', 'shell','su 0 '+command], capture_output=True, text=True)
+            # Traditional su mode
+            adb_cmd = self._build_adb_command(['shell', f'su 0 {command}'])
 
-        return output
+        return subprocess.run(adb_cmd, capture_output=True, text=True)
 
 
-    def _adb_push_file(self,file,dst):
-        output = subprocess.run(['adb', 'push',file,dst], capture_output=True, text=True)
-        return output
+    def _adb_push_file(self, file: str, dst: str) -> subprocess.CompletedProcess:
+        """Push a file to the device."""
+        adb_cmd = self._build_adb_command(['push', file, dst])
+        return subprocess.run(adb_cmd, capture_output=True, text=True)
+
+
+    def _adb_pull_file(self, src_file: str, dst: str) -> subprocess.CompletedProcess:
+        """Pull a file from the device."""
+        adb_cmd = self._build_adb_command(['pull', src_file, dst])
+        return subprocess.run(adb_cmd, capture_output=True, text=True)
+
+
+    def _get_android_device_arch(self) -> str:
+        """Get the architecture of the target Android device."""
+        try:
+            device = self.get_frida_device()
+            return device.query_system_parameters()['arch']
+        except Exception as e:
+            self.logger.warning(f"Failed to get arch via Frida, falling back to ADB: {e}")
+            # Fallback to ADB
+            result = self._run_adb_shell_command("getprop ro.product.cpu.abi")
+            abi = result.stdout.strip()
+            # Map ABI to Frida arch
+            if 'arm64' in abi or 'aarch64' in abi:
+                return 'arm64'
+            elif 'armeabi' in abi or 'arm' in abi:
+                return 'arm'
+            elif 'x86_64' in abi:
+                return 'x64'
+            elif 'x86' in abi:
+                return 'ia32'
+            return 'arm64'  # Default
 
-    
-    def _adb_pull_file(self,src_file,dst):
-        output = subprocess.run(['adb', 'pull',src_file,dst], capture_output=True, text=True)
-        return output
-    
 
-    def _get_android_device_arch(self):
-        if self.is_remote:
-            frida_usb_json_data = frida.get_remote_device().query_system_parameters() 
-        else:
-            frida_usb_json_data = frida.get_usb_device().query_system_parameters()
-        return frida_usb_json_data['arch']
-    
-    
     def _adb_make_binary_executable(self, path):
         output = self.run_adb_command_as_root("chmod +x "+path)
 
 
-    def _adb_does_file_exist(self,path):
-        output = self.run_adb_command_as_root("ls "+path)
-        if len(output.stderr) > 1:
-            return False
+    def _adb_does_file_exist(self, path: str) -> bool:
+        """Check if a file exists on the device."""
+        if self.is_device_rooted():
+            output = self.run_adb_command_as_root("ls " + path)
+            return len(output.stderr) <= 1
         else:
-            return True
-          
+            output = self._run_adb_shell_command(f"ls {path} 2>/dev/null")
+            return len(output.stderr) <= 1 and output.stdout.strip()
 
 
-    def adb_check_root(self):
-        if bool(subprocess.run(['adb', 'shell','su -v'], capture_output=True, text=True).stdout):
-            self.is_magisk_mode = True
-            return True
+    def is_device_rooted(self) -> bool:
+        """
+        Check if the target device has root access.
+        Caches result after first check.
+
+        :return: True if device is rooted, False otherwise
+        """
+        if self._is_rooted is not None:
+            return self._is_rooted
 
-        return bool(subprocess.run(['adb', 'shell','su 0 id -u'], capture_output=True, text=True).stdout)
+        self._is_rooted = self.adb_check_root()
+        return self._is_rooted
+
+    def adb_check_root(self) -> bool:
+        """
+        Check if the device has root access.
+
+        Supports three root modes:
+        1. ADB root mode (LineageOS): adbd runs as root, no su needed
+        2. Magisk mode: su -c command
+        3. Traditional su: su 0 command
+
+        :return: True if root is available, False otherwise
+        """
+        try:
+            # First, check for ADB root mode (LineageOS with "adb root" enabled)
+            # In this mode, adbd runs as root and all shell commands are root
+            result = subprocess.run(
+                self._build_adb_command(['shell', 'id', '-u']),
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.stdout.strip() == "0":
+                # Shell is already running as root (adb root mode)
+                self.is_adb_root_mode = True
+                self.is_magisk_mode = False
+                if self.verbose:
+                    self.logger.info("[*] Detected ADB root mode (adbd running as root)")
+                return True
+
+            # Try Magisk-style su
+            result = subprocess.run(
+                self._build_adb_command(['shell', 'su -v']),
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.stdout.strip():
+                self.is_magisk_mode = True
+                self.is_adb_root_mode = False
+                if self.verbose:
+                    self.logger.info("[*] Detected Magisk root mode")
+                return True
+
+            # Try traditional su
+            result = subprocess.run(
+                self._build_adb_command(['shell', 'su 0 id -u']),
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.stdout.strip() == "0":
+                self.is_magisk_mode = False
+                self.is_adb_root_mode = False
+                if self.verbose:
+                    self.logger.info("[*] Detected traditional su root mode")
+                return True
+
+            return False
+
+        except subprocess.TimeoutExpired:
+            self.logger.debug("Root check timed out")
+            return False
+        except Exception as e:
+            self.logger.debug(f"Root check failed: {e}")
+            return False
 
 
     def _adb_remove_file_if_exist(self, path="/data/local/tmp/frida-server"):
         if self._adb_does_file_exist(path):
-            output = self.run_adb_command_as_root("rm "+path)
+            if self.is_device_rooted():
+                self.run_adb_command_as_root("rm " + path)
+            else:
+                self._run_adb_shell_command(f"rm {path}")
 
 
 def main():
     if len(sys.argv) > 1:
         parser = argparse.ArgumentParser(description='FridaManager initialization parameters.')
-        
+
         parser.add_argument('--is_remote', type=lambda x: (str(x).lower() == 'true'), default=False, help='Whether to use Frida in remote mode. Default is False.')
         parser.add_argument('--socket', type=str, default="", help='Socket to use for the connection. Expected in the format <ip:port>.')
         parser.add_argument('--verbose', required=False, action="store_const", const=True, default=False, help='Enable verbose output. Default is False.')
         parser.add_argument('--frida_install_dst', type=str, default="/data/local/tmp/", help='Frida installation destination. Default is "/data/local/tmp/".')
         parser.add_argument('-r','--is_running', required=False, action="store_const", const=True, default=False, help='Checks only if frida-server is running on the Android device or not.')
+        parser.add_argument('-d', '--device', type=str, default=None, help='Target device serial (e.g., emulator-5554). Auto-selects if not specified.')
+        parser.add_argument('-l', '--list-devices', required=False, action="store_const", const=True, default=False, help='List all connected devices and exit.')
 
         args = parser.parse_args()
 
+        # List devices mode
+        if args.list_devices:
+            devices = FridaManager.get_connected_devices()
+            if not devices:
+                print("No devices connected")
+            else:
+                print(f"{'Serial':<20} {'Type':<10} {'State':<12} {'Model'}")
+                print("-" * 60)
+                for d in devices:
+                    print(f"{d['serial']:<20} {d['type']:<10} {d['state']:<12} {d['model']}")
+            sys.exit(0)
+
         if args.is_running:
-            afm_obj = FridaManager()
+            afm_obj = FridaManager(device_serial=args.device)
             if afm_obj.is_frida_server_running():
                 afm_obj.logger.info("[*] frida-server is running on Android device")
             else:
@@ -401,7 +787,7 @@ def main():
 
 
 
-        afm_obj = FridaManager(args.is_remote, args.socket, args.verbose, args.frida_install_dst)
+        afm_obj = FridaManager(args.is_remote, args.socket, args.verbose, args.frida_install_dst, device_serial=args.device)
     else:
         afm_obj = FridaManager()
 
@@ -416,4 +802,3 @@ def main():
 
 if __name__ == "__main__":
     main()
-

AndroidFridaManager/about.py

@@ -2,4 +2,4 @@
 # -*- coding: utf-8 -*-
 
 __author__ = "Daniel Baier"
-__version__ = "1.9.0"
+__version__ = "1.9.2"

AndroidFridaManager/job_manager.py

@@ -4,21 +4,24 @@
 import atexit
 import subprocess
 import frida
-from typing import Optional, Dict, Union
+from typing import Optional, Dict, Union, List
 from .job import Job, FridaBasedException
 import time
 import re
 import logging
 
 class JobManager(object):
-    """  A class representing the current Job manager. """
+    """  A class representing the current Job manager with multi-device support. """
 
 
-    def __init__(self,host="", enable_spawn_gating=False) -> None:
+    def __init__(self, host="", enable_spawn_gating=False, device_serial: Optional[str] = None) -> 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.
+            Init a new job manager with optional device targeting.
+
+            :param host: Remote host for Frida connection (ip:port format)
+            :param enable_spawn_gating: Enable spawn gating for child process tracking
+            :param device_serial: Specific device serial to target (e.g., 'emulator-5554').
+                                  If None, uses default device selection.
         """
 
         self.jobs = {}
@@ -34,6 +37,11 @@ class JobManager(object):
         self.init_last_job = False
         self.logger = logging.getLogger(__name__)
         self._ensure_logging_setup()
+
+        # Multi-device support
+        self._device_serial = device_serial
+        self._multiple_devices = self._check_multiple_devices()
+
         atexit.register(self.cleanup)
 
     def _ensure_logging_setup(self):
@@ -46,11 +54,53 @@ class JobManager(object):
             # Set up basic logging if no handlers exist
             root_logger.setLevel(logging.INFO)
             handler = logging.StreamHandler()
-            formatter = logging.Formatter('[%(asctime)s] [%(levelname)-4s] - %(message)s', 
+            formatter = logging.Formatter('[%(asctime)s] [%(levelname)-4s] - %(message)s',
                                         datefmt='%d-%m-%y %H:%M:%S')
             handler.setFormatter(formatter)
             root_logger.addHandler(handler)
 
+    def _check_multiple_devices(self) -> bool:
+        """Check if multiple devices are connected."""
+        try:
+            result = subprocess.run(
+                ['adb', 'devices'],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            # Count device lines (skip header)
+            device_count = sum(
+                1 for line in result.stdout.strip().split('\n')[1:]
+                if line.strip() and '\tdevice' in line
+            )
+            return device_count > 1
+        except Exception:
+            return False
+
+    def _build_adb_command(self, args: List[str]) -> List[str]:
+        """
+        Build ADB command with device targeting if needed.
+
+        :param args: ADB command arguments (without 'adb' prefix)
+        :return: Complete command list including device targeting
+        """
+        cmd = ['adb']
+        if self._device_serial and self._multiple_devices:
+            cmd.extend(['-s', self._device_serial])
+        cmd.extend(args)
+        return cmd
+
+    @property
+    def device_serial(self) -> Optional[str]:
+        """Get the current target device serial."""
+        return self._device_serial
+
+    @device_serial.setter
+    def device_serial(self, serial: str) -> None:
+        """Set the target device serial."""
+        self._device_serial = serial
+        self._multiple_devices = self._check_multiple_devices()
+
     def cleanup(self) -> None:
         """
             Clean up all of the job in the job manager.
@@ -65,7 +115,7 @@ class JobManager(object):
             self.stop_jobs()
 
         print("\n[*] Have a nice day!")
-    
+
 
     def job_list(self):
         return list(self.jobs.keys())
@@ -103,8 +153,8 @@ class JobManager(object):
         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}']
-            
+            cmd = self._build_adb_command(['shell', 'am', 'start', '-n', f'{package_name}/{main_activity}'])
+
             # Add extras if provided
             if extras:
                 for key, value in extras.items():
@@ -114,11 +164,11 @@ class JobManager(object):
                         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']
-        
+            cmd = self._build_adb_command(['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:
@@ -128,7 +178,7 @@ class JobManager(object):
                 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_cmd = self._build_adb_command(['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])
@@ -156,14 +206,13 @@ class JobManager(object):
             self.logger.info(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:  
+        try:
             if should_spawn:
                 self.pid = self.spawn(target_process)
             else:
@@ -172,8 +221,8 @@ class JobManager(object):
             raise FridaBasedException(f"TimeOutError: {te}")
         except frida.ProcessNotFoundError as pe:
             raise FridaBasedException(f"ProcessNotFoundError: {pe}")
-        
-    
+
+
     def init_job(self,frida_script_name, custom_hooking_handler_name):
         try:
             if self.process_session:
@@ -211,7 +260,7 @@ class JobManager(object):
         except Exception as fe:
             raise FridaBasedException(f"Frida-Error: {fe}")
 
-        
+
     def start_job(self,frida_script_name, custom_hooking_handler_name):
         try:
             if self.process_session:
@@ -226,12 +275,12 @@ class JobManager(object):
                     if self.pid != -1:
                         self.device.resume(self.pid)
                         time.sleep(1) # without it Java.perform silently fails
-                
+
                 return job
 
             else:
                 self.logger.error("[-] no frida session. Aborting...")
-            
+
 
         except frida.TransportError as fe:
             raise FridaBasedException(f"Problems while attaching to frida-server: {fe}")
@@ -245,7 +294,7 @@ class JobManager(object):
             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:
@@ -255,8 +304,8 @@ class JobManager(object):
             except frida.InvalidOperationError:
                 self.logger.error('[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]
@@ -282,13 +331,14 @@ class JobManager(object):
 
 
     def stop_app(self, app_package):
-        subprocess.run(["adb", "shell", "am", "force-stop", app_package])
+        cmd = self._build_adb_command(["shell", "am", "force-stop", app_package])
+        subprocess.run(cmd)
 
 
     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):
@@ -296,21 +346,44 @@ class JobManager(object):
         for job_id in jobs_to_stop:
             self.logger.info(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])
+        cmd = self._build_adb_command(["shell", "am", "force-stop", app_package])
+        subprocess.run(cmd)
 
 
     def kill_app(self, pid):
-        subprocess.run(["adb", "shell", "kill", str(pid)])
+        cmd = self._build_adb_command(["shell", "kill", str(pid)])
+        subprocess.run(cmd)
 
-    
-    def setup_frida_handler(self,host="", enable_spawn_gating=False):
+
+    def setup_frida_handler(self, host="", enable_spawn_gating=False):
+        """
+        Setup the Frida device handler with multi-device support.
+
+        :param host: Remote host for Frida connection
+        :param enable_spawn_gating: Enable spawn gating
+        :return: Frida Device object
+        """
         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
+                # Remote device connection
                 device = frida.get_device_manager().add_remote_device(host)
+            elif self._device_serial:
+                # Multi-device: Get specific device by serial
+                try:
+                    device = frida.get_device(self._device_serial)
+                except frida.InvalidArgumentError:
+                    # Fallback: enumerate and find by ID
+                    device = None
+                    for d in frida.enumerate_devices():
+                        if d.id == self._device_serial:
+                            device = d
+                            break
+                    if device is None:
+                        raise FridaBasedException(f"Frida device '{self._device_serial}' not found")
             else:
+                # Single device: Use USB device
                 device = frida.get_usb_device()
 
             # to handle forks
@@ -320,7 +393,7 @@ class JobManager(object):
                     self.first_instrumenation_script(device.attach(child.pid))
                 device.resume(child.pid)
 
-            # if the target process is starting another process 
+            # if the target process is starting another process
             def on_spawn_added(spawn):
                 self.logger.info(f"Process spawned with pid {spawn.pid}. Name: {spawn.identifier}")
                 if callable(self.first_instrumenation_script):
@@ -331,7 +404,7 @@ class JobManager(object):
             if enable_spawn_gating:
                 device.enable_spawn_gating()
                 device.on("spawn_added", on_spawn_added)
-            
+
             return device
 
         except frida.InvalidArgumentError:

{androidfridamanager-1.9.0.dist-info → androidfridamanager-1.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AndroidFridaManager
-Version: 1.9.0
+Version: 1.9.2
 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
@@ -33,7 +33,7 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-![version](https://img.shields.io/badge/version-1.9.0-blue) [![PyPI version](https://badge.fury.io/py/AndroidFridaManager.svg)](https://badge.fury.io/py/AndroidFridaManager) [![Publish status](https://github.com/fkie-cad/friTap/actions/workflows/publish.yml/badge.svg?branch=main)](https://github.com/fkie-cad/AndroidFridaManager/actions/workflows/publish-to-pypi.yml)
+![version](https://img.shields.io/badge/version-1.9.2-blue) [![PyPI version](https://badge.fury.io/py/AndroidFridaManager.svg)](https://badge.fury.io/py/AndroidFridaManager) [![Publish status](https://github.com/fkie-cad/friTap/actions/workflows/publish.yml/badge.svg?branch=main)](https://github.com/fkie-cad/AndroidFridaManager/actions/workflows/publish-to-pypi.yml)
 
 # AndroidFridaManager
 

androidfridamanager-1.9.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+AndroidFridaManager/FridaManager.py,sha256=QonEFHpI5YTWWmHPrHGiUNuF-V0V_5qUC1GQ1yMx_Gg,31522
+AndroidFridaManager/__init__.py,sha256=T6AKtrGSLQ9M5bJoWDQcsRTJbSEbksdgrx3AAAdozRI,171
+AndroidFridaManager/about.py,sha256=eT4HT7KJGOEnLNu9eam06-A_1n_ZVYAexp02TRRRW6o,98
+AndroidFridaManager/job.py,sha256=1NNcfCjkyUtwUkMXSgT4uswA8UStHo3jxbeJwJoWhc8,3352
+AndroidFridaManager/job_manager.py,sha256=S3biHhYrk-DUUfrHA-g8vbOqwgl4FnWELrUjMxsFyG8,15983
+androidfridamanager-1.9.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+androidfridamanager-1.9.2.dist-info/METADATA,sha256=P8k6Nsb_aqnsh_cqzFixy2HiIpbs5tQ5LxmkzCfQvFQ,5141
+androidfridamanager-1.9.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+androidfridamanager-1.9.2.dist-info/entry_points.txt,sha256=GmNngu2fDNCxUcquFRegBa7GWknPKG1jsM4lvWeyKnY,64
+androidfridamanager-1.9.2.dist-info/top_level.txt,sha256=oH2lVMSRlghmt-_tVrOEUqvY462P9hd5Ktgp5-1qF3o,20
+androidfridamanager-1.9.2.dist-info/RECORD,,

androidfridamanager-1.9.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-AndroidFridaManager/FridaManager.py,sha256=h4B1TxYZyFU2TbQhbFXblEIAmG8lehiqDJmSeM1VrIA,16515
-AndroidFridaManager/__init__.py,sha256=T6AKtrGSLQ9M5bJoWDQcsRTJbSEbksdgrx3AAAdozRI,171
-AndroidFridaManager/about.py,sha256=AnyNW3Vf1B29iyCca75YikQoOslkmhci3b9IbRrWFrM,98
-AndroidFridaManager/job.py,sha256=1NNcfCjkyUtwUkMXSgT4uswA8UStHo3jxbeJwJoWhc8,3352
-AndroidFridaManager/job_manager.py,sha256=HUilXVNBEqdgY4LTlerK9XZpb0w7UgQBCq_bxpXwVVI,13253
-androidfridamanager-1.9.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-androidfridamanager-1.9.0.dist-info/METADATA,sha256=p4wEduWuT8dzPBG6rtjnDfpNbTBjLDuqgLd390elqAM,5141
-androidfridamanager-1.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-androidfridamanager-1.9.0.dist-info/entry_points.txt,sha256=GmNngu2fDNCxUcquFRegBa7GWknPKG1jsM4lvWeyKnY,64
-androidfridamanager-1.9.0.dist-info/top_level.txt,sha256=oH2lVMSRlghmt-_tVrOEUqvY462P9hd5Ktgp5-1qF3o,20
-androidfridamanager-1.9.0.dist-info/RECORD,,