getapk 1.0.0__tar.gz

getapk-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rudranetra India Private Limited (https://rudranetra.com)
+
+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.

getapk-1.0.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: getapk
+Version: 1.0.0
+Summary: Pull an installed app from an Android device over adb as an APK (or an APKS bundle for split APKs)
+License: MIT
+Project-URL: Homepage, https://rudranetra.com/tools
+Project-URL: Source, https://github.com/RansomWhisker/getAPK
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# getAPK
+
+**Pull an installed app off your Android phone as an `.apk` (or an `.apks` bundle for split apps) — in one command.**
+
+`getapk` talks to your device through `adb`, finds where an app is installed, copies every APK file it consists of, checks each one is a real APK, and writes a single ready-to-analyse file with its SHA-256. It is the Android counterpart of [getIPA](https://github.com/RansomWhisker/getIPA).
+
+> A tool by [**rudranetra.com**](https://rudranetra.com) · more at [rudranetra.com/tools](https://rudranetra.com/tools)
+
+## Why not just `adb pull`?
+
+Most Play Store apps are installed as *split APKs*: `base.apk` plus one file per CPU architecture, language and screen density. Pulling only `base.apk` gives you something that will not install and is missing native libraries and resources. getapk pulls them all and bundles them, base first, into one `.apks` file that [AppSleuth](https://github.com/RansomWhisker/AppSleuth) and bundletool-style tools understand.
+
+## Install
+
+    pipx install getapk
+
+Requires Python 3.9+ and Android platform-tools (`adb`) on your PATH. Works on macOS, Linux and Windows. No Python dependencies.
+
+On the phone: enable Developer options → USB debugging, connect, and accept the authorisation prompt. No root needed.
+
+## Use
+
+    getapk --list                         # user-installed apps with versions and installer
+    getapk --list -m bank                 # filter by text
+    getapk com.example.app -o ./apps      # one app
+    getapk com.a.app com.b.app            # several
+    getapk --all -o ./apps                # every user-installed app
+    getapk --all --include-system         # include preinstalled apps
+    getapk -s SERIAL com.example.app      # pick a device when several are connected
+
+Single-APK apps are written as `<package>-<version>.apk`; split apps as `<package>-<version>.apks`. Use `--format apks` to always bundle. Then:
+
+    appsleuth scan com.example.app-1.2.3.apks
+
+## Security
+
+* Package names, device serials and every path reported by the device are validated before use; nothing is passed through a shell on your computer, and the one command run on the phone only ever receives a validated package name.
+* Output file names are sanitised, so a hostile device cannot write outside the output directory.
+* Each pulled file must be a valid APK (a zip containing `AndroidManifest.xml`).
+* Files are written to a temporary directory and moved into place only when complete.
+
+Only use getapk on devices and apps you own or are authorised to analyse. Apps may be copyrighted; extraction is for your own security analysis.
+
+## Tests
+
+    python -m unittest discover -s tests -t .
+
+MIT licence · © Rudranetra India Private Limited

getapk-1.0.0/README.md

@@ -0,0 +1,48 @@
+# getAPK
+
+**Pull an installed app off your Android phone as an `.apk` (or an `.apks` bundle for split apps) — in one command.**
+
+`getapk` talks to your device through `adb`, finds where an app is installed, copies every APK file it consists of, checks each one is a real APK, and writes a single ready-to-analyse file with its SHA-256. It is the Android counterpart of [getIPA](https://github.com/RansomWhisker/getIPA).
+
+> A tool by [**rudranetra.com**](https://rudranetra.com) · more at [rudranetra.com/tools](https://rudranetra.com/tools)
+
+## Why not just `adb pull`?
+
+Most Play Store apps are installed as *split APKs*: `base.apk` plus one file per CPU architecture, language and screen density. Pulling only `base.apk` gives you something that will not install and is missing native libraries and resources. getapk pulls them all and bundles them, base first, into one `.apks` file that [AppSleuth](https://github.com/RansomWhisker/AppSleuth) and bundletool-style tools understand.
+
+## Install
+
+    pipx install getapk
+
+Requires Python 3.9+ and Android platform-tools (`adb`) on your PATH. Works on macOS, Linux and Windows. No Python dependencies.
+
+On the phone: enable Developer options → USB debugging, connect, and accept the authorisation prompt. No root needed.
+
+## Use
+
+    getapk --list                         # user-installed apps with versions and installer
+    getapk --list -m bank                 # filter by text
+    getapk com.example.app -o ./apps      # one app
+    getapk com.a.app com.b.app            # several
+    getapk --all -o ./apps                # every user-installed app
+    getapk --all --include-system         # include preinstalled apps
+    getapk -s SERIAL com.example.app      # pick a device when several are connected
+
+Single-APK apps are written as `<package>-<version>.apk`; split apps as `<package>-<version>.apks`. Use `--format apks` to always bundle. Then:
+
+    appsleuth scan com.example.app-1.2.3.apks
+
+## Security
+
+* Package names, device serials and every path reported by the device are validated before use; nothing is passed through a shell on your computer, and the one command run on the phone only ever receives a validated package name.
+* Output file names are sanitised, so a hostile device cannot write outside the output directory.
+* Each pulled file must be a valid APK (a zip containing `AndroidManifest.xml`).
+* Files are written to a temporary directory and moved into place only when complete.
+
+Only use getapk on devices and apps you own or are authorised to analyse. Apps may be copyrighted; extraction is for your own security analysis.
+
+## Tests
+
+    python -m unittest discover -s tests -t .
+
+MIT licence · © Rudranetra India Private Limited

getapk-1.0.0/getapk.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: getapk
+Version: 1.0.0
+Summary: Pull an installed app from an Android device over adb as an APK (or an APKS bundle for split APKs)
+License: MIT
+Project-URL: Homepage, https://rudranetra.com/tools
+Project-URL: Source, https://github.com/RansomWhisker/getAPK
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# getAPK
+
+**Pull an installed app off your Android phone as an `.apk` (or an `.apks` bundle for split apps) — in one command.**
+
+`getapk` talks to your device through `adb`, finds where an app is installed, copies every APK file it consists of, checks each one is a real APK, and writes a single ready-to-analyse file with its SHA-256. It is the Android counterpart of [getIPA](https://github.com/RansomWhisker/getIPA).
+
+> A tool by [**rudranetra.com**](https://rudranetra.com) · more at [rudranetra.com/tools](https://rudranetra.com/tools)
+
+## Why not just `adb pull`?
+
+Most Play Store apps are installed as *split APKs*: `base.apk` plus one file per CPU architecture, language and screen density. Pulling only `base.apk` gives you something that will not install and is missing native libraries and resources. getapk pulls them all and bundles them, base first, into one `.apks` file that [AppSleuth](https://github.com/RansomWhisker/AppSleuth) and bundletool-style tools understand.
+
+## Install
+
+    pipx install getapk
+
+Requires Python 3.9+ and Android platform-tools (`adb`) on your PATH. Works on macOS, Linux and Windows. No Python dependencies.
+
+On the phone: enable Developer options → USB debugging, connect, and accept the authorisation prompt. No root needed.
+
+## Use
+
+    getapk --list                         # user-installed apps with versions and installer
+    getapk --list -m bank                 # filter by text
+    getapk com.example.app -o ./apps      # one app
+    getapk com.a.app com.b.app            # several
+    getapk --all -o ./apps                # every user-installed app
+    getapk --all --include-system         # include preinstalled apps
+    getapk -s SERIAL com.example.app      # pick a device when several are connected
+
+Single-APK apps are written as `<package>-<version>.apk`; split apps as `<package>-<version>.apks`. Use `--format apks` to always bundle. Then:
+
+    appsleuth scan com.example.app-1.2.3.apks
+
+## Security
+
+* Package names, device serials and every path reported by the device are validated before use; nothing is passed through a shell on your computer, and the one command run on the phone only ever receives a validated package name.
+* Output file names are sanitised, so a hostile device cannot write outside the output directory.
+* Each pulled file must be a valid APK (a zip containing `AndroidManifest.xml`).
+* Files are written to a temporary directory and moved into place only when complete.
+
+Only use getapk on devices and apps you own or are authorised to analyse. Apps may be copyrighted; extraction is for your own security analysis.
+
+## Tests
+
+    python -m unittest discover -s tests -t .
+
+MIT licence · © Rudranetra India Private Limited

getapk-1.0.0/getapk.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+getapk.egg-info/PKG-INFO
+getapk.egg-info/SOURCES.txt
+getapk.egg-info/dependency_links.txt
+getapk.egg-info/entry_points.txt
+getapk.egg-info/top_level.txt
+getapk_cli/__init__.py
+getapk_cli/cli.py
+tests/test_getapk.py

getapk-1.0.0/getapk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

getapk-1.0.0/getapk.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+getapk = getapk_cli.cli:main

getapk-1.0.0/getapk.egg-info/top_level.txt

@@ -0,0 +1 @@
+getapk_cli

getapk-1.0.0/getapk_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

getapk-1.0.0/getapk_cli/cli.py

@@ -0,0 +1,251 @@
+"""getapk: pull installed apps from an Android device over adb.
+
+Single-APK apps become `<package>-<version>.apk`. Apps installed as split APKs (most Play Store
+apps today) become `<package>-<version>.apks`, a zip holding base.apk and every split, which
+AppSleuth and bundletool-style tools understand. Only use it on devices and apps you are
+authorised to analyse.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import zipfile
+from typing import Dict, List, Optional
+
+from . import __version__
+
+PKG_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z0-9_]+)+$")
+SERIAL_RE = re.compile(r"^[A-Za-z0-9._:\-]{1,100}$")
+DEVICE_PATH_RE = re.compile(r"^/[A-Za-z0-9_./=~+@\-]+\.apk$")
+ADB_TIMEOUT = 120
+PULL_TIMEOUT = 900
+
+
+class AdbError(Exception):
+    pass
+
+
+def die(msg: str, code: int = 1):
+    print(f"error: {msg}", file=sys.stderr)
+    sys.exit(code)
+
+
+class Adb:
+    def __init__(self, serial: Optional[str] = None, exe: Optional[str] = None):
+        self.exe = exe or shutil.which("adb")
+        if not self.exe:
+            raise AdbError("adb not found. Install Android platform-tools and put adb on your PATH "
+                           "(or pass --adb /path/to/adb).")
+        if serial is not None and not SERIAL_RE.match(serial):
+            raise AdbError("invalid device serial")
+        self.serial = serial
+
+    def _base(self) -> List[str]:
+        return [self.exe] + (["-s", self.serial] if self.serial else [])
+
+    def run(self, *args: str, timeout: int = ADB_TIMEOUT) -> str:
+        try:
+            r = subprocess.run(self._base() + list(args), capture_output=True, text=True,
+                               encoding="utf-8", errors="replace", timeout=timeout)
+        except subprocess.TimeoutExpired:
+            raise AdbError(f"adb {' '.join(args[:2])} timed out")
+        if r.returncode != 0:
+            raise AdbError((r.stderr or r.stdout).strip()[:300] or f"adb exited {r.returncode}")
+        return r.stdout
+
+    def devices(self) -> List[Dict[str, str]]:
+        out = subprocess.run([self.exe, "devices", "-l"], capture_output=True, text=True,
+                             encoding="utf-8", errors="replace", timeout=ADB_TIMEOUT).stdout
+        rows = []
+        for line in out.splitlines()[1:]:
+            parts = line.split()
+            if len(parts) >= 2:
+                model = next((p.split(":", 1)[1] for p in parts[2:] if p.startswith("model:")), "")
+                rows.append({"serial": parts[0], "state": parts[1], "model": model})
+        return rows
+
+    def check_device(self):
+        ds = self.devices()
+        ready = [d for d in ds if d["state"] == "device"]
+        if self.serial:
+            if not any(d["serial"] == self.serial and d["state"] == "device" for d in ds):
+                raise AdbError(f"device {self.serial} not found or not authorised (check the phone for the USB debugging prompt)")
+        elif not ready:
+            bad = [d for d in ds if d["state"] != "device"]
+            raise AdbError("no authorised device. " + (f"{bad[0]['serial']} is '{bad[0]['state']}': "
+                           "unlock the phone and accept the USB debugging prompt." if bad else
+                           "Connect a device with USB debugging enabled."))
+        elif len(ready) > 1:
+            raise AdbError("several devices connected; choose one with -s SERIAL: " +
+                           ", ".join(f"{d['serial']} ({d['model']})" for d in ready))
+
+    def packages(self, include_system: bool = False) -> List[str]:
+        out = self.run("shell", "pm", "list", "packages", *([] if include_system else ["-3"]))
+        pk = sorted({l.split(":", 1)[1].strip() for l in out.splitlines() if l.startswith("package:")})
+        return [p for p in pk if PKG_RE.match(p)]
+
+    def apk_paths(self, package: str) -> List[str]:
+        if not PKG_RE.match(package):
+            raise AdbError(f"invalid package name: {package!r}")
+        out = self.run("shell", "pm", "path", package)
+        paths = [l.split(":", 1)[1].strip() for l in out.splitlines() if l.startswith("package:")]
+        bad = [p for p in paths if not DEVICE_PATH_RE.match(p)]
+        if bad:
+            raise AdbError(f"unexpected path reported by the device: {bad[0][:80]!r}")
+        # base first, then splits, in a stable order
+        return sorted(paths, key=lambda p: (os.path.basename(p) != "base.apk", p))
+
+    def version(self, package: str) -> Dict[str, str]:
+        info = {"name": "", "code": "", "installer": ""}
+        try:
+            out = self.run("shell", "dumpsys", "package", package)
+        except AdbError:
+            return info
+        for line in out.splitlines():
+            line = line.strip()
+            if line.startswith("versionName=") and not info["name"]:
+                info["name"] = line.split("=", 1)[1].strip()
+            elif line.startswith("versionCode=") and not info["code"]:
+                info["code"] = line.split("=", 1)[1].split()[0]
+            elif line.startswith("installerPackageName=") and not info["installer"]:
+                info["installer"] = line.split("=", 1)[1].strip()
+        return info
+
+    def pull(self, remote: str, local: str):
+        self.run("pull", remote, local, timeout=PULL_TIMEOUT)
+
+
+def safe_part(s: str) -> str:
+    return re.sub(r"[^A-Za-z0-9._+-]", "_", s)[:80] or "unknown"
+
+
+def sha256_file(path: str) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for chunk in iter(lambda: fh.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def looks_like_apk(path: str) -> bool:
+    try:
+        with zipfile.ZipFile(path) as z:
+            return "AndroidManifest.xml" in z.namelist()
+    except (zipfile.BadZipFile, OSError):
+        return False
+
+
+def pull_app(adb: Adb, package: str, outdir: str, fmt: str = "auto", quiet: bool = False) -> Dict[str, object]:
+    paths = adb.apk_paths(package)
+    if not paths:
+        raise AdbError(f"{package} is not installed")
+    ver = adb.version(package)
+    stem = safe_part(package) + (f"-{safe_part(ver['name'])}" if ver["name"] else "")
+    os.makedirs(outdir, exist_ok=True)
+    work = tempfile.mkdtemp(prefix="getapk_")
+    try:
+        local = []
+        for i, remote in enumerate(paths):
+            name = safe_part(os.path.basename(remote))
+            if name in [os.path.basename(x) for x in local]:
+                name = f"{i}_{name}"
+            dst = os.path.join(work, name)
+            adb.pull(remote, dst)
+            if not looks_like_apk(dst):
+                raise AdbError(f"{name} did not pull as a valid APK")
+            local.append(dst)
+        split = len(local) > 1
+        if fmt == "apk" and split:
+            raise AdbError(f"{package} is a split-APK app ({len(local)} files); use --format auto or apks")
+        if split or fmt == "apks":
+            final = os.path.join(outdir, stem + ".apks")
+            tmp_out = final + ".part"
+            with zipfile.ZipFile(tmp_out, "w", zipfile.ZIP_STORED) as z:       # APKs are already compressed
+                for f in local:
+                    z.write(f, os.path.basename(f))
+            os.replace(tmp_out, final)
+        else:
+            final = os.path.join(outdir, stem + ".apk")
+            shutil.copyfile(local[0], final)
+        return {"package": package, "path": final, "splits": len(local), "version": ver["name"],
+                "size": os.path.getsize(final), "sha256": sha256_file(final), "installer": ver["installer"]}
+    finally:
+        shutil.rmtree(work, ignore_errors=True)
+
+
+def fmt_size(n: int) -> str:
+    return f"{n / 1e6:.1f} MB" if n >= 1e6 else f"{n / 1e3:.0f} KB"
+
+
+def cmd_list(adb: Adb, a) -> int:
+    pk = adb.packages(a.include_system)
+    if a.match:
+        pk = [p for p in pk if a.match.lower() in p.lower()]
+    if not pk:
+        print("No matching apps.")
+        return 1
+    for i, p in enumerate(pk, 1):
+        v = adb.version(p)
+        print(f"{i:3}. {p:<55} {v['name'] or '?':<14} {v['installer'] or ''}")
+    return 0
+
+
+def main(argv: Optional[List[str]] = None):
+    for s in (sys.stdout, sys.stderr):
+        try:
+            s.reconfigure(encoding="utf-8", errors="replace")
+        except (AttributeError, ValueError):
+            pass
+    ap = argparse.ArgumentParser(prog="getapk", description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("package", nargs="*", help="package name(s) to pull, e.g. com.example.app")
+    ap.add_argument("-l", "--list", action="store_true", help="list installed apps")
+    ap.add_argument("--all", action="store_true", help="pull every (user-installed) app")
+    ap.add_argument("-m", "--match", help="with --list/--all: only packages containing this text")
+    ap.add_argument("--include-system", action="store_true", help="include system/preinstalled apps")
+    ap.add_argument("-s", "--serial", help="device serial (needed when several devices are connected)")
+    ap.add_argument("-o", "--out", default=".", help="output directory (default: current)")
+    ap.add_argument("--format", choices=["auto", "apk", "apks"], default="auto",
+                    help="auto: .apk for single-APK apps, .apks bundle for split apps")
+    ap.add_argument("--adb", help="path to the adb executable")
+    ap.add_argument("--version", action="version", version=f"getapk {__version__}")
+    a = ap.parse_args(argv)
+    try:
+        adb = Adb(a.serial, a.adb)
+        adb.check_device()
+        if a.list:
+            sys.exit(cmd_list(adb, a))
+        targets = list(a.package)
+        if a.all:
+            targets += [p for p in adb.packages(a.include_system)
+                        if (not a.match or a.match.lower() in p.lower()) and p not in targets]
+        if not targets:
+            ap.print_usage(sys.stderr)
+            die("give a package name, or use --list / --all", 2)
+        failures = 0
+        for p in targets:
+            try:
+                r = pull_app(adb, p, a.out, a.format)
+                kind = f"{r['splits']} splits" if r["splits"] > 1 else "single APK"
+                print(f"[+] {r['package']} {r['version'] or ''} -> {r['path']}  ({kind}, {fmt_size(r['size'])})")
+                print(f"    sha256 {r['sha256']}")
+            except AdbError as e:
+                failures += 1
+                print(f"[-] {p}: {e}", file=sys.stderr)
+        if failures:
+            sys.exit(1)
+    except AdbError as e:
+        die(str(e))
+    except KeyboardInterrupt:
+        print("\ninterrupted", file=sys.stderr)
+        sys.exit(130)
+
+
+if __name__ == "__main__":
+    main()

getapk-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "getapk"
+version = "1.0.0"
+description = "Pull an installed app from an Android device over adb as an APK (or an APKS bundle for split APKs)"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+dependencies = []
+
+[project.scripts]
+getapk = "getapk_cli.cli:main"
+
+[project.urls]
+Homepage = "https://rudranetra.com/tools"
+Source = "https://github.com/RansomWhisker/getAPK"
+
+[tool.setuptools]
+packages = ["getapk_cli"]

getapk-1.0.0/setup.cfg

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

getapk-1.0.0/tests/test_getapk.py

@@ -0,0 +1,79 @@
+import os
+import tempfile
+import unittest
+import zipfile
+
+from getapk_cli import cli
+
+
+def make_apk(path):
+    with zipfile.ZipFile(path, "w") as z:
+        z.writestr("AndroidManifest.xml", b"x")
+
+
+class FakeAdb(cli.Adb):
+    def __init__(self, paths, bad_apk=False):
+        self.exe, self.serial = "adb", None
+        self._paths, self._bad = paths, bad_apk
+
+    def run(self, *args, timeout=0):
+        if args[:2] == ("shell", "pm") and args[2] == "path":
+            return "".join(f"package:{p}\n" for p in self._paths)
+        if args[:2] == ("shell", "dumpsys"):
+            return "    versionCode=12 minSdk=24\n    versionName=1.2.3\n    installerPackageName=com.android.vending\n"
+        if args[0] == "pull":
+            if self._bad:
+                open(args[2], "wb").write(b"not a zip")
+            else:
+                make_apk(args[2])
+            return ""
+        raise AssertionError(args)
+
+
+class Pull(unittest.TestCase):
+    def test_single_apk(self):
+        out = tempfile.mkdtemp()
+        r = cli.pull_app(FakeAdb(["/data/app/x/base.apk"]), "com.example.app", out)
+        self.assertTrue(r["path"].endswith("com.example.app-1.2.3.apk"))
+        self.assertEqual(r["splits"], 1)
+
+    def test_split_becomes_apks_base_first(self):
+        out = tempfile.mkdtemp()
+        paths = ["/data/app/x/split_config.en.apk", "/data/app/x/base.apk", "/data/app/x/split_config.arm64_v8a.apk"]
+        r = cli.pull_app(FakeAdb(paths), "com.example.app", out)
+        self.assertTrue(r["path"].endswith(".apks"))
+        with zipfile.ZipFile(r["path"]) as z:
+            self.assertEqual(z.namelist()[0], "base.apk")
+            self.assertEqual(len(z.namelist()), 3)
+
+    def test_rejects_non_apk(self):
+        with self.assertRaises(cli.AdbError):
+            cli.pull_app(FakeAdb(["/data/app/x/base.apk"], bad_apk=True), "com.example.app", tempfile.mkdtemp())
+
+    def test_format_apk_refuses_split(self):
+        with self.assertRaises(cli.AdbError):
+            cli.pull_app(FakeAdb(["/data/app/x/base.apk", "/data/app/x/split_a.apk"]), "com.example.app",
+                         tempfile.mkdtemp(), fmt="apk")
+
+
+class Validation(unittest.TestCase):
+    def test_package_names(self):
+        for bad in ("a; rm -rf /", "$(id)", "com.example.app && x", "../x", "single", ""):
+            with self.assertRaises(cli.AdbError, msg=bad):
+                FakeAdb([]).apk_paths(bad)
+
+    def test_hostile_device_path_rejected(self):
+        with self.assertRaises(cli.AdbError):
+            FakeAdb(["/data/app/x/base.apk; id"]).apk_paths("com.example.app")
+        with self.assertRaises(cli.AdbError):
+            FakeAdb(["../../etc/passwd"]).apk_paths("com.example.app")
+
+    def test_serial_and_safe_name(self):
+        with self.assertRaises(cli.AdbError):
+            cli.Adb("x; y", exe="adb")
+        self.assertEqual(cli.safe_part("../../a b"), ".._.._a_b")
+        self.assertNotIn("/", cli.safe_part("a/b"))
+
+
+if __name__ == "__main__":
+    unittest.main()