ipa-forge 0.1.0__py3-none-any.whl

ipa_forge/__init__.py

@@ -0,0 +1 @@
+# SPDX-License-Identifier: GPL-3.0-or-later

ipa_forge/altstore/__init__.py

@@ -0,0 +1 @@
+# SPDX-License-Identifier: GPL-3.0-or-later

ipa_forge/altstore/source.py

@@ -0,0 +1,44 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""AltStore Classic source.json app-entry export.
+
+A distribution metadata layer, deliberately kept separate from the signing
+engine (see the architecture doc's AltStore-source-is-optional note) -- it
+only describes an already-patched-and-signed .ipa, it never produces one.
+"""
+
+from __future__ import annotations
+
+import json
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from ipa_forge.bundle.ipa import extract_ipa, load_bundle
+from ipa_forge.manifest import sha256_of
+from ipa_forge.validators.ipa_validator import validate_ipa_structure
+
+
+def build_app_entry(ipa_path: Path, download_url: str) -> dict[str, Any]:
+    with tempfile.TemporaryDirectory(prefix="ipa_forge_export_") as tmp:
+        validate_ipa_structure(ipa_path)
+        app_path = extract_ipa(ipa_path, Path(tmp))
+        bundle = load_bundle(app_path)
+        name = bundle.info_plist.get("CFBundleName", bundle.main_executable_name)
+        bundle_id = bundle.bundle_id
+        version = bundle.version
+        build = bundle.build
+
+    return {
+        "name": name,
+        "bundleIdentifier": bundle_id,
+        "version": version,
+        "buildVersion": build,
+        "downloadURL": download_url,
+        "size": ipa_path.stat().st_size,
+        "sha256": sha256_of(ipa_path),
+    }
+
+
+def write_source_json(entry: dict[str, Any], path: Path, source_name: str = "ipa-forge patched apps") -> None:
+    source = {"name": source_name, "apps": [entry]}
+    path.write_text(json.dumps(source, indent=2))

ipa_forge/analysis/__init__.py

@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""General-purpose static reverse engineering of an IPA -- class-dump,
+strings, symbols, security posture, and version diffing -- built on the same
+Mach-O/ObjC analysis engine `ipa_forge.hooks` uses for hook verification
+(`ipa_forge.machO.objc`). See `forge analysis --help`.
+
+Deliberately out of scope, by design, not oversight (see ROADMAP.md):
+
+- **FairPlay/App Store DRM decryption.** Every command here assumes an
+  already-decrypted `.ipa`, exactly like the rest of ipa-forge; decryption
+  is DRM-circumvention tooling, a different risk category from static
+  analysis of a binary you already have rights to inspect.
+- **Instruction-level disassembly/decompilation** (capstone/Ghidra-grade).
+  A large additional dependency and maintenance surface; tracked as a
+  future phase in ROADMAP.md rather than bundled by default.
+"""
+
+from __future__ import annotations

ipa_forge/analysis/classdump.py

@@ -0,0 +1,103 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Render a `MachOAnalysis` as `.h`-style class-dump text: `@interface`,
+`@protocol`, and `@interface (Category)` blocks with method signatures,
+ivars, and properties -- the general-purpose reverse-engineering view built
+on the same class table `ipa_forge.hooks` uses for hook verification.
+"""
+
+from __future__ import annotations
+
+from ipa_forge.analysis.type_encoding import decode_method_signature, decode_type, read_one_type
+from ipa_forge.machO.objc import MachOAnalysis, MachOCategory, MachOClass, MachOProtocol
+
+
+def _method_lines(methods: dict[str, str], prefix: str) -> list[str]:
+    return [f"{prefix} {decode_method_signature(sel, enc)};" for sel, enc in sorted(methods.items())]
+
+
+def _decl(type_str: str, name: str) -> str:
+    """`Type name;` for a value type, `Type *name;` for a pointer type --
+    decode_type() already renders the trailing `*`, so avoid a stray space
+    between it and the identifier."""
+    sep = "" if type_str.endswith("*") else " "
+    return f"{type_str}{sep}{name}"
+
+
+def render_class(cls: MachOClass) -> str:
+    conforms = f" <{', '.join(sorted(cls.protocols))}>" if cls.protocols else ""
+    header = f"@interface {cls.name} : {cls.super_name or 'NSObject'}{conforms}"
+    lines = [header]
+
+    if cls.ivars:
+        lines.append("{")
+        for iv in cls.ivars:
+            lines.append(f"    {_decl(decode_type(iv.type_encoding), iv.name)};")
+        lines.append("}")
+
+    for prop in cls.properties:
+        # attribute string: "T<type-encoding>,<flag>,<flag>,..." (e.g.
+        # 'T@"NSString",C,N,V_label') -- a naive split(",") would break on a
+        # comma inside a generic-collection class name, so tokenize the type
+        # encoding itself rather than string-splitting the whole attribute.
+        type_enc = prop.attributes[1:] if prop.attributes.startswith("T") else prop.attributes
+        tok, _ = read_one_type(type_enc, 0) if type_enc else ("", 0)
+        decoded = decode_type(tok) if tok else "id"
+        lines.append(f"@property {_decl(decoded, prop.name)}; // {prop.attributes}")
+
+    if cls.properties and (cls.inst or cls.cls):
+        lines.append("")
+
+    lines.extend(_method_lines(cls.cls, "+"))
+    lines.extend(_method_lines(cls.inst, "-"))
+
+    lines.append("")
+    lines.append("@end")
+    return "\n".join(lines)
+
+
+def render_protocol(proto: MachOProtocol) -> str:
+    conforms = f" <{', '.join(sorted(proto.protocols))}>" if proto.protocols else ""
+    lines = [f"@protocol {proto.name}{conforms}"]
+    lines.extend(_method_lines(proto.cls, "+"))
+    lines.extend(_method_lines(proto.inst, "-"))
+    if proto.opt_cls or proto.opt_inst:
+        lines.append("@optional")
+        lines.extend(_method_lines(proto.opt_cls, "+"))
+        lines.extend(_method_lines(proto.opt_inst, "-"))
+    lines.append("@end")
+    return "\n".join(lines)
+
+
+def render_category(cat: MachOCategory) -> str:
+    lines = [f"@interface {cat.class_name} ({cat.name})"]
+    lines.extend(_method_lines(cat.cls, "+"))
+    lines.extend(_method_lines(cat.inst, "-"))
+    lines.append("@end")
+    return "\n".join(lines)
+
+
+def render_analysis(
+    analysis: MachOAnalysis,
+    *,
+    class_filter: str | None = None,
+    search: str | None = None,
+) -> str:
+    """Render every class/protocol/category in `analysis` as class-dump text,
+    optionally restricted to one class name or a substring/regex search over
+    class names (matches `forge hooks extract`'s --class/--search)."""
+    import re as _re
+
+    classes = sorted(analysis.classes.values(), key=lambda c: c.name)
+    if class_filter:
+        classes = [c for c in classes if c.name == class_filter]
+    elif search:
+        pat = _re.compile(search)
+        classes = [c for c in classes if pat.search(c.name)]
+
+    blocks: list[str] = []
+    if not class_filter and not search:
+        blocks.extend(render_protocol(p) for p in sorted(analysis.protocols.values(), key=lambda p: p.name))
+    blocks.extend(render_class(c) for c in classes)
+    if not class_filter and not search:
+        blocks.extend(render_category(cat) for cat in sorted(analysis.categories, key=lambda c: (c.class_name, c.name)))
+    return "\n\n".join(blocks)

ipa_forge/analysis/diff.py

@@ -0,0 +1,127 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Version-to-version diffing for porting: what changed between two builds
+of the same app -- classes/protocols added or removed, per-class method
+churn, and Info.plist key changes.
+
+Distinct from `forge hooks diff`, which only re-checks a patch definition's
+*declared* hook targets and is a pass/fail gate (did a required hook
+regress?). This is the broader, informational survey: what changed at all,
+independent of any particular patch set. Entitlements are deliberately not
+diffed here -- reading them requires shelling out to `codesign`/`security`,
+and `signing/backend.py` is the only module allowed to do that (see
+architecture.md's hard constraint); a real entitlements diff belongs there,
+not in this read-only static-analysis package.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from ipa_forge.machO.objc import MachOAnalysis
+
+_MISSING = object()
+
+
+@dataclass
+class AnalysisDiff:
+    added_classes: set[str] = field(default_factory=set)
+    removed_classes: set[str] = field(default_factory=set)
+    added_protocols: set[str] = field(default_factory=set)
+    removed_protocols: set[str] = field(default_factory=set)
+    # class name -> (added selectors, removed selectors); instance + class
+    # methods combined, only for classes present in both builds.
+    changed_class_methods: dict[str, tuple[set[str], set[str]]] = field(default_factory=dict)
+    changed_plist_keys: dict[str, tuple[Any, Any]] = field(default_factory=dict)
+
+    @property
+    def has_changes(self) -> bool:
+        return bool(
+            self.added_classes
+            or self.removed_classes
+            or self.added_protocols
+            or self.removed_protocols
+            or self.changed_class_methods
+            or self.changed_plist_keys
+        )
+
+
+def diff_classes(
+    old: MachOAnalysis, new: MachOAnalysis
+) -> tuple[set[str], set[str], dict[str, tuple[set[str], set[str]]]]:
+    old_names = set(old.classes)
+    new_names = set(new.classes)
+    added = new_names - old_names
+    removed = old_names - new_names
+
+    changed: dict[str, tuple[set[str], set[str]]] = {}
+    for name in old_names & new_names:
+        old_methods = set(old.classes[name].inst) | set(old.classes[name].cls)
+        new_methods = set(new.classes[name].inst) | set(new.classes[name].cls)
+        added_m = new_methods - old_methods
+        removed_m = old_methods - new_methods
+        if added_m or removed_m:
+            changed[name] = (added_m, removed_m)
+    return added, removed, changed
+
+
+def diff_plists(old_plist: dict[str, Any], new_plist: dict[str, Any]) -> dict[str, tuple[Any, Any]]:
+    """Key -> (old value, new value); a key present on only one side reports
+    `None` for the side it's missing from."""
+    changed: dict[str, tuple[Any, Any]] = {}
+    for key in set(old_plist) | set(new_plist):
+        old_val = old_plist.get(key, _MISSING)
+        new_val = new_plist.get(key, _MISSING)
+        if old_val != new_val:
+            changed[key] = (
+                None if old_val is _MISSING else old_val,
+                None if new_val is _MISSING else new_val,
+            )
+    return changed
+
+
+def diff_analyses(
+    old: MachOAnalysis,
+    new: MachOAnalysis,
+    old_plist: dict[str, Any],
+    new_plist: dict[str, Any],
+) -> AnalysisDiff:
+    added_classes, removed_classes, changed_methods = diff_classes(old, new)
+    return AnalysisDiff(
+        added_classes=added_classes,
+        removed_classes=removed_classes,
+        added_protocols=set(new.protocols) - set(old.protocols),
+        removed_protocols=set(old.protocols) - set(new.protocols),
+        changed_class_methods=changed_methods,
+        changed_plist_keys=diff_plists(old_plist, new_plist),
+    )
+
+
+def render_diff(diff: AnalysisDiff) -> str:
+    if not diff.has_changes:
+        return "no differences found"
+
+    lines: list[str] = []
+    if diff.added_classes:
+        lines.append(f"+ {len(diff.added_classes)} new class(es):")
+        lines.extend(f"    {c}" for c in sorted(diff.added_classes))
+    if diff.removed_classes:
+        lines.append(f"- {len(diff.removed_classes)} removed class(es):")
+        lines.extend(f"    {c}" for c in sorted(diff.removed_classes))
+    if diff.added_protocols:
+        lines.append(f"+ {len(diff.added_protocols)} new protocol(s): {', '.join(sorted(diff.added_protocols))}")
+    if diff.removed_protocols:
+        removed_names = ", ".join(sorted(diff.removed_protocols))
+        lines.append(f"- {len(diff.removed_protocols)} removed protocol(s): {removed_names}")
+    if diff.changed_class_methods:
+        lines.append(f"~ {len(diff.changed_class_methods)} class(es) with method changes:")
+        for cls, (added_m, removed_m) in sorted(diff.changed_class_methods.items()):
+            if added_m:
+                lines.append(f"    {cls}: + {', '.join(sorted(added_m))}")
+            if removed_m:
+                lines.append(f"    {cls}: - {', '.join(sorted(removed_m))}")
+    if diff.changed_plist_keys:
+        lines.append(f"~ {len(diff.changed_plist_keys)} Info.plist key(s) changed:")
+        for key, (old_v, new_v) in sorted(diff.changed_plist_keys.items()):
+            lines.append(f"    {key}: {old_v!r} -> {new_v!r}")
+    return "\n".join(lines)

ipa_forge/analysis/security.py

@@ -0,0 +1,72 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Read-only Mach-O security/build posture: PIE, encryption-flag detection
+(never decryption -- see the module docstring boundary in
+`ipa_forge.analysis`), stack protector, an ARC heuristic, min-OS, and
+platform. The same kind of static check `otool -l`/jtool2's `--sig` print,
+as structured data instead of text to grep."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import lief
+
+from ipa_forge.machO.arch import arch_name, load_macho
+
+
+@dataclass
+class SecurityPosture:
+    binary: str
+    arch: str
+    pie: bool
+    # True when LC_ENCRYPTION_INFO(_64)'s cryptid != 0 -- an App Store binary
+    # pulled without prior decryption. Detection only; this tool never
+    # decrypts it (see ROADMAP.md for why that is out of scope).
+    encrypted: bool
+    stack_protector: bool  # ___stack_chk_fail imported
+    arc_heuristic: bool  # _objc_storeStrong/_objc_release imported (best-effort, not definitive)
+    min_os: str | None
+    platform: str | None
+
+
+def analyze_security(path: Path, arch: str | None = None) -> SecurityPosture:
+    binary = load_macho(path, arch)
+    imported = {str(s.name) for s in binary.symbols if s.category == lief.MachO.Symbol.CATEGORY.UNDEFINED}
+
+    enc = binary.encryption_info
+    encrypted = enc is not None and enc.crypt_id != 0
+
+    min_os: str | None = None
+    platform: str | None = None
+    bv = binary.build_version
+    vm = binary.version_min
+    if bv is not None:
+        min_os = ".".join(str(n) for n in bv.minos)
+        platform = str(bv.platform).rsplit(".", 1)[-1]
+    elif vm is not None:
+        min_os = ".".join(str(n) for n in vm.version)
+
+    return SecurityPosture(
+        binary=path.name,
+        arch=arch_name(binary),
+        pie=lief.MachO.Header.FLAGS.PIE in binary.header.flags_list,
+        encrypted=encrypted,
+        stack_protector="___stack_chk_fail" in imported,
+        arc_heuristic=bool({"_objc_storeStrong", "_objc_release"} & imported),
+        min_os=min_os,
+        platform=platform,
+    )
+
+
+def render_security_posture(posture: SecurityPosture) -> str:
+    """A short human-readable summary for the CLI."""
+    os_bit = f", min {posture.platform} {posture.min_os}" if posture.min_os else ""
+    lines = [
+        f"{posture.binary} ({posture.arch}){os_bit}",
+        f"  PIE:             {'yes' if posture.pie else 'NO'}",
+        f"  Encrypted:       {'yes (App Store, undecrypted)' if posture.encrypted else 'no'}",
+        f"  Stack protector: {'yes' if posture.stack_protector else 'no'}",
+        f"  ARC (heuristic): {'likely' if posture.arc_heuristic else 'unclear / MRC'}",
+    ]
+    return "\n".join(lines)

ipa_forge/analysis/strings.py

@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Printable-string extraction from Mach-O binaries -- `strings <binary>`,
+but IPA-aware: runs over every executable in the bundle (main + frameworks +
+dylibs + extensions) in one pass, tagging each string with the binary it
+came from."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from ipa_forge.bundle.models import AppBundle
+from ipa_forge.machO.detect import bundle_executable_paths
+
+
+@dataclass
+class ExtractedString:
+    value: str
+    binary: str  # file name of the executable it was found in
+
+
+def extract_strings(data: bytes, min_len: int = 4) -> list[str]:
+    """Printable-ASCII runs at least `min_len` bytes long, terminated by a
+    non-printable/NUL byte -- the same definition classic `strings` uses.
+    Wide (UTF-16) string literals are not decoded; documented limitation."""
+    pattern = re.compile(rb"[\x20-\x7e]{%d,}" % max(min_len, 1))
+    return [m.group().decode("ascii") for m in pattern.finditer(data)]
+
+
+def strings_in_bundle(bundle: AppBundle, min_len: int = 4) -> list[ExtractedString]:
+    """Extract strings from every executable in the bundle, main binary
+    first, in inventory order thereafter."""
+    out: list[ExtractedString] = []
+    for path in bundle_executable_paths(bundle):
+        try:
+            data = path.read_bytes()
+        except OSError:
+            continue
+        out.extend(ExtractedString(s, path.name) for s in extract_strings(data, min_len))
+    return out

ipa_forge/analysis/symbols.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Linked libraries + imported/exported symbols for a Mach-O executable --
+`otool -L` + `nm`, backed by LIEF's structured symbol table instead of
+shelling out and parsing text."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import lief
+
+from ipa_forge.machO.arch import arch_name, load_macho
+
+
+@dataclass
+class BinarySymbols:
+    binary: str
+    arch: str
+    linked_libraries: list[str] = field(default_factory=list)
+    imported_symbols: list[str] = field(default_factory=list)
+    exported_symbols: list[str] = field(default_factory=list)
+
+
+def analyze_symbols(path: Path, arch: str | None = None) -> BinarySymbols:
+    """Fat binaries require an explicit `arch` -- same rule `forge patch`'s
+    binary operations follow (see `machO/arch.py::load_macho`); a thin
+    binary needs none."""
+    binary = load_macho(path, arch)
+    # CATEGORY.UNDEFINED: referenced here, defined in another image (an
+    # import). CATEGORY.EXTERNAL: defined in this image and globally
+    # visible (an export). CATEGORY.LOCAL: internal-only, not exported.
+    imported = sorted({str(s.name) for s in binary.symbols if s.category == lief.MachO.Symbol.CATEGORY.UNDEFINED})
+    exported = sorted({str(s.name) for s in binary.symbols if s.category == lief.MachO.Symbol.CATEGORY.EXTERNAL})
+    libraries = sorted({str(lib.name) for lib in binary.libraries})
+    return BinarySymbols(
+        binary=path.name,
+        arch=arch_name(binary),
+        linked_libraries=libraries,
+        imported_symbols=imported,
+        exported_symbols=exported,
+    )

ipa_forge/analysis/type_encoding.py

@@ -0,0 +1,164 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Best-effort Objective-C type-encoding decoder.
+
+Turns runtime type-encoding strings (as found on ivars, properties, and
+method ``types`` fields -- see ``@encode`` in the Objective-C runtime) into
+readable pseudo-header text for `class-dump`-style output. This is
+deliberately not a full encoder/decoder round-trip: structs/unions render as
+just their tag name (no field expansion) and bitfields fall back to the raw
+encoding. Good enough to read a class-dump header; not good enough to
+regenerate a compilable one.
+"""
+
+from __future__ import annotations
+
+import re
+
+_MODIFIERS = "rnNoORV"  # const, in, inout, out, bycopy, byref, oneway
+
+_SIMPLE = {
+    "c": "char",
+    "i": "int",
+    "s": "short",
+    "l": "long",
+    "q": "long long",
+    "C": "unsigned char",
+    "I": "unsigned int",
+    "S": "unsigned short",
+    "L": "unsigned long",
+    "Q": "unsigned long long",
+    "f": "float",
+    "d": "double",
+    "B": "BOOL",
+    "v": "void",
+    "*": "char *",
+    "#": "Class",
+    ":": "SEL",
+    "?": "void /* unknown type (block/fn ptr) */",
+}
+
+_ARRAY_RE = re.compile(r"^\[(\d+)(.*)\]$")
+
+
+def read_one_type(encoding: str, i: int) -> tuple[str, int]:
+    """Read a single type-encoding token starting at `i`. Returns the token
+    text and the index just past it -- callers use this to walk a method's
+    full ``types`` string one argument at a time."""
+    start = i
+    while i < len(encoding) and encoding[i] in _MODIFIERS:
+        i += 1
+    if i >= len(encoding):
+        return encoding[start:i], i
+    c = encoding[i]
+    if c == "@":
+        i += 1
+        if i < len(encoding) and encoding[i] == '"':
+            end = encoding.find('"', i + 1)
+            i = (end + 1) if end != -1 else len(encoding)
+        return encoding[start:i], i
+    if c in "{(":
+        close = "}" if c == "{" else ")"
+        open_c = c
+        depth = 1
+        i += 1
+        while i < len(encoding) and depth:
+            if encoding[i] == open_c:
+                depth += 1
+            elif encoding[i] == close:
+                depth -= 1
+            i += 1
+        return encoding[start:i], i
+    if c == "[":
+        depth = 1
+        i += 1
+        while i < len(encoding) and depth:
+            if encoding[i] == "[":
+                depth += 1
+            elif encoding[i] == "]":
+                depth -= 1
+            i += 1
+        return encoding[start:i], i
+    if c == "^":
+        i += 1
+        _, i = read_one_type(encoding, i)
+        return encoding[start:i], i
+    return encoding[start : i + 1], i + 1
+
+
+def decode_type(encoding: str) -> str:
+    """Render one type-encoding token as a readable C/Objective-C type."""
+    encoding = encoding.lstrip(_MODIFIERS)
+    if not encoding:
+        return "?"
+    c = encoding[0]
+    if c in _SIMPLE:
+        return _SIMPLE[c]
+    if c == "@":
+        if encoding.startswith('@"'):
+            end = encoding.find('"', 2)
+            cls = encoding[2:end] if end != -1 else ""
+            if cls.startswith("<") and cls.endswith(">"):
+                return f"id<{cls[1:-1]}>"
+            return f"{cls} *" if cls else "id"
+        return "id"
+    if c == "^":
+        inner = decode_type(encoding[1:])
+        return inner if inner.endswith("*") else f"{inner} *"
+    if c == "{":
+        name = encoding[1:].split("=", 1)[0].split("}", 1)[0]
+        return f"struct {name}" if name else "struct"
+    if c == "(":
+        name = encoding[1:].split("=", 1)[0].split(")", 1)[0]
+        return f"union {name}" if name else "union"
+    if c == "[":
+        m = _ARRAY_RE.match(encoding)
+        if m:
+            count, inner = m.groups()
+            return f"{decode_type(inner)}[{count}]"
+    return encoding  # fallback: bitfields and anything else unrecognized
+
+
+def decode_method_signature(selector: str, encoding: str) -> str:
+    """Render `- (returnType)part1:(argType1)arg1 part2:(argType2)arg2` from
+    a selector and its method ``types`` encoding. Falls back to an untyped
+    signature (every arg as `id`) when the encoding is missing/unparseable --
+    e.g. a hook target the walker found via a string cross-check rather than
+    a fully decoded method list."""
+    parts = selector.split(":")
+    is_multi_arg = selector.endswith(":")
+    arg_labels = [p for p in parts if p] if is_multi_arg else []
+
+    if not encoding:
+        if not is_multi_arg:
+            return f"(id){selector}"
+        return " ".join(f"{label}:(id)arg{i + 1}" for i, label in enumerate(arg_labels))
+
+    i = 0
+    ret_tok, i = read_one_type(encoding, i)
+    ret = decode_type(ret_tok)
+    j = i
+    while j < len(encoding) and (encoding[j].isdigit() or encoding[j] == "-"):
+        j += 1
+    i = j
+
+    arg_types: list[str] = []
+    while i < len(encoding):
+        tok, i = read_one_type(encoding, i)
+        j = i
+        while j < len(encoding) and (encoding[j].isdigit() or encoding[j] == "-"):
+            j += 1
+        i = j
+        arg_types.append(tok)
+
+    real_args = arg_types[2:]  # skip self (@) and _cmd (:)
+    if not is_multi_arg:
+        return f"({ret}){selector}"
+    if len(real_args) != len(arg_labels):
+        # types string didn't decode cleanly (e.g. truncated data) -- keep the
+        # return type but fall back to untyped args rather than mismatching
+        return f"({ret})" + " ".join(f"{label}:(id)arg{i + 1}" for i, label in enumerate(arg_labels))
+    pieces = [
+        f"{label}:({decode_type(tok)})arg{i + 1}"
+        for i, (label, tok) in enumerate(zip(arg_labels, real_args, strict=True))
+    ]
+    return f"({ret})" + " ".join(pieces)

ipa_forge/bundle/__init__.py

@@ -0,0 +1 @@
+# SPDX-License-Identifier: GPL-3.0-or-later