stitch 0.0.21__tar.gz

stitch-0.0.21/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+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.

stitch-0.0.21/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: stitch
+Version: 0.0.21
+Author-email: Alon Schwartzblat <alon.ponch@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML
+Requires-Dist: androguard
+Dynamic: license-file
+
+# Stitch
+Stitch is a powerful APK patching python library that allows you to inject your own java module into any APK, bundle or XAPK file.
+
+## How it works
+
+Will be added soon.
+
+## Projects using Stitch:
+- [MakoPatcher][https://github.com/Schwartzblat/MakoPatcher]- A patcher for 12+ app.
+
+## How to use
+### Installation
+You can install Stitch using pip:
+```bash
+# For now, install the test version from TestPyPI
+pip install stitch
+```
+
+### Basic Usage
+Create an Android Gradle project like my smali_generator (Check it out in on of the examples) that generates the java module you want to inject.
+
+Then, use the following code to patch an APK:
+```python
+from stitch import Stitch
+
+with Stitch(
+        apk_path='./input.apk',
+        output_apk='./output.apk',
+        temp_path='./temp',
+        external_module='./smali_generator'
+) as stitch:
+    stitch.patch()
+```
+And that's it! Your APK will be patched with the injected module.
+
+## Contributing
+
+I will be happy if you want to contribute to this project. Feel free to open issues or submit pull requests.
+
+## Disclaimer
+
+For educational purpose only or something like that. I am not responsible for any misuse of this software.

stitch-0.0.21/README.md

@@ -0,0 +1,42 @@
+# Stitch
+Stitch is a powerful APK patching python library that allows you to inject your own java module into any APK, bundle or XAPK file.
+
+## How it works
+
+Will be added soon.
+
+## Projects using Stitch:
+- [MakoPatcher][https://github.com/Schwartzblat/MakoPatcher]- A patcher for 12+ app.
+
+## How to use
+### Installation
+You can install Stitch using pip:
+```bash
+# For now, install the test version from TestPyPI
+pip install stitch
+```
+
+### Basic Usage
+Create an Android Gradle project like my smali_generator (Check it out in on of the examples) that generates the java module you want to inject.
+
+Then, use the following code to patch an APK:
+```python
+from stitch import Stitch
+
+with Stitch(
+        apk_path='./input.apk',
+        output_apk='./output.apk',
+        temp_path='./temp',
+        external_module='./smali_generator'
+) as stitch:
+    stitch.patch()
+```
+And that's it! Your APK will be patched with the injected module.
+
+## Contributing
+
+I will be happy if you want to contribute to this project. Feel free to open issues or submit pull requests.
+
+## Disclaimer
+
+For educational purpose only or something like that. I am not responsible for any misuse of this software.

stitch-0.0.21/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "stitch"
+version = "0.0.21"
+description = ""
+authors = [
+    { name = "Alon Schwartzblat", email = "alon.ponch@gmail.com" },
+]
+requires-python = ">=3.11"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = [
+    "PyYAML",
+    "androguard"
+]
+[build-system]
+requires = ["setuptools>=81.0.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["bin/*.jar"]

stitch-0.0.21/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

stitch-0.0.21/src/stitch/__init__.py

@@ -0,0 +1 @@
+from stitch.stitch import Stitch

stitch-0.0.21/src/stitch/apk_utils.py

@@ -0,0 +1,125 @@
+import glob
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import typing
+import zipfile
+import yaml
+from stitch.common import APKTOOL_PATH, UBER_APK_SIGNER_PATH, EXTRACTED_PATH, BUNDLE_APK_EXTRACTED_PATH, BUNDLE_DIR_PATH
+
+main_apk_name = 'base.apk'
+
+
+def is_bundle(path: os.PathLike) -> bool:
+    with zipfile.ZipFile(path, 'r') as zip_file:
+        for file in zip_file.namelist():
+            if file.endswith('.apk'):
+                return True
+    return False
+
+
+def extract_apk(apk_path: os.PathLike, temp_path: Path, extracted_path: typing.Optional[Path] = None) -> None:
+    if str(apk_path).endswith('.xapk'):
+        global main_apk_name
+        with zipfile.ZipFile(apk_path, 'r') as zip_file:
+            apk_files = [file for file in zip_file.namelist() if file.endswith('.apk')]
+            if len(apk_files) == 0:
+                raise ValueError('No APK files found in the XAPK.')
+            main_apk_name = max(apk_files, key=lambda x: zip_file.getinfo(x).file_size)
+    if is_bundle(apk_path):
+        with zipfile.ZipFile(apk_path, 'r') as zip_file:
+            zip_file.extractall(temp_path / BUNDLE_APK_EXTRACTED_PATH)
+        os.makedirs(temp_path / BUNDLE_DIR_PATH, exist_ok=True)
+        for apk_file in glob.iglob(str(temp_path / BUNDLE_APK_EXTRACTED_PATH / '*.apk')):
+            if os.path.basename(apk_file) != main_apk_name:
+                shutil.copy(apk_file, temp_path / BUNDLE_DIR_PATH)
+        extract_apk(temp_path / BUNDLE_APK_EXTRACTED_PATH / main_apk_name, temp_path)
+        return
+    subprocess.check_call(
+        [
+            "java",
+            "-jar",
+            APKTOOL_PATH,
+            "d",
+            "-q",
+            "-r",
+            "--output",
+            extracted_path if extracted_path is not None else temp_path / EXTRACTED_PATH,
+            apk_path,
+        ],
+        timeout=20 * 60,
+    )
+
+
+def compile_apk(input_path: Path, output_path: Path) -> None:
+    yml_path = input_path / 'apktool.yml'
+    if yml_path.exists():
+        with open(yml_path, 'r') as file:
+            apktool_yml = yaml.safe_load(file)
+        if 'so' not in apktool_yml['doNotCompress']:
+            apktool_yml['doNotCompress'].append('so')
+        with open(yml_path, 'w') as file:
+            yaml.safe_dump(apktool_yml, file, default_flow_style=False, sort_keys=False)
+    for i in range(2):
+        try:
+            subprocess.check_call([
+                "java",
+                "-jar",
+                APKTOOL_PATH,
+                "build",
+                "-q",
+                str(input_path),
+                "--output",
+                str(output_path)
+            ], timeout=20 * 60
+            )
+            break
+        except Exception as e:
+            if i == 1:
+                raise e
+
+
+def sign_apk(bundle_dir: Path, apk_path: Path, output_path: Path, is_bundle_file: bool) -> None:
+    apk_files = [str(apk_path)]
+    for file in glob.glob(str(bundle_dir / '*.apk')):
+        apk_files.append(str(file))
+    for file in apk_files:
+        args = ["java", "-jar", UBER_APK_SIGNER_PATH]
+        if os.environ.get('KEYSTORE_PATH') is not None:
+            args.extend(["--ks", os.environ['KEYSTORE_PATH']])
+        if os.environ.get('KEY_ALIAS') is not None:
+            args.extend(["--ksAlias", os.environ['KEY_ALIAS']])
+        if os.environ.get('KEYSTORE_PASSWORD') is not None:
+            args.extend(["--ksPass", os.environ['KEYSTORE_PASSWORD']])
+        if os.environ.get('KEY_PASSWORD') is not None:
+            args.extend(["--ksKeyPass", os.environ['KEY_PASSWORD']])
+        args.extend(['--allowResign', '--apks', file])
+        subprocess.check_call(args, timeout=20 * 60)
+        os.remove(file)
+        if is_bundle_file:
+            os.rename(
+                f'{file.removesuffix(".apk")}-aligned-signed.apk',
+                f'{file.removesuffix(".apk")}.apk',
+            )
+        else:
+            os.rename(f'{str(apk_path).removesuffix(".apk")}-aligned-signed.apk', output_path)
+
+
+def _recursive_search_class(parent: Path, class_path: list) -> typing.Optional[Path]:
+    for child in parent.iterdir():
+        if len(class_path) == 1 and child.is_file() and child.name == f'{class_path[0]}.smali':
+            return child
+        elif child.is_dir() and child.name == class_path[0]:
+            return _recursive_search_class(child, class_path[1:])
+    return None
+
+
+def find_smali_file_by_class_name(parent: Path, class_name: str) -> typing.Optional[Path]:
+    for child in parent.iterdir():
+        if not child.is_dir() or not str(child.name).startswith('smali'):
+            continue
+        file_path = _recursive_search_class(child, class_name.split('.'))
+        if file_path:
+            return file_path
+    return None

stitch-0.0.21/src/stitch/artifactory_generator/SimpleArtifactoryFinder.py

@@ -0,0 +1,19 @@
+from abc import abstractmethod
+import re
+
+CLASS_NAME_RE = re.compile(r'\.class public.*L(?P<name>[\w/]+)')
+
+
+class SimpleArtifactoryFinder:
+    def __init__(self, args):
+        self.args = args
+        self.is_once = True
+        self.is_found = False
+
+    @abstractmethod
+    def class_filter(self, class_data: str) -> bool:
+        pass
+
+    @abstractmethod
+    def extract_artifacts(self, artifacts: dict, class_data: str) -> None:
+        pass

stitch-0.0.21/src/stitch/artifactory_generator/generate_artifactory.py

@@ -0,0 +1,26 @@
+"""
+This module supposed to be edited by the user to generate the artifactory for their project.
+"""
+import glob
+import os
+from pathlib import Path
+
+from stitch.common import EXTRACTED_PATH
+
+
+def generate_artifactory(temp_path: Path, artifacts_finders: list):
+    artifacts = dict()
+    for filename in glob.iglob(os.path.join(temp_path, EXTRACTED_PATH, "**", "*.smali"), recursive=True):
+        if len(artifacts_finders) == 0:
+            break
+        with open(filename, "r", encoding="utf8") as f:
+            data = f.read()
+        for artifact_finder in artifacts_finders:
+            if not artifact_finder.class_filter(data):
+                continue
+            artifact_finder.extract_artifacts(artifacts, data)
+            if artifact_finder.is_once and artifact_finder.is_found:
+                artifacts_finders.remove(artifact_finder)
+
+    print(f'[+] Found artifacts:\n{artifacts}')
+    return artifacts

stitch-0.0.21/src/stitch/common.py

@@ -0,0 +1,28 @@
+import dataclasses
+from pathlib import Path
+from importlib.resources import files
+import enum
+
+APKTOOL_PATH = files('stitch').joinpath('bin/apktool_2.12.1.jar')
+UBER_APK_SIGNER_PATH = files('stitch').joinpath('./bin/uber-apk-signer-1.2.1.jar')
+EXTRACTED_PATH = 'extracted'
+BUNDLE_DIR_PATH = 'bundle_apks'
+BUNDLE_APK_EXTRACTED_PATH = Path('bundle')
+SMALI_GENERATOR_TEMP_PATH = './smali_generator'
+SMALI_EXTRACTED_PATH = './smali_extracted'
+SMALI_GENERATOR_OUTPUT_PATH = './smali_generator.apk'
+ARTIFACTORY_PATH = Path('artifactory.json')
+
+
+class ManifestKeys(enum.StrEnum):
+    EXPORTED = '{http://schemas.android.com/apk/res/android}exported'
+    NAME = '{http://schemas.android.com/apk/res/android}name'
+    TARGET_ACTIVITY = '{http://schemas.android.com/apk/res/android}targetActivity'
+
+
+ANDROID_MANIFEST_RELEVANT_TAGS = ['activity', 'activity-alias', 'provider', 'receiver', 'service']
+
+@dataclasses.dataclass
+class ExternalModule:
+    module_path: Path
+    invoke_line: str

stitch-0.0.21/src/stitch/patcher.py

@@ -0,0 +1,158 @@
+import glob
+import os
+from pathlib import Path
+import re
+import shutil
+import subprocess
+from typing import Optional
+
+import lxml.etree
+from androguard.core.apk import APK
+from androguard.util import set_log
+from androguard.core.axml import ARSCParser
+from stitch.apk_utils import find_smali_file_by_class_name, extract_apk, is_bundle
+from stitch.common import ManifestKeys, SMALI_GENERATOR_TEMP_PATH, SMALI_GENERATOR_OUTPUT_PATH, \
+    SMALI_EXTRACTED_PATH, \
+    BUNDLE_APK_EXTRACTED_PATH, EXTRACTED_PATH
+
+set_log('CRITICAL')
+INVOKE_LINE = '\n\tinvoke-static {}, Lcom/smali_generator/TheAmazingPatch;->on_load()V\n\t'
+
+
+def patch_artifacts(artifactory: dict, smali_generator_temp_path: Path) -> None:
+    for file in glob.iglob(str(smali_generator_temp_path / '**' / '**'), recursive=True, include_hidden=True):
+        if os.path.isdir(file):
+            continue
+        with open(file, 'rb') as f:
+            old_data = f.read()
+        data = old_data
+        for key, value in artifactory.items():
+            data = data.replace(f'{{{{{key}}}}}'.encode(), value.encode())
+        if data != old_data:
+            with open(file, 'wb') as f:
+                f.write(data)
+
+
+def prepare_smali(temp_path: Path, external_module: Path, artifactory: dict) -> None:
+    smali_generator_temp_path = temp_path / SMALI_GENERATOR_TEMP_PATH
+    print('[+] Copying the smali generator...')
+    shutil.copytree(external_module, smali_generator_temp_path)
+    print('[+] Patching the artifacts...')
+    patch_artifacts(artifactory, smali_generator_temp_path)
+    print('[+] Assembling the java...')
+    subprocess.check_call(['./gradlew', 'assembleRelease'], cwd=smali_generator_temp_path)
+    print('[+] Extracting the smali...')
+    extract_apk(smali_generator_temp_path / SMALI_GENERATOR_OUTPUT_PATH, temp_path,
+                smali_generator_temp_path / SMALI_EXTRACTED_PATH)
+
+
+def get_activities_with_entry_points(apk_path: Path) -> list:
+    manifest: lxml.etree.Element = APK(str(apk_path)).get_android_manifest_xml()
+    activities = []
+    for element in manifest.find('.//application').getchildren():
+        should_patch = False
+        if element.tag == 'activity' or element.tag == 'activity-alias':
+            should_patch = element.get(ManifestKeys.EXPORTED) == 'true'
+        elif element.tag == 'provider' or element.tag == 'receiver' or element.tag == 'service':
+            should_patch = True
+        if should_patch:
+            activities.append(element)
+    return activities
+
+
+def patch_or_add_function(smali_file_path: Path, function_name: str, invoke_line: str) -> None:
+    with open(smali_file_path, 'r') as file:
+        smali_file = file.read()
+    matches = re.findall(fr'\.method \w+ [^\n]*{function_name}[^\n]*\n[^\n]+', smali_file)
+    if len(matches) == 0:
+        pass
+    for match in matches:
+        smali_file = smali_file.replace(match, f'{match}\n\t{invoke_line}\n\t')
+    with open(smali_file_path, 'w') as file:
+        file.write(smali_file)
+
+
+def add_static_call_to_on_load(temp_path: Path, class_name: str, function_name: str, invoke_line: str) -> None:
+    smali_file_path = find_smali_file_by_class_name(temp_path / EXTRACTED_PATH, class_name)
+    if smali_file_path is None:
+        print(f'[-] Failed to find smali file for {class_name}')
+        return
+    patch_or_add_function(smali_file_path, function_name, invoke_line)
+
+
+def patch_entries(apk_path: Path, temp_path: Path, invoke_line: str) -> None:
+    from stitch.apk_utils import main_apk_name
+    print('[+] Searching for activities with entry points...')
+    activities_to_patch = get_activities_with_entry_points(
+        Path(temp_path) / BUNDLE_APK_EXTRACTED_PATH / main_apk_name if is_bundle(
+            apk_path) else apk_path)
+    print(f'[+] Found {len(activities_to_patch)} activities with entry points')
+    for activity in activities_to_patch:
+        add_static_call_to_on_load(temp_path, activity.get(
+            ManifestKeys.TARGET_ACTIVITY if activity.tag == 'activity-alias' else ManifestKeys.NAME),
+            'onCreate' if 'activity' in activity.tag else '<init>', invoke_line)
+
+
+def patch_google_api_key(temp_path: Path, package_name: str, custom_google_api_key: str) -> None:
+    print('[+] Searching for google api key...')
+    resources_path = temp_path / EXTRACTED_PATH / 'resources.arsc'
+    resources = ARSCParser(resources_path.read_bytes())
+    _, original_google_api_key = resources.get_string(package_name, 'google_api_key')
+    print(f'[+] Original google api key: {original_google_api_key}')
+    with open(resources_path, 'rb') as file:
+        resources_data = file.read()
+    resources_data = resources_data.replace(original_google_api_key.encode(), custom_google_api_key.encode())
+    with open(resources_path, 'wb') as file:
+        file.write(resources_data)
+
+
+def get_new_smali_folder(smali_path: Path) -> Path:
+    smali_folders = [folder for folder in smali_path.iterdir() if
+                     folder.is_dir() and folder.name.startswith('smali_classes')]
+    if not smali_folders:
+        return smali_path / 'smali'
+    smali_folders.sort(key=lambda x: int(x.name.replace('smali_classes', '')))
+    smali_index = int(smali_folders[-1].name.replace('smali_classes', '')) + 1
+    (smali_path / f'smali_classes{smali_index}').mkdir()
+    return smali_path / f'smali_classes{smali_index}'
+
+
+def patch_apk(apk_path: Path, temp_path: Path, external_module: Path, artifactory: dict, arch: str,
+              api_key: Optional[str] = None) -> None:
+    print('[+] Preparing the smali...')
+    prepare_smali(temp_path, external_module, artifactory)
+
+    new_smali_folder = get_new_smali_folder(temp_path / EXTRACTED_PATH)
+
+    print(f'[+] Applying the custom smali into {new_smali_folder.name}...')
+    shutil.copytree(temp_path / SMALI_GENERATOR_TEMP_PATH / SMALI_EXTRACTED_PATH / 'smali',
+                    new_smali_folder,
+                    dirs_exist_ok=True)
+
+    smali_folders = [folder for folder in
+                     (temp_path / EXTRACTED_PATH).iterdir() if
+                     folder.is_dir() and (folder.name.startswith('smali_classes') or folder.name == 'smali')]
+    for folder in smali_folders:
+        # move every first folder within to the new smali folder
+        for file in folder.iterdir():
+            if not (new_smali_folder / file.name).exists():
+                shutil.move(file, new_smali_folder)
+                break
+
+    print('[+] Injecting the custom so...')
+    os.makedirs(temp_path / EXTRACTED_PATH / 'lib' / arch, exist_ok=True)
+    shutil.copytree(
+        temp_path / SMALI_GENERATOR_TEMP_PATH / SMALI_EXTRACTED_PATH / 'lib' / arch,
+        temp_path / EXTRACTED_PATH / 'lib' / arch,
+        dirs_exist_ok=True)
+    print('[+] Adding calls to the custom smali...')
+    patch_entries(apk_path, temp_path)
+
+    if api_key is not None:
+        print('[+] Patching google api key...')
+        if is_bundle(apk_path):
+            from stitch.apk_utils import main_apk_name
+            package_name = APK(str(temp_path / BUNDLE_APK_EXTRACTED_PATH / main_apk_name)).get_package()
+        else:
+            package_name = APK(str(apk_path)).get_package()
+        patch_google_api_key(temp_path, package_name, api_key)

stitch-0.0.21/src/stitch/stitch.py

@@ -0,0 +1,148 @@
+import json
+import os
+import shutil
+from pathlib import Path
+from typing import List
+
+from androguard.core.apk import APK
+from stitch.apk_utils import is_bundle
+from stitch.artifactory_generator.SimpleArtifactoryFinder import SimpleArtifactoryFinder
+from stitch.common import BUNDLE_APK_EXTRACTED_PATH
+
+from .apk_utils import compile_apk, sign_apk
+from .artifactory_generator.generate_artifactory import generate_artifactory
+from .common import SMALI_EXTRACTED_PATH, SMALI_GENERATOR_TEMP_PATH, EXTRACTED_PATH, ExternalModule
+from . import apk_utils
+from . import patcher
+
+
+class Stitch:
+    apk_path: Path
+    output_apk: Path
+    temp_path: Path
+    artifactory: Path
+    external_modules: List[ExternalModule]
+    arch: str
+    google_api_key: str
+    should_sign: bool
+    extra_artifacts: dict
+
+    def __init__(self, apk_path: str, output_apk: str = 'out.apk', temp_path: str = './temp',
+                 external_modules: List[ExternalModule] = None,
+                 arch: str = 'arm64-v8a', artifactory_list: List[SimpleArtifactoryFinder] = None,
+                 google_api_key: str = None, should_sign=True, extra_artifacts: dict = None):
+        if external_modules is None:
+            external_modules = [ExternalModule(
+                Path('./smali_generator'),
+                'invoke-static {}, Lcom/smali_generator/TheAmazingPatch;->on_load()V'
+            )]
+        self.apk_path = Path(apk_path)
+        self.output_apk = Path(output_apk)
+        self.temp_path = Path(temp_path)
+        if self.temp_path.exists():
+            raise Exception('[!] The temp path already exists')
+        self.external_modules = external_modules
+        self.arch = arch
+        self.artifactory_list = [] if artifactory_list is None else artifactory_list
+        os.makedirs(str(self.temp_path), exist_ok=True)
+        self.google_api_key = google_api_key
+        self.should_sign = should_sign
+        if extra_artifacts is None:
+            extra_artifacts = {}
+        self.extra_artifacts = extra_artifacts
+        self.is_bundle_file = is_bundle(self.apk_path)
+
+    def prepare_artifactory(self):
+        if self.artifactory.exists():
+            try:
+                with open(self.artifactory, 'r') as file:
+                    json.load(file)
+            except json.decoder.JSONDecodeError:
+                pass
+            else:
+                return
+        else:
+            with open(self.artifactory, 'w') as file:
+                json.dump({'SOME_CONST_KEY': 'VALUE'}, file)
+
+    def patch(self):
+        apk_utils.extract_apk(self.apk_path, self.temp_path)
+
+        artifactory = generate_artifactory(self.temp_path, self.artifactory_list)
+        artifactory.update(self.extra_artifacts)
+
+        smali_folders = [folder for folder in
+                         (self.temp_path / EXTRACTED_PATH).iterdir() if
+                         folder.is_dir() and (folder.name.startswith('smali_classes') or folder.name == 'smali')]
+        new_smali_folders = [patcher.get_new_smali_folder(self.temp_path / EXTRACTED_PATH) for _ in
+                             range(len(smali_folders))]
+        print(f'[+] Applying the custom smali into {new_smali_folders[0].name}...')
+
+        for i, folder in enumerate(smali_folders):
+            # move every first folder within to the new smali folder
+            for file in folder.iterdir():
+                target_folder = new_smali_folders[i % len(new_smali_folders)]
+                if not (target_folder / file.name).exists():
+                    shutil.move(file, target_folder)
+                    break
+        target_smali_folder = patcher.get_new_smali_folder(self.temp_path / EXTRACTED_PATH)
+
+        for module in self.external_modules:
+            print('[+] Preparing the smali...')
+            patcher.prepare_smali(self.temp_path, module.module_path, artifactory)
+
+            shutil.copytree(self.temp_path / SMALI_GENERATOR_TEMP_PATH / SMALI_EXTRACTED_PATH / 'smali',
+                            target_smali_folder,
+                            dirs_exist_ok=True)
+            if (self.temp_path / SMALI_GENERATOR_TEMP_PATH / SMALI_EXTRACTED_PATH / 'lib' / self.arch).exists():
+                print('[+] Injecting the custom so...')
+                os.makedirs(self.temp_path / EXTRACTED_PATH / 'lib' / self.arch, exist_ok=True)
+                shutil.copytree(
+                    self.temp_path / SMALI_GENERATOR_TEMP_PATH / SMALI_EXTRACTED_PATH / 'lib' / self.arch,
+                    self.temp_path / EXTRACTED_PATH / 'lib' / self.arch,
+                    dirs_exist_ok=True)
+            shutil.rmtree(self.temp_path / SMALI_GENERATOR_TEMP_PATH, ignore_errors=True)
+
+        invoke_lines = '\n\t'.join([module.invoke_line for module in self.external_modules])
+
+        print('[+] Adding calls to the custom smali...')
+        patcher.patch_entries(self.apk_path, self.temp_path, invoke_lines)
+
+        if self.google_api_key is not None:
+            print('[+] Patching google api key...')
+            if self.is_bundle_file:
+                from stitch.apk_utils import main_apk_name
+                package_name = APK(str(self.temp_path / BUNDLE_APK_EXTRACTED_PATH / main_apk_name)).get_package()
+            else:
+                package_name = APK(str(self.apk_path)).get_package()
+            patcher.patch_google_api_key(self.temp_path, package_name, self.google_api_key)
+
+        temp_output_apk = self.temp_path / 'unsigned.apk'
+
+        print('[+] Compiling APK...')
+        compile_apk(self.temp_path / EXTRACTED_PATH, temp_output_apk)
+
+        if self.should_sign:
+            print('[+] Signing APK...')
+            sign_apk(self.temp_path / BUNDLE_APK_EXTRACTED_PATH, temp_output_apk, self.output_apk, self.is_bundle_file)
+
+        if self.is_bundle_file:
+            from stitch.apk_utils import main_apk_name
+            shutil.move(temp_output_apk, self.temp_path / BUNDLE_APK_EXTRACTED_PATH / main_apk_name)
+            shutil.move(self.temp_path / BUNDLE_APK_EXTRACTED_PATH, 'output_bundle_apks')
+            temp_output_path = shutil.make_archive(str(self.temp_path / 'temp_output'), 'zip', 'output_bundle_apks')
+            shutil.move(temp_output_path, self.output_apk)
+            shutil.rmtree('output_bundle_apks', ignore_errors=True)
+        else:
+            if not self.should_sign:
+                shutil.move(temp_output_apk, self.output_apk)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        print('[+] Cleaning up...')
+        self.clean_up()
+
+    def clean_up(self):
+        shutil.rmtree(self.temp_path, ignore_errors=True)

stitch-0.0.21/src/stitch.egg-info/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: stitch
+Version: 0.0.21
+Author-email: Alon Schwartzblat <alon.ponch@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML
+Requires-Dist: androguard
+Dynamic: license-file
+
+# Stitch
+Stitch is a powerful APK patching python library that allows you to inject your own java module into any APK, bundle or XAPK file.
+
+## How it works
+
+Will be added soon.
+
+## Projects using Stitch:
+- [MakoPatcher][https://github.com/Schwartzblat/MakoPatcher]- A patcher for 12+ app.
+
+## How to use
+### Installation
+You can install Stitch using pip:
+```bash
+# For now, install the test version from TestPyPI
+pip install stitch
+```
+
+### Basic Usage
+Create an Android Gradle project like my smali_generator (Check it out in on of the examples) that generates the java module you want to inject.
+
+Then, use the following code to patch an APK:
+```python
+from stitch import Stitch
+
+with Stitch(
+        apk_path='./input.apk',
+        output_apk='./output.apk',
+        temp_path='./temp',
+        external_module='./smali_generator'
+) as stitch:
+    stitch.patch()
+```
+And that's it! Your APK will be patched with the injected module.
+
+## Contributing
+
+I will be happy if you want to contribute to this project. Feel free to open issues or submit pull requests.
+
+## Disclaimer
+
+For educational purpose only or something like that. I am not responsible for any misuse of this software.

stitch-0.0.21/src/stitch.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+src/stitch/__init__.py
+src/stitch/apk_utils.py
+src/stitch/common.py
+src/stitch/patcher.py
+src/stitch/stitch.py
+src/stitch.egg-info/PKG-INFO
+src/stitch.egg-info/SOURCES.txt
+src/stitch.egg-info/dependency_links.txt
+src/stitch.egg-info/requires.txt
+src/stitch.egg-info/top_level.txt
+src/stitch/artifactory_generator/SimpleArtifactoryFinder.py
+src/stitch/artifactory_generator/__init__.py
+src/stitch/artifactory_generator/generate_artifactory.py
+src/stitch/bin/apktool_2.12.1.jar
+src/stitch/bin/uber-apk-signer-1.2.1.jar

stitch-0.0.21/src/stitch.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

stitch-0.0.21/src/stitch.egg-info/requires.txt

@@ -0,0 +1,2 @@
+PyYAML
+androguard

stitch-0.0.21/src/stitch.egg-info/top_level.txt

@@ -0,0 +1 @@
+stitch