apk-patchx 7.9.2025.1__py3-none-any.whl

apk_patchx/services/patch_smali.py

@@ -0,0 +1,145 @@
+"""Service for smali code patching."""
+
+import re
+from pathlib import Path
+from typing import List, Optional
+
+from ..exceptions import FridaPatchError
+
+
+class SmaliPatcher:
+    """Service for patching smali code."""
+
+    @staticmethod
+    def inject_load_library(smali_file: Path, library_name: str = "frida-gadget") -> bool:
+        """Inject System.loadLibrary call into smali file.
+
+        Returns:
+            bool: True if injection was successful, False otherwise.
+        """
+        if not smali_file.exists():
+            return False
+
+        try:
+            lines = smali_file.read_text().splitlines()
+            new_lines = []
+            injected = False
+            i = 0
+
+            while i < len(lines):
+                line = lines[i]
+                new_lines.append(line)
+
+                # Look for existing static constructor
+                if line.strip().startswith(".method static constructor"):
+                    injected = SmaliPatcher._inject_into_constructor(
+                        lines, new_lines, i, library_name
+                    )
+                    # Skip processed lines
+                    i = len([l for l in new_lines if l]) - 1
+                i += 1
+
+            if not injected:
+                # Create new static constructor
+                injected = SmaliPatcher._create_constructor(
+                    new_lines, library_name
+                )
+
+            if injected:
+                smali_file.write_text("\n".join(new_lines))
+                return True
+
+        except Exception as e:
+            raise FridaPatchError(f"Failed to patch smali file {smali_file}: {e}")
+
+        return False
+
+    @staticmethod
+    def _inject_into_constructor(lines: List[str], new_lines: List[str], 
+                               start_index: int, library_name: str) -> bool:
+        """Inject into existing static constructor."""
+        i = start_index + 1
+
+        # Find .locals line
+        while i < len(lines) and not lines[i].strip().startswith(".locals"):
+            new_lines.append(lines[i])
+            i += 1
+
+        if i >= len(lines):
+            return False
+
+        # Process .locals line
+        locals_line = lines[i]
+        new_lines.append(locals_line)
+
+        # Update locals count
+        match = re.search(r"\.locals (\d+)", locals_line)
+        if match:
+            locals_count = int(match.group(1)) + 1
+            new_lines[-1] = f"    .locals {locals_count}"
+
+        # Inject loadLibrary call
+        new_lines.extend([
+            "",
+            f'    const-string v0, "{library_name}"',
+            "    invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V",
+            ""
+        ])
+
+        # Add remaining lines
+        i += 1
+        while i < len(lines):
+            new_lines.append(lines[i])
+            i += 1
+
+        return True
+
+    @staticmethod
+    def _create_constructor(lines: List[str], library_name: str) -> bool:
+        """Create new static constructor."""
+        # Find insertion point (before first method or before .end class)
+        insert_index = -1
+
+        for i, line in enumerate(lines):
+            if (line.strip().startswith(".method") and 
+                not line.strip().startswith(".method static constructor")):
+                insert_index = i
+                break
+
+        if insert_index == -1:
+            # Insert before .end class
+            for i in range(len(lines) - 1, -1, -1):
+                if lines[i].strip() == ".end class":
+                    insert_index = i
+                    break
+
+        if insert_index != -1:
+            constructor_lines = [
+                "",
+                ".method static constructor <clinit>()V",
+                "    .locals 1",
+                "",
+                f'    const-string v0, "{library_name}"',
+                "    invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V",
+                "",
+                "    return-void",
+                ".end method",
+                ""
+            ]
+
+            lines[insert_index:insert_index] = constructor_lines
+            return True
+
+        return False
+
+    @staticmethod
+    def is_already_patched(smali_file: Path, library_name: str = "frida-gadget") -> bool:
+        """Check if smali file is already patched."""
+        if not smali_file.exists():
+            return False
+
+        try:
+            content = smali_file.read_text()
+            return f'"{library_name}"' in content and "loadLibrary" in content
+        except Exception:
+            return False

apk_patchx/services/signing.py

@@ -0,0 +1,106 @@
+"""APK signing service."""
+
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from ..exceptions import SigningError, ToolNotFoundError
+from ..utils.core import run_command, get_apkpatcher_home
+from .android_sdk import AndroidSDKService
+
+
+class SigningService:
+    """Service for APK signing operations."""
+
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self.sdk_service = AndroidSDKService(verbose=verbose)
+        self._keystore_path: Optional[Path] = None
+
+    @property
+    def keystore_path(self) -> Path:
+        """Get debug keystore path."""
+        if self._keystore_path is None:
+            keystore_path = get_apkpatcher_home() / "debug.keystore"
+            if not keystore_path.exists():
+                self._generate_debug_keystore(keystore_path)
+            self._keystore_path = keystore_path
+        return self._keystore_path
+
+    def _generate_debug_keystore(self, keystore_path: Path) -> None:
+        """Generate debug keystore."""
+        if self.verbose:
+            print("Generating debug keystore...")
+
+        cmd = [
+            "keytool", "-genkey", "-v",
+            "-keystore", str(keystore_path),
+            "-alias", "apkpatcher_debug",
+            "-keyalg", "RSA",
+            "-keysize", "2048",
+            "-validity", "10000",
+            "-storepass", "apkpatcher",
+            "-keypass", "apkpatcher",
+            "-dname", "CN=APKPatcher Debug, OU=Debug, O=APKPatcher, C=US",
+            "-noprompt"
+        ]
+
+        result = run_command(cmd)
+        if result.returncode != 0:
+            raise SigningError("Failed to generate debug keystore")
+
+    def sign_apk(self, apk_path: Path, output_path: Optional[Path] = None) -> Path:
+        """Sign APK file."""
+        if output_path is None:
+            output_path = apk_path.parent / f"{apk_path.stem}_signed.apk"
+
+        # First align the APK
+        aligned_path = self._zipalign_apk(apk_path)
+
+        # Then sign it
+        signed_path = self._apksigner_sign(aligned_path, output_path)
+
+        # Clean up aligned file if it's temporary
+        if aligned_path != apk_path:
+            aligned_path.unlink(missing_ok=True)
+
+        return signed_path
+
+    def _zipalign_apk(self, apk_path: Path) -> Path:
+        """Align APK using zipalign."""
+        zipalign = self.sdk_service.get_tool_path("zipalign")
+        aligned_path = apk_path.parent / f"{apk_path.stem}_aligned.apk"
+
+        cmd = [str(zipalign), "-p", "4", str(apk_path), str(aligned_path)]
+
+        if self.verbose:
+            print(f"Aligning {apk_path}...")
+
+        result = run_command(cmd)
+        if result.returncode != 0:
+            raise SigningError(f"Failed to align APK: {apk_path}")
+
+        return aligned_path
+
+    def _apksigner_sign(self, apk_path: Path, output_path: Path) -> Path:
+        """Sign APK using apksigner."""
+        apksigner = self.sdk_service.get_tool_path("apksigner")
+
+        cmd = [
+            str(apksigner), "sign",
+            "--ks", str(self.keystore_path),
+            "--ks-key-alias", "apkpatcher_debug",
+            "--ks-pass", "pass:apkpatcher",
+            "--key-pass", "pass:apkpatcher",
+            "--out", str(output_path),
+            str(apk_path)
+        ]
+
+        if self.verbose:
+            print(f"Signing {apk_path}...")
+
+        result = run_command(cmd)
+        if result.returncode != 0:
+            raise SigningError(f"Failed to sign APK: {apk_path}")
+
+        return output_path

apk_patchx/services/split_merge.py

@@ -0,0 +1,146 @@
+"""Service for handling split APK merging."""
+
+from pathlib import Path
+from typing import List
+
+from ..exceptions import BuildError, ValidationError
+from .apktool import ApktoolService
+from .signing import SigningService
+
+
+class SplitMergeService:
+    """Service for merging split APKs into single APK."""
+
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self.apktool_service = ApktoolService(verbose=verbose)
+        self.signing_service = SigningService(verbose=verbose)
+
+    def merge_split_apks(self, apk_paths: List[Path], net: bool = False) -> Path:
+        """Merge multiple split APKs into a single APK."""
+        if not apk_paths:
+            raise ValidationError("No APK paths provided")
+
+        if len(apk_paths) == 1:
+            # Single APK, just sign and return
+            return self.signing_service.sign_apk(apk_paths[0])
+
+        # Find base APK
+        base_apk = None
+        split_apks = []
+
+        for apk_path in apk_paths:
+            if apk_path.name == "base.apk":
+                base_apk = apk_path
+            else:
+                split_apks.append(apk_path)
+
+        if base_apk is None:
+            base_apk = apk_paths[0]  # Use first as base
+            split_apks = apk_paths[1:]
+
+        if self.verbose:
+            print(f"Merging {len(apk_paths)} split APKs...")
+
+        # Decode all APKs
+        base_dir = self.apktool_service.decode(base_apk, no_resources=False, no_sources=True)
+
+        split_dirs = []
+        for split_apk in split_apks:
+            split_dir = self.apktool_service.decode(
+                split_apk, 
+                no_resources=False, 
+                no_sources=True,
+                extra_args="--resource-mode dummy"
+            )
+            split_dirs.append(split_dir)
+
+        # Merge content from split APKs into base
+        self._merge_split_content(base_dir, split_dirs)
+
+        # Fix dummy resource identifiers
+        self._fix_dummy_resources(base_dir, split_dirs)
+
+        # Update manifest to disable APK splitting
+        self._disable_apk_splitting(base_dir)
+
+        # Build merged APK
+        output_path = base_apk.parent / "merged.apk"
+        built_path = self.apktool_service.build(base_dir, output_path, add_network_config=net)
+
+        # Sign merged APK
+        signed_path = self.signing_service.sign_apk(built_path)
+
+        if self.verbose:
+            print(f"Merged APK created: {signed_path}")
+
+        return signed_path
+
+    def _merge_split_content(self, base_dir: Path, split_dirs: List[Path]) -> None:
+        """Merge content from split directories into base directory."""
+        import shutil
+
+        for split_dir in split_dirs:
+            # Copy all directories except AndroidManifest.xml, apktool.yml, and original/
+            for item in split_dir.iterdir():
+                if item.name in ["AndroidManifest.xml", "apktool.yml", "original"]:
+                    continue
+
+                target = base_dir / item.name
+
+                if item.is_dir():
+                    if item.name == "res":
+                        # Special handling for res directory - only copy non-XML files
+                        self._merge_res_directory(item, target)
+                    else:
+                        # Copy entire directory
+                        if target.exists():
+                            shutil.rmtree(target)
+                        shutil.copytree(item, target)
+                else:
+                    # Copy file
+                    shutil.copy2(item, target)
+
+    def _merge_res_directory(self, source_res: Path, target_res: Path) -> None:
+        """Merge res directories, excluding XML files to avoid conflicts."""
+        import shutil
+
+        for item in source_res.rglob("*"):
+            if item.is_file() and not item.suffix == ".xml":
+                relative_path = item.relative_to(source_res)
+                target_file = target_res / relative_path
+
+                target_file.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(item, target_file)
+
+    def _fix_dummy_resources(self, base_dir: Path, split_dirs: List[Path]) -> None:
+        """Fix APKTOOL_DUMMY resource identifiers."""
+        # This is a simplified implementation
+        # In a full implementation, you would:
+        # 1. Find all DUMMY resource IDs in base/res/values/public.xml
+        # 2. Find the real names in split APK public.xml files
+        # 3. Replace all references to DUMMY names with real names
+
+        if self.verbose:
+            print("Fixing dummy resource identifiers...")
+
+        public_xml = base_dir / "res" / "values" / "public.xml"
+        if not public_xml.exists():
+            return
+
+        # Simple approach: remove DUMMY entries (they'll be regenerated)
+        try:
+            content = public_xml.read_text()
+            lines = content.splitlines()
+            filtered_lines = [line for line in lines if "APKTOOL_DUMMY_" not in line]
+            public_xml.write_text("\n".join(filtered_lines))
+        except Exception:
+            pass  # Continue without fixing if there's an issue
+
+    def _disable_apk_splitting(self, base_dir: Path) -> None:
+        """Disable APK splitting in AndroidManifest.xml."""
+        from ..utils.manifest import ManifestUtils
+
+        manifest_path = base_dir / "AndroidManifest.xml"
+        if manifest_path.exists():
+            ManifestUtils.disable_apk_splitting(manifest_path)

apk_patchx/utils/__init__.py

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

apk_patchx/utils/core.py

@@ -0,0 +1,77 @@
+"""Core utility functions for APKPatcher."""
+
+import logging
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+import requests
+from tqdm import tqdm
+
+from ..exceptions import NetworkError
+
+
+def setup_logging(verbose: bool = False) -> None:
+    """Setup logging configuration."""
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format='%(levelname)s: %(message)s'
+    )
+
+
+def get_apkpatcher_home() -> Path:
+    """Get APKPatcher home directory."""
+    return Path.home() / ".apkpatcher"
+
+
+def run_command(cmd, capture_output: bool = False, text: bool = True, **kwargs):
+    """Run command with proper error handling."""
+    try:
+        return subprocess.run(cmd, capture_output=capture_output, text=text, **kwargs)
+    except FileNotFoundError as e:
+        from ..exceptions import ToolNotFoundError
+        raise ToolNotFoundError(f"Command not found: {cmd[0]}")
+
+
+def download_file(url: str, output_path: Path, chunk_size: int = 8192) -> None:
+    """Download file with progress bar."""
+    try:
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+
+        total_size = int(response.headers.get('content-length', 0))
+
+        with open(output_path, 'wb') as f:
+            with tqdm(total=total_size, unit='B', unit_scale=True, desc=output_path.name) as pbar:
+                for chunk in response.iter_content(chunk_size=chunk_size):
+                    if chunk:
+                        f.write(chunk)
+                        pbar.update(len(chunk))
+
+    except requests.RequestException as e:
+        raise NetworkError(f"Failed to download {url}: {e}")
+    except Exception as e:
+        raise NetworkError(f"Download error: {e}")
+
+
+def is_java_available() -> bool:
+    """Check if Java is available."""
+    try:
+        result = subprocess.run(['java', '-version'], capture_output=True)
+        return result.returncode == 0
+    except FileNotFoundError:
+        return False
+
+
+def validate_package_name(package_name: str) -> bool:
+    """Validate Android package name format."""
+    import re
+    pattern = r'^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)+$'
+    return bool(re.match(pattern, package_name))
+
+
+def ensure_directory(path: Path) -> Path:
+    """Ensure directory exists and return path."""
+    path.mkdir(parents=True, exist_ok=True)
+    return path

apk_patchx/utils/manifest.py

@@ -0,0 +1,140 @@
+"""Android manifest manipulation utilities."""
+
+import re
+from pathlib import Path
+from typing import Optional
+import xml.etree.ElementTree as ET
+
+from ..exceptions import ValidationError
+
+
+class ManifestUtils:
+    """Utilities for AndroidManifest.xml manipulation."""
+
+    @staticmethod
+    def add_internet_permission(manifest_path: Path) -> None:
+        """Add INTERNET permission to manifest if not present."""
+        content = manifest_path.read_text()
+
+        if "android.permission.INTERNET" in content:
+            return  # Already present
+
+        # Find manifest tag and add permission
+        lines = content.splitlines()
+        manifest_found = False
+
+        for i, line in enumerate(lines):
+            if "<manifest" in line:
+                manifest_found = True
+            elif manifest_found and ("<application" in line or "<uses-" in line):
+                # Insert before application or other uses- tags
+                lines.insert(i, '    <uses-permission android:name="android.permission.INTERNET" />')
+                break
+        else:
+            # If no good insertion point found, add after manifest opening
+            for i, line in enumerate(lines):
+                if "<manifest" in line and ">" in line:
+                    lines.insert(i + 1, '    <uses-permission android:name="android.permission.INTERNET" />')
+                    break
+
+        manifest_path.write_text("\n".join(lines))
+
+    @staticmethod
+    def set_extract_native_libs(manifest_path: Path, extract: bool = True) -> None:
+        """Set android:extractNativeLibs attribute."""
+        content = manifest_path.read_text()
+
+        extract_value = "true" if extract else "false"
+
+        # Replace existing attribute or add it
+        if "android:extractNativeLibs" in content:
+            content = re.sub(
+                r'android:extractNativeLibs="[^"]*"',
+                f'android:extractNativeLibs="{extract_value}"',
+                content
+            )
+        else:
+            # Add to application tag
+            content = re.sub(
+                r'(<application[^>]*)',
+                rf'\1 android:extractNativeLibs="{extract_value}"',
+                content
+            )
+
+        manifest_path.write_text(content)
+
+    @staticmethod
+    def add_network_security_config(manifest_path: Path) -> None:
+        """Add network security config to application."""
+        content = manifest_path.read_text()
+
+        if "android:networkSecurityConfig" in content:
+            return  # Already present
+
+        # Add to application tag
+        content = re.sub(
+            r'(<application[^>]*)',
+            r'\1 android:networkSecurityConfig="@xml/network_security_config"',
+            content
+        )
+
+        manifest_path.write_text(content)
+
+    @staticmethod
+    def disable_apk_splitting(manifest_path: Path) -> None:
+        """Disable APK splitting in manifest."""
+        content = manifest_path.read_text()
+
+        # Set isSplitRequired to false
+        content = re.sub(
+            r'android:isSplitRequired="true"',
+            'android:isSplitRequired="false"',
+            content
+        )
+
+        # Set com.android.vending.splits.required to false
+        content = re.sub(
+            r'(<meta-data[^>]*android:name="com\.android\.vending\.splits\.required"[^>]*android:value=")[^"]*(")',
+            r'\1false\2',
+            content
+        )
+
+        manifest_path.write_text(content)
+
+    @staticmethod
+    def get_package_name(manifest_path: Path) -> Optional[str]:
+        """Extract package name from manifest."""
+        try:
+            content = manifest_path.read_text()
+            match = re.search(r'package="([^"]*)"', content)
+            return match.group(1) if match else None
+        except Exception:
+            return None
+
+    @staticmethod
+    def get_main_activity(manifest_path: Path) -> Optional[str]:
+        """Extract main activity name from manifest."""
+        try:
+            content = manifest_path.read_text()
+
+            # Look for activity with MAIN action and LAUNCHER category
+            pattern = (
+                r'<activity[^>]*android:name="([^"]*)"[^>]*>.*?'
+                r'<action android:name="android\.intent\.action\.MAIN".*?'
+                r'<category android:name="android\.intent\.category\.LAUNCHER"'
+            )
+            match = re.search(pattern, content, re.DOTALL)
+
+            if match:
+                activity_name = match.group(1)
+                if activity_name.startswith("."):
+                    # Relative name, prepend package
+                    package = ManifestUtils.get_package_name(manifest_path)
+                    if package:
+                        activity_name = package + activity_name
+                return activity_name
+
+        except Exception:
+            pass
+
+        return None

apk_patchx/utils/versions.py

@@ -0,0 +1,65 @@
+"""Version management utilities."""
+
+import requests
+from typing import Optional
+
+from ..exceptions import NetworkError
+
+
+def get_latest_github_release(owner: str, repo: str) -> str:
+    """Get the latest release version from GitHub."""
+    url = f"https://api.github.com/repos/{owner}/{repo}/releases/latest"
+
+    try:
+        response = requests.get(url, timeout=30)
+        response.raise_for_status()
+
+        data = response.json()
+        tag_name = data.get("tag_name", "")
+
+        # Remove 'v' prefix if present
+        if tag_name.startswith("v"):
+            tag_name = tag_name[1:]
+
+        return tag_name
+
+    except requests.RequestException as e:
+        raise NetworkError(f"Failed to get latest release for {owner}/{repo}: {e}")
+    except KeyError:
+        raise NetworkError(f"Invalid response format from GitHub API")
+
+
+def compare_versions(version1: str, version2: str) -> int:
+    """Compare two version strings.
+
+    Returns:
+        -1 if version1 < version2
+         0 if version1 == version2
+         1 if version1 > version2
+    """
+    def version_tuple(v):
+        return tuple(map(int, v.split('.')))
+
+    try:
+        v1_tuple = version_tuple(version1)
+        v2_tuple = version_tuple(version2)
+
+        if v1_tuple < v2_tuple:
+            return -1
+        elif v1_tuple > v2_tuple:
+            return 1
+        else:
+            return 0
+    except ValueError:
+        # If version parsing fails, do string comparison
+        if version1 < version2:
+            return -1
+        elif version1 > version2:
+            return 1
+        else:
+            return 0
+
+
+def is_version_newer(current: str, latest: str) -> bool:
+    """Check if latest version is newer than current."""
+    return compare_versions(current, latest) < 0