apk-patchx 7.9.2025.1__tar.gz

apk_patchx-7.9.2025.1/.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+.env
+.venv

apk_patchx-7.9.2025.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 APKPatcher Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

apk_patchx-7.9.2025.1/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: apk-patchx
+Version: 7.9.2025.1
+Summary: Android APK manipulation toolkit with Frida gadget injection support
+Keywords: android,apk,reverse-engineering,frida,patching
+Author: APKPatcher Contributors
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Software Distribution
+License-File: LICENSE
+Requires-Dist: click>=8.0.0
+Requires-Dist: requests>=2.25.0
+Requires-Dist: tqdm>=4.60.0
+Requires-Dist: colorama>=0.4.4
+Project-URL: Homepage, https://github.com/kaifcodec/apk-patchx
+Project-URL: Issues, https://github.com/kaifcodec/apk-patchx/issues
+Project-URL: Repository, https://github.com/kaifcodec/apk-patchx.git
+
+# APKPatcher
+
+A powerful command-line tool for Android APK manipulation, including Frida gadget injection, APK decoding/building, and package management.
+
+## Features
+
+- **APK Management**: Pull, decode, build, and sign APK files
+- **Frida Integration**: Inject Frida gadgets for runtime manipulation
+- **Split APK Support**: Automatically merge split APKs into single files
+- **Package Renaming**: Change APK package names
+- **Auto-bootstrap**: Automatically downloads and manages required tools
+
+## Installation
+
+```bash
+pip install apkpatcher
+```
+
+## Usage
+
+### Pull APK from device
+```bash
+apkpatcher pull com.example.app
+```
+
+### Decode APK
+```bash
+apkpatcher decode app.apk
+```
+
+### Build APK from source
+```bash
+apkpatcher build app_src/
+```
+
+### Patch APK with Frida gadget
+```bash
+apkpatcher patch app.apk --arch arm64
+```
+
+### Rename APK package
+```bash
+apkpatcher rename app.apk com.newpackage.name
+```
+
+### Sign APK
+```bash
+apkpatcher sign app.apk
+```
+
+## Architecture Support
+
+- ARM (`arm`)
+- ARM64 (`arm64`) 
+- x86 (`x86`)
+- x86_64 (`x86_64`)
+
+## Requirements
+
+- Python 3.8+
+- Java Runtime Environment (JRE 8+)
+- ADB (for device operations)
+
+## Tool Management
+
+APKPatcher automatically downloads and manages required tools in `~/.apkpatcher/tools/`:
+
+- apktool
+- Android SDK build-tools
+- Platform tools (adb)
+- dexpatch
+- Frida gadgets
+
+## License
+
+MIT License - see LICENSE file for details.
+

apk_patchx-7.9.2025.1/README.md

@@ -0,0 +1,76 @@
+# APKPatcher
+
+A powerful command-line tool for Android APK manipulation, including Frida gadget injection, APK decoding/building, and package management.
+
+## Features
+
+- **APK Management**: Pull, decode, build, and sign APK files
+- **Frida Integration**: Inject Frida gadgets for runtime manipulation
+- **Split APK Support**: Automatically merge split APKs into single files
+- **Package Renaming**: Change APK package names
+- **Auto-bootstrap**: Automatically downloads and manages required tools
+
+## Installation
+
+```bash
+pip install apkpatcher
+```
+
+## Usage
+
+### Pull APK from device
+```bash
+apkpatcher pull com.example.app
+```
+
+### Decode APK
+```bash
+apkpatcher decode app.apk
+```
+
+### Build APK from source
+```bash
+apkpatcher build app_src/
+```
+
+### Patch APK with Frida gadget
+```bash
+apkpatcher patch app.apk --arch arm64
+```
+
+### Rename APK package
+```bash
+apkpatcher rename app.apk com.newpackage.name
+```
+
+### Sign APK
+```bash
+apkpatcher sign app.apk
+```
+
+## Architecture Support
+
+- ARM (`arm`)
+- ARM64 (`arm64`) 
+- x86 (`x86`)
+- x86_64 (`x86_64`)
+
+## Requirements
+
+- Python 3.8+
+- Java Runtime Environment (JRE 8+)
+- ADB (for device operations)
+
+## Tool Management
+
+APKPatcher automatically downloads and manages required tools in `~/.apkpatcher/tools/`:
+
+- apktool
+- Android SDK build-tools
+- Platform tools (adb)
+- dexpatch
+- Frida gadgets
+
+## License
+
+MIT License - see LICENSE file for details.

apk_patchx-7.9.2025.1/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-7.9.2025.1/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-7.9.2025.1/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-7.9.2025.1/apk_patchx/services/__init__.py

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

apk_patchx-7.9.2025.1/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