apk-patchx 7.9.2025.1__py3-none-any.whl

apk_patchx/__init__.py

@@ -0,0 +1,14 @@
+"""APKPatcher - Android APK manipulation toolkit."""
+
+__version__ = "7.9.2025.1"
+__author__ = "APKPatcher Contributors"
+__email__ = "contributors@apkpatcher.dev"
+__license__ = "MIT"
+
+from .exceptions import APKPatcherError, ToolNotFoundError, ValidationError
+
+__all__ = [
+    "APKPatcherError",
+    "ToolNotFoundError", 
+    "ValidationError"
+]

apk_patchx/cli.py

@@ -0,0 +1,273 @@
+"""Command-line interface for APKPatcher."""
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+import click
+import colorama
+from colorama import Fore, Style
+
+from . import __version__
+from .exceptions import APKPatcherError
+from .services.adb import ADBService
+from .services.apktool import ApktoolService
+from .services.frida import FridaService
+from .services.signing import SigningService
+from .utils.core import setup_logging, get_apkpatcher_home
+
+colorama.init(autoreset=True)
+
+
+def print_error(message: str) -> None:
+    """Print error message in red."""
+    click.echo(f"{Fore.RED}[!] {message}{Style.RESET_ALL}", err=True)
+
+
+def print_success(message: str) -> None:
+    """Print success message in green.""" 
+    click.echo(f"{Fore.GREEN}[+] {message}{Style.RESET_ALL}")
+
+
+def print_info(message: str) -> None:
+    """Print info message in blue."""
+    click.echo(f"{Fore.BLUE}[*] {message}{Style.RESET_ALL}")
+
+
+def print_warning(message: str) -> None:
+    """Print warning message in yellow."""
+    click.echo(f"{Fore.YELLOW}[!] {message}{Style.RESET_ALL}")
+
+
+@click.group(invoke_without_command=True)
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose output")
+@click.option("--version", is_flag=True, help="Show version and exit")
+@click.pass_context
+def cli(ctx: click.Context, verbose: bool, version: bool) -> None:
+    """APKPatcher - Android APK manipulation toolkit."""
+    if version:
+        click.echo(f"APKPatcher {__version__}")
+        sys.exit(0)
+
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+        sys.exit(0)
+
+    ctx.ensure_object(dict)
+    ctx.obj["verbose"] = verbose
+    setup_logging(verbose)
+
+    # Initialize APKPatcher home directory
+    home = get_apkpatcher_home()
+    home.mkdir(parents=True, exist_ok=True)
+
+    if verbose:
+        print_info(f"APKPatcher home: {home}")
+
+
+@cli.command()
+@click.argument("package_name")
+@click.option("--net", is_flag=True, help="Add permissive network security config")
+@click.pass_context
+def pull(ctx: click.Context, package_name: str, net: bool) -> None:
+    """Pull APK from connected device."""
+    try:
+        verbose = ctx.obj.get("verbose", False)
+        adb_service = ADBService(verbose=verbose)
+        apktool_service = ApktoolService(verbose=verbose)
+        signing_service = SigningService(verbose=verbose)
+
+        print_info(f"Pulling {package_name} from device...")
+        apk_paths = adb_service.pull_package(package_name)
+
+        if len(apk_paths) > 1:
+            from .services.split_merge import SplitMergeService
+            merge_service = SplitMergeService(verbose=verbose)
+            output_path = merge_service.merge_split_apks(apk_paths, net=net)
+            print_success(f"Merged split APKs to: {output_path}")
+        else:
+            print_success(f"Pulled APK to: {apk_paths[0]}")
+
+    except APKPatcherError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("apk_file", type=click.Path(exists=True, path_type=Path))
+@click.option("--no-res", "-r", is_flag=True, help="Do not decode resources")
+@click.option("--no-src", "-s", is_flag=True, help="Do not disassemble DEX")
+@click.option("--only-main-classes", is_flag=True, help="Only disassemble main DEX classes")
+@click.option("--apktool-decode-args", help="Additional apktool decode arguments")
+@click.pass_context
+def decode(ctx: click.Context, apk_file: Path, no_res: bool, no_src: bool, 
+          only_main_classes: bool, apktool_decode_args: Optional[str]) -> None:
+    """Decode APK file."""
+    try:
+        verbose = ctx.obj.get("verbose", False)
+        apktool_service = ApktoolService(verbose=verbose)
+
+        print_info(f"Decoding {apk_file}...")
+        output_dir = apktool_service.decode(
+            apk_file,
+            no_resources=no_res,
+            no_sources=no_src,
+            only_main_classes=only_main_classes,
+            extra_args=apktool_decode_args
+        )
+        print_success(f"Decoded to: {output_dir}")
+
+    except APKPatcherError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("apk_dir", type=click.Path(exists=True, path_type=Path))
+@click.option("-o", "--output", help="Output APK path", type=click.Path(path_type=Path))
+@click.option("--net", is_flag=True, help="Add permissive network security config")
+@click.option("--apktool-build-args", help="Additional apktool build arguments")
+@click.pass_context
+def build(ctx: click.Context, apk_dir: Path, output: Optional[Path], 
+         net: bool, apktool_build_args: Optional[str]) -> None:
+    """Build APK from decoded directory."""
+    try:
+        verbose = ctx.obj.get("verbose", False)
+        apktool_service = ApktoolService(verbose=verbose)
+        signing_service = SigningService(verbose=verbose)
+
+        if output is None:
+            output = apk_dir.with_suffix(".apk")
+
+        print_info(f"Building {apk_dir}...")
+        apk_path = apktool_service.build(
+            apk_dir,
+            output,
+            add_network_config=net,
+            extra_args=apktool_build_args
+        )
+
+        print_info("Signing APK...")
+        signed_path = signing_service.sign_apk(apk_path)
+        print_success(f"Built and signed: {signed_path}")
+
+    except APKPatcherError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("apk_file", type=click.Path(exists=True, path_type=Path))
+@click.option("--arch", "-a", required=True, 
+              type=click.Choice(["arm", "arm64", "x86", "x86_64"]),
+              help="Target architecture")
+@click.option("--gadget-conf", "-g", type=click.Path(exists=True, path_type=Path),
+              help="Frida gadget configuration file")
+@click.option("--net", is_flag=True, help="Add permissive network security config")
+@click.option("--no-src", "-s", is_flag=True, help="Do not disassemble DEX")
+@click.option("--only-main-classes", is_flag=True, help="Only disassemble main DEX classes")
+@click.option("--frida-version", help="Specific Frida version to use")
+@click.option("--apktool-decode-args", help="Additional apktool decode arguments")
+@click.option("--apktool-build-args", help="Additional apktool build arguments")
+@click.pass_context
+def patch(ctx: click.Context, apk_file: Path, arch: str, gadget_conf: Optional[Path],
+         net: bool, no_src: bool, only_main_classes: bool, frida_version: Optional[str],
+         apktool_decode_args: Optional[str], apktool_build_args: Optional[str]) -> None:
+    """Patch APK with Frida gadget."""
+    try:
+        verbose = ctx.obj.get("verbose", False)
+        frida_service = FridaService(verbose=verbose)
+
+        print_info(f"Patching {apk_file} with Frida gadget ({arch})...")
+        output_path = frida_service.patch_apk(
+            apk_file,
+            arch,
+            gadget_config=gadget_conf,
+            add_network_config=net,
+            no_sources=no_src,
+            only_main_classes=only_main_classes,
+            frida_version=frida_version,
+            decode_args=apktool_decode_args,
+            build_args=apktool_build_args
+        )
+        print_success(f"Patched APK: {output_path}")
+
+    except APKPatcherError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("apk_file", type=click.Path(exists=True, path_type=Path))
+@click.argument("new_package")
+@click.option("--net", is_flag=True, help="Add permissive network security config")
+@click.pass_context
+def rename(ctx: click.Context, apk_file: Path, new_package: str, net: bool) -> None:
+    """Rename APK package."""
+    try:
+        verbose = ctx.obj.get("verbose", False)
+        apktool_service = ApktoolService(verbose=verbose)
+        signing_service = SigningService(verbose=verbose)
+
+        print_info(f"Renaming {apk_file} to {new_package}...")
+
+        # Decode APK
+        decoded_dir = apktool_service.decode(apk_file, no_resources=False, no_sources=True)
+
+        # Update apktool.yml with new package name
+        apktool_yml = decoded_dir / "apktool.yml"
+        content = apktool_yml.read_text()
+
+        # Add or update renameManifestPackage
+        if "renameManifestPackage:" in content:
+            import re
+            content = re.sub(r"renameManifestPackage:.*", f"renameManifestPackage: {new_package}", content)
+        else:
+            content += f"\nrenameManifestPackage: {new_package}\n"
+
+        apktool_yml.write_text(content)
+
+        # Build and sign
+        output_path = apk_file.parent / f"{apk_file.stem}.renamed.apk"
+        built_path = apktool_service.build(decoded_dir, output_path, add_network_config=net)
+        signed_path = signing_service.sign_apk(built_path)
+
+        print_success(f"Renamed APK: {signed_path}")
+
+    except APKPatcherError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("apk_file", type=click.Path(exists=True, path_type=Path))
+@click.pass_context
+def sign(ctx: click.Context, apk_file: Path) -> None:
+    """Sign APK file."""
+    try:
+        verbose = ctx.obj.get("verbose", False)
+        signing_service = SigningService(verbose=verbose)
+
+        print_info(f"Signing {apk_file}...")
+        signed_path = signing_service.sign_apk(apk_file)
+        print_success(f"Signed APK: {signed_path}")
+
+    except APKPatcherError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+def main() -> None:
+    """Entry point for the CLI."""
+    try:
+        cli()
+    except KeyboardInterrupt:
+        print_error("Operation cancelled by user")
+        sys.exit(1)
+    except Exception as e:
+        print_error(f"Unexpected error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

apk_patchx/exceptions.py

@@ -0,0 +1,41 @@
+"""Custom exceptions for APKPatcher."""
+
+
+class APKPatcherError(Exception):
+    """Base exception for APKPatcher."""
+    pass
+
+
+class ToolNotFoundError(APKPatcherError):
+    """Raised when a required tool is not found."""
+    pass
+
+
+class ValidationError(APKPatcherError):
+    """Raised when input validation fails.""" 
+    pass
+
+
+class BuildError(APKPatcherError):
+    """Raised when APK build operation fails."""
+    pass
+
+
+class SigningError(APKPatcherError):
+    """Raised when APK signing fails."""
+    pass
+
+
+class ADBError(APKPatcherError):
+    """Raised when ADB operation fails."""
+    pass
+
+
+class FridaPatchError(APKPatcherError):
+    """Raised when Frida patching fails."""
+    pass
+
+
+class NetworkError(APKPatcherError):
+    """Raised when network operation fails."""
+    pass

apk_patchx/services/__init__.py

@@ -0,0 +1 @@
+"""Services package for APKPatcher."""

apk_patchx/services/adb.py

@@ -0,0 +1,98 @@
+"""ADB service for device operations."""
+
+import re
+import subprocess
+from pathlib import Path
+from typing import List, Optional
+
+from ..exceptions import ADBError, ToolNotFoundError
+from ..utils.core import run_command, get_apkpatcher_home
+from .android_sdk import AndroidSDKService
+
+
+class ADBService:
+    """Service for ADB operations."""
+
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self.sdk_service = AndroidSDKService(verbose=verbose)
+        self._adb_path: Optional[Path] = None
+
+    @property
+    def adb_path(self) -> Path:
+        """Get ADB executable path."""
+        if self._adb_path is None:
+            # First try system ADB
+            result = subprocess.run(["which", "adb"], capture_output=True, text=True)
+            if result.returncode == 0:
+                self._adb_path = Path(result.stdout.strip())
+            else:
+                # Use SDK ADB
+                self.sdk_service.ensure_platform_tools()
+                sdk_root = get_apkpatcher_home() / "tools" / "sdk"
+                self._adb_path = sdk_root / "platform-tools" / "adb"
+
+            if not self._adb_path.exists():
+                raise ToolNotFoundError("ADB not found and SDK installation failed")
+
+        return self._adb_path
+
+    def pull_package(self, package_name: str) -> List[Path]:
+        """Pull APK(s) for given package name."""
+        # Get package path(s)
+        cmd = [str(self.adb_path), "shell", "pm", "path", package_name]
+        result = run_command(cmd, capture_output=True, text=True)
+
+        if result.returncode != 0 or not result.stdout.strip():
+            raise ADBError(f"Package {package_name} not found on device")
+
+        package_paths = []
+        for line in result.stdout.strip().split("\n"):
+            if line.startswith("package:"):
+                package_paths.append(line.replace("package:", ""))
+
+        if not package_paths:
+            raise ADBError(f"No package paths found for {package_name}")
+
+        # Pull each APK
+        pulled_apks = []
+        if len(package_paths) > 1:
+            # Split APKs
+            split_dir = Path(f"{package_name}_split_apks")
+            split_dir.mkdir(exist_ok=True)
+
+            for i, package_path in enumerate(package_paths):
+                apk_name = f"split_{i}.apk" if i > 0 else "base.apk"
+                local_path = split_dir / apk_name
+
+                cmd = [str(self.adb_path), "pull", package_path, str(local_path)]
+                result = run_command(cmd)
+                if result.returncode != 0:
+                    raise ADBError(f"Failed to pull {package_path}")
+
+                pulled_apks.append(local_path)
+        else:
+            # Single APK
+            local_path = Path(f"{package_name}.apk")
+            cmd = [str(self.adb_path), "pull", package_paths[0], str(local_path)]
+            result = run_command(cmd)
+            if result.returncode != 0:
+                raise ADBError(f"Failed to pull {package_paths[0]}")
+
+            pulled_apks.append(local_path)
+
+        return pulled_apks
+
+    def is_device_connected(self) -> bool:
+        """Check if device is connected."""
+        try:
+            cmd = [str(self.adb_path), "devices"]
+            result = run_command(cmd, capture_output=True, text=True)
+
+            lines = result.stdout.strip().split("\n")[1:]  # Skip header
+            for line in lines:
+                if line.strip() and "\tdevice" in line:
+                    return True
+            return False
+        except Exception:
+            return False

apk_patchx/services/android_sdk.py

@@ -0,0 +1,145 @@
+"""Android SDK management service."""
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+from urllib.parse import urljoin
+
+from ..exceptions import NetworkError, ToolNotFoundError
+from ..utils.core import run_command, get_apkpatcher_home, download_file
+
+
+class AndroidSDKService:
+    """Service for managing Android SDK components."""
+
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self.sdk_root = get_apkpatcher_home() / "tools" / "sdk"
+        self.cmdline_tools_dir = get_apkpatcher_home() / "tools" / "cmdline-tools"
+
+    def ensure_java(self) -> None:
+        """Ensure Java is available."""
+        try:
+            result = subprocess.run(["java", "-version"], 
+                                  capture_output=True, text=True, check=False)
+            if result.returncode != 0:
+                raise ToolNotFoundError(
+                    "Java is required but not found. Please install Java 8 or later."
+                )
+        except FileNotFoundError:
+            raise ToolNotFoundError(
+                "Java is required but not found. Please install Java 8 or later."
+            )
+
+    def ensure_cmdline_tools(self) -> None:
+        """Ensure Android command line tools are installed."""
+        if (self.cmdline_tools_dir / "bin" / "sdkmanager").exists():
+            return
+
+        self.cmdline_tools_dir.mkdir(parents=True, exist_ok=True)
+
+        # Download command line tools
+        tools_url = "https://dl.google.com/android/repository/commandlinetools-linux-9123335_latest.zip"
+        zip_path = get_apkpatcher_home() / "tools" / "commandlinetools.zip"
+
+        if self.verbose:
+            print(f"Downloading Android command line tools...")
+
+        download_file(tools_url, zip_path)
+
+        # Extract
+        import zipfile
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(get_apkpatcher_home() / "tools")
+
+        zip_path.unlink()
+
+        if self.verbose:
+            print("Android command line tools installed")
+
+    def ensure_build_tools(self, version: str = "33.0.1") -> None:
+        """Ensure Android build tools are installed."""
+        build_tools_dir = self.sdk_root / "build-tools" / version
+        if build_tools_dir.exists():
+            return
+
+        self.ensure_cmdline_tools()
+        self.sdk_root.mkdir(parents=True, exist_ok=True)
+
+        sdkmanager = self.cmdline_tools_dir / "bin" / "sdkmanager"
+
+        if self.verbose:
+            print(f"Installing build-tools {version}...")
+
+        cmd = [
+            str(sdkmanager),
+            f"build-tools;{version}",
+            f"--sdk_root={self.sdk_root}"
+        ]
+
+        # Accept licenses automatically
+        process = subprocess.Popen(
+            cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE if not self.verbose else None,
+            stderr=subprocess.PIPE if not self.verbose else None,
+            text=True
+        )
+
+        # Send 'y' for license acceptance
+        stdout, stderr = process.communicate(input="y\n" * 10)
+
+        if process.returncode != 0:
+            raise ToolNotFoundError(f"Failed to install build-tools: {stderr}")
+
+        if self.verbose:
+            print(f"Build-tools {version} installed")
+
+    def ensure_platform_tools(self) -> None:
+        """Ensure Android platform tools are installed."""
+        platform_tools_dir = self.sdk_root / "platform-tools"
+        if platform_tools_dir.exists():
+            return
+
+        self.ensure_cmdline_tools()
+        self.sdk_root.mkdir(parents=True, exist_ok=True)
+
+        sdkmanager = self.cmdline_tools_dir / "bin" / "sdkmanager"
+
+        if self.verbose:
+            print("Installing platform-tools...")
+
+        cmd = [
+            str(sdkmanager),
+            "platform-tools",
+            f"--sdk_root={self.sdk_root}"
+        ]
+
+        # Accept licenses automatically
+        process = subprocess.Popen(
+            cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE if not self.verbose else None,
+            stderr=subprocess.PIPE if not self.verbose else None,
+            text=True
+        )
+
+        stdout, stderr = process.communicate(input="y\n" * 10)
+
+        if process.returncode != 0:
+            raise ToolNotFoundError(f"Failed to install platform-tools: {stderr}")
+
+        if self.verbose:
+            print("Platform-tools installed")
+
+    def get_tool_path(self, tool: str) -> Path:
+        """Get path to SDK tool."""
+        if tool in ["aapt", "aapt2", "zipalign", "apksigner"]:
+            self.ensure_build_tools()
+            return self.sdk_root / "build-tools" / "33.0.1" / tool
+        elif tool == "adb":
+            self.ensure_platform_tools()
+            return self.sdk_root / "platform-tools" / tool
+        else:
+            raise ValueError(f"Unknown tool: {tool}")