PyPI - ipa-forge - Versions diffs - 0.1.0__py3-none-any.whl - Mend

ipa-forge 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (62) hide show

ipa_forge/__init__.py +1 -0
ipa_forge/altstore/__init__.py +1 -0
ipa_forge/altstore/source.py +44 -0
ipa_forge/analysis/__init__.py +18 -0
ipa_forge/analysis/classdump.py +103 -0
ipa_forge/analysis/diff.py +127 -0
ipa_forge/analysis/security.py +72 -0
ipa_forge/analysis/strings.py +40 -0
ipa_forge/analysis/symbols.py +42 -0
ipa_forge/analysis/type_encoding.py +164 -0
ipa_forge/bundle/__init__.py +1 -0
ipa_forge/bundle/inventory.py +96 -0
ipa_forge/bundle/ipa.py +81 -0
ipa_forge/bundle/models.py +58 -0
ipa_forge/bundle/plist.py +18 -0
ipa_forge/cli/__init__.py +1 -0
ipa_forge/cli/analysis.py +225 -0
ipa_forge/cli/common.py +41 -0
ipa_forge/cli/hooks.py +357 -0
ipa_forge/cli/main.py +170 -0
ipa_forge/gui/__init__.py +1 -0
ipa_forge/gui/analysis.html +229 -0
ipa_forge/gui/app.py +304 -0
ipa_forge/gui/index.html +244 -0
ipa_forge/hooks/__init__.py +0 -0
ipa_forge/hooks/scan.py +81 -0
ipa_forge/hooks/verify.py +348 -0
ipa_forge/machO/__init__.py +1 -0
ipa_forge/machO/arch.py +94 -0
ipa_forge/machO/detect.py +50 -0
ipa_forge/machO/injector.py +99 -0
ipa_forge/machO/objc.py +534 -0
ipa_forge/manifest.py +74 -0
ipa_forge/patch/__init__.py +1 -0
ipa_forge/patch/base.py +48 -0
ipa_forge/patch/binary.py +131 -0
ipa_forge/patch/dylib.py +59 -0
ipa_forge/patch/engine.py +48 -0
ipa_forge/patch/loader.py +88 -0
ipa_forge/patch/paths.py +19 -0
ipa_forge/patch/plist.py +61 -0
ipa_forge/patch/resolver.py +37 -0
ipa_forge/patch/resource.py +135 -0
ipa_forge/patch/schema.py +118 -0
ipa_forge/patch/version.py +25 -0
ipa_forge/patches.py +76 -0
ipa_forge/pipeline.py +235 -0
ipa_forge/signing/__init__.py +1 -0
ipa_forge/signing/backend.py +111 -0
ipa_forge/signing/pipeline.py +99 -0
ipa_forge/signing/profile.py +131 -0
ipa_forge/signing/provider.py +113 -0
ipa_forge/signing/reconcile.py +27 -0
ipa_forge/validators/__init__.py +1 -0
ipa_forge/validators/archive_validator.py +25 -0
ipa_forge/validators/bundle_validator.py +27 -0
ipa_forge/validators/ipa_validator.py +39 -0
ipa_forge-0.1.0.dist-info/METADATA +914 -0
ipa_forge-0.1.0.dist-info/RECORD +62 -0
ipa_forge-0.1.0.dist-info/WHEEL +4 -0
ipa_forge-0.1.0.dist-info/entry_points.txt +2 -0
ipa_forge-0.1.0.dist-info/licenses/LICENSE +674 -0

ipa_forge/gui/index.html ADDED Viewed

@@ -0,0 +1,244 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="color-scheme" content="light dark" />
+    <title>ipa-forge — Patch an IPA</title>
+    <style>
+      :root {
+        --accent: #0071e3;
+        --accent-hover: #0077ed;
+        --accent-press: #0068d6;
+        --bg: #f5f5f7;
+        --card: #ffffff;
+        --text: #1d1d1f;
+        --text-secondary: #6e6e73;
+        --border: rgba(0, 0, 0, 0.12);
+        --shadow: 0 8px 30px rgba(0, 0, 0, 0.08);
+        --success: #34c759;
+        --danger: #ff3b30;
+        --success-bg: rgba(52, 199, 89, 0.12);
+        --danger-bg: rgba(255, 59, 48, 0.12);
+        --danger-border: rgba(255, 59, 48, 0.5);
+      }
+      @media (prefers-color-scheme: dark) {
+        :root {
+          --bg: #000000;
+          --card: #1c1c1e;
+          --text: #f5f5f7;
+          --text-secondary: #98989d;
+          --border: rgba(255, 255, 255, 0.16);
+          --shadow: 0 8px 30px rgba(0, 0, 0, 0.6);
+          --accent: #0a84ff;
+          --accent-hover: #3a9bff;
+        }
+      }
+      * { box-sizing: border-box; }
+      body {
+        margin: 0;
+        font-family: -apple-system, "SF Pro Text", "Helvetica Neue", sans-serif;
+        background: var(--bg);
+        color: var(--text);
+        display: flex;
+        min-height: 100vh;
+        align-items: center;
+        justify-content: center;
+        padding: 24px;
+      }
+      .card {
+        background: var(--card);
+        border-radius: 18px;
+        box-shadow: var(--shadow);
+        padding: 32px;
+        width: 100%;
+        max-width: 460px;
+      }
+      h1 { font-size: 22px; margin: 0 0 4px; }
+      .subtitle { color: var(--text-secondary); font-size: 13px; margin: 0 0 20px; }
+      .subtitle a { color: var(--accent); }
+      .drop {
+        border: 2px dashed var(--border);
+        border-radius: 12px;
+        padding: 28px 16px;
+        text-align: center;
+        color: var(--text-secondary);
+        cursor: pointer;
+        transition: border-color 0.2s, color 0.2s;
+        font-size: 14px;
+      }
+      .drop.dragover, .drop:hover { border-color: var(--accent); color: var(--text); }
+      .drop .file-name { color: var(--text); font-weight: 600; word-break: break-all; }
+      .drop input { display: none; }
+      .status {
+        margin-top: 16px;
+        border-radius: 10px;
+        padding: 12px 14px;
+        font-size: 13px;
+        display: none;
+      }
+      .status.error { display: block; background: var(--danger-bg); border: 1px solid var(--danger-border); color: var(--danger); }
+      .status.info { display: block; background: var(--success-bg); border: 1px solid rgba(52,199,89,0.5); color: var(--success); }
+      .status.warn { display: block; background: rgba(255,149,0,0.12); border: 1px solid rgba(255,149,0,0.5); color: #ff9500; }
+      .status.warn b { color: var(--text); }
+      .detected { display: none; margin-top: 16px; font-size: 13px; }
+      .detected.show { display: block; }
+      .detected .row { display: flex; justify-content: space-between; padding: 6px 0; border-bottom: 1px solid var(--border); }
+      .detected .row:last-child { border-bottom: none; }
+      .detected .k { color: var(--text-secondary); }
+      .detected .v { font-weight: 600; }
+      button {
+        margin-top: 18px;
+        width: 100%;
+        padding: 14px;
+        border: none;
+        border-radius: 12px;
+        background: var(--accent);
+        color: #fff;
+        font-size: 15px;
+        font-weight: 600;
+        cursor: pointer;
+        transition: background 0.2s;
+      }
+      button:hover { background: var(--accent-hover); }
+      button:active { background: var(--accent-press); }
+      button:disabled { opacity: 0.5; cursor: default; }
+      .footnote { margin-top: 14px; color: var(--text-secondary); font-size: 12px; text-align: center; }
+      .download { margin-top: 14px; text-align: center; }
+      .download a { color: var(--accent); font-weight: 600; text-decoration: none; }
+    </style>
+  </head>
+  <body>
+    <div class="card">
+      <h1>ipa-forge</h1>
+      <p class="subtitle">
+        Select an IPA to patch it with the matching patch set. Output is unsigned — ready for AltStore.
+        Just want to inspect an IPA? <a href="/analysis">Reverse engineering tools</a>.
+      </p>
+      <div class="drop" id="drop">
+        <span id="dropText">Click or drop your .ipa file here</span>
+        <input type="file" id="file" accept=".ipa" />
+      </div>
+      <div class="status" id="status"></div>
+      <div class="detected" id="detected">
+        <div class="row"><span class="k">App</span><span class="v" id="dApp">–</span></div>
+        <div class="row"><span class="k">Version</span><span class="v" id="dVersion">–</span></div>
+        <div class="row"><span class="k">Patch set</span><span class="v" id="dPatchSet">–</span></div>
+        <div class="row"><span class="k">Targets</span><span class="v" id="dTarget">–</span></div>
+      </div>
+      <button id="patchBtn" disabled>Patch</button>
+      <div class="download" id="download"></div>
+      <p class="footnote">version mismatch shows a warning but patching still runs — hook verification is the safety net.</p>
+    </div>
+    <script>
+      const fileInput = document.getElementById("file");
+      const drop = document.getElementById("drop");
+      const dropText = document.getElementById("dropText");
+      const status = document.getElementById("status");
+      const detected = document.getElementById("detected");
+      const patchBtn = document.getElementById("patchBtn");
+      const download = document.getElementById("download");
+      let currentFile = null;
+      let currentPatchSet = null;
+      function showStatus(kind, html) {
+        status.className = "status " + kind;
+        status.innerHTML = html;
+      }
+      function setDetected(app, version, patchSet, target) {
+        detected.classList.add("show");
+        document.getElementById("dApp").textContent = app || "–";
+        document.getElementById("dVersion").textContent = version || "–";
+        document.getElementById("dPatchSet").textContent = patchSet || "none found";
+        document.getElementById("dTarget").textContent = target || "–";
+      }
+      async function analyze(file) {
+        showStatus("info", "Analyzing…");
+        download.innerHTML = "";
+        const fd = new FormData();
+        fd.append("ipa", file);
+        const res = await fetch("/detect", { method: "POST", body: fd });
+        const data = await res.json();
+        if (!res.ok) {
+          showStatus("error", data.error || "Could not read the IPA.");
+          patchBtn.disabled = true;
+          return;
+        }
+        const ps = data.patch_sets || [];
+        currentPatchSet = ps[0] ? ps[0].name : null;
+        setDetected(data.bundle_id, data.version, currentPatchSet || "none", ps[0] ? ps[0].target_version : "–");
+        if (!ps.length) {
+          showStatus("error", "No patch set found for <b>" + (data.bundle_id || "this app") + "</b>.");
+          patchBtn.disabled = true;
+        } else if (data.mismatch) {
+          showStatus(
+            "warn",
+            "Heads up: this patch set targets <b>" + ps[0].target_version + "</b> but your IPA is <b>" +
+              data.version + "</b>. The hooks gate will still verify everything — patching is allowed."
+          );
+          patchBtn.disabled = false;
+        } else {
+          showStatus("info", "Ready — patch set <b>" + currentPatchSet + "</b> matches.");
+          patchBtn.disabled = false;
+        }
+      }
+      drop.addEventListener("click", () => fileInput.click());
+      drop.addEventListener("dragover", (e) => { e.preventDefault(); drop.classList.add("dragover"); });
+      drop.addEventListener("dragleave", () => drop.classList.remove("dragover"));
+      drop.addEventListener("drop", (e) => {
+        e.preventDefault();
+        drop.classList.remove("dragover");
+        if (e.dataTransfer.files.length) {
+          currentFile = e.dataTransfer.files[0];
+          dropText.textContent = currentFile.name;
+          dropText.classList.add("file-name");
+          analyze(currentFile);
+        }
+      });
+      fileInput.addEventListener("change", () => {
+        if (fileInput.files.length) {
+          currentFile = fileInput.files[0];
+          dropText.textContent = currentFile.name;
+          dropText.classList.add("file-name");
+          analyze(currentFile);
+        }
+      });
+      patchBtn.addEventListener("click", async () => {
+        if (!currentFile || !currentPatchSet) return;
+        patchBtn.disabled = true;
+        showStatus("info", "Patching… (a 150 MB IPA takes a few minutes)");
+        download.innerHTML = "";
+        const fd = new FormData();
+        fd.append("ipa", currentFile);
+        fd.append("patch_set", currentPatchSet);
+        fd.append("no_sign", "true");
+        const res = await fetch("/patch", { method: "POST", body: fd });
+        const data = await res.json();
+        if (!res.ok) {
+          showStatus("error", data.error || "Patching failed.");
+          patchBtn.disabled = false;
+          return;
+        }
+        const manifest = data.manifest || {};
+        const applied = (manifest.patches_applied || []).filter((p) => p.status === "applied").length;
+        showStatus("info", "Patched — " + applied + " operation(s) applied.");
+        if (data.download_url) {
+          download.innerHTML = '<a href="' + data.download_url + '">Download patched IPA</a>';
+        }
+        patchBtn.disabled = false;
+      });
+    </script>
+  </body>
+</html>

ipa_forge/hooks/__init__.py ADDED Viewed

File without changes

ipa_forge/hooks/scan.py ADDED Viewed

@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Scan ObjC tweak sources for runtime hook calls.
+Recognizes ``<prefix>HookInstance/HookClass/AddInstanceMethod`` calls with an
+inline ``NSClassFromString(@"X")`` (or a file-scoped, unambiguous
+``cls = NSClassFromString(@"X")`` assignment), plus class names passed
+through a local resolver helper — any function whose body calls
+``NSClassFromString`` and that is invoked as ``resolver("X")`` at the hook
+call site (e.g. ``igHookInstance(igClass("YTSettings"), ...)``).
+Helper/loop-based hooks whose class is *passed into another function* before
+reaching the hook call (``hookParserNil(igClass("X"))`` → ``igHookInstance(cls,
+...)`` inside ``hookParserNil``) are not traced across function boundaries —
+declare those manually in the definition's ``hooks:`` block, exactly as the
+docs say.
+"""
+from __future__ import annotations
+import re
+from pathlib import Path
+from ipa_forge.hooks.verify import HookDecl
+_PATTERN = re.compile(
+    r"([A-Za-z_][A-Za-z0-9_]*)?(?:Hook(Instance|Class|ConfigBool)|AddInstanceMethod)"
+    r"\("
+    r"\s*(?:NSClassFromString\(@?\"([^\"]+)\"\)|\[\s*(\w+)\s*class\]|(\w+)|(\w+)\(@?\"([^\"]+)\"\))"
+    r"\s*,\s*(?:@selector\(([^)]+)\)|sel_registerName\(\"([^\"]+)\"\))"
+)
+_VAR_RE = re.compile(r"(\w+)\s*=\s*NSClassFromString\(@?\"([^\"]+)\"\)")
+# A class-resolver helper: a function returning Class whose body calls
+# NSClassFromString (simple single-expression bodies). Calls like
+# ``resolver("X")`` resolve X to a class name at the hook call site.
+_RESOLVER_RE = re.compile(r"(?:\bstatic\s+)?Class\s+(\w+)\s*\([^)]*\)\s*\{[^{}]*NSClassFromString")
+_RESOLVER_CALL_RE = re.compile(r"(\w+)\s*\(\s*@?\"([^\"]+)\"\s*\)")
+def scan_hook_sources(dylib_src: Path) -> list[HookDecl]:
+    """Scan ``*.m`` files under ``dylib_src`` and return hook declarations."""
+    decls: list[HookDecl] = []
+    for f in sorted(dylib_src.glob("*.m")):
+        text = f.read_text(errors="replace")
+        # map NSClassFromString assignments to their variable (file-scoped),
+        # only when unambiguous (a var assigned two different classes is
+        # untrustworthy — skip it)
+        var_class: dict[str, str] = {}
+        var_classes: dict[str, set[str]] = {}
+        for m in _VAR_RE.finditer(text):
+            var_classes.setdefault(m.group(1), set()).add(m.group(2))
+        for var, classes in var_classes.items():
+            if len(classes) == 1:
+                var_class[var] = next(iter(classes))
+        # resolver helpers: functions whose body calls NSClassFromString
+        resolvers = {m.group(1) for m in _RESOLVER_RE.finditer(text)}
+        resolver_class: dict[str, str] = {}
+        if resolvers:
+            for m in _RESOLVER_CALL_RE.finditer(text):
+                if m.group(1) in resolvers:
+                    resolver_class[m.group(1)] = m.group(2)
+        for m in _PATTERN.finditer(text):
+            _prefix, kind, cls, cls2, clsvar, clsfn, clsarg, sel, sel2 = m.groups()
+            is_add = kind is None  # AddInstanceMethod branch
+            cls = cls or cls2 or var_class.get(clsvar or "") or (resolver_class.get(clsfn or "") if clsfn else "")
+            sel = sel or sel2
+            if not cls or not sel:
+                continue
+            hook_kind = "class" if kind == "Class" else "instance"  # ConfigBool hooks the getter -> instance
+            decls.append(HookDecl(cls, sel, hook_kind, added=is_add))  # type: ignore[arg-type]
+    # de-duplicate, keep first-seen order
+    seen: set[tuple[str, str]] = set()
+    unique: list[HookDecl] = []
+    for d in decls:
+        if (d.class_name, d.selector) in seen:
+            continue
+        seen.add((d.class_name, d.selector))
+        unique.append(d)
+    return unique

ipa_forge/hooks/verify.py ADDED Viewed

@@ -0,0 +1,348 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Hook verification: classify each declared hook against a MachOAnalysis.
+Statuses:
+- ``ok`` — class parsed and selector found on the class or an ancestor.
+- ``ok-system`` — class is a system-framework class (not in the app's
+  classlist) and the selector is referenced somewhere in the app binary.
+- ``added`` — declared ``added: true`` (the tweak adds the method); absence
+  is the expected state and counts as a pass.
+- ``missing-class`` — class absent from the app entirely (renamed/removed).
+- ``missing-selector`` — class present but the selector is nowhere in the
+  binary: the hook would attach but never fire.
+- ``elsewhere`` — selector exists in the binary but not on this class or its
+  ancestors: the hook would silently no-op on this class.
+``required`` hooks that resolve to a failure status fail the run; the rest
+are reported as warnings so porting to a new version is guided, not blocked.
+"""
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Literal
+from ipa_forge.machO.objc import MachOAnalysis, contains_string
+HookStatus = Literal[
+    "ok",
+    "ok-system",
+    "ok-inherited",
+    "added",
+    "missing-class",
+    "missing-selector",
+    "elsewhere",
+    "referenced-only",
+    "unverified",
+]
+_SYSTEM_PREFIXES = ("NS", "UI", "CA", "AV", "MP", "CF", "CG", "SK", "_", "TUI")
+# Selectors hooks commonly target that are defined on system superclasses
+# (UIView/UIButton/UIViewController etc.) — not visible in the app's class
+# method lists, but inherited at runtime, so the hook attaches fine.
+_SYSTEM_SELECTORS = {
+    "init",
+    "dealloc",
+    "layoutSubviews",
+    "didMoveToWindow",
+    "viewDidAppear:",
+    "viewDidLoad",
+    "viewDidDisappear:",
+    "setHidden:",
+    "setFrame:",
+    "setBackgroundColor:",
+    "setEnabled:",
+    "sizeThatFits:",
+    "titleLabel",
+    "setTitle:forState:",
+    "addGestureRecognizer:",
+    "setDelegate:",
+    "setUserInteractionEnabled:",
+    "setAlpha:",
+    "setNeedsLayout",
+    "removeFromSuperview",
+    "setText:",
+    "setOn:",
+    "setAccessibilityIdentifier:",
+    "setValue:forKey:",
+    "didMoveToSuperview",
+    # UIResponder event-handling methods -- every UIView/UIViewController
+    # inherits a default implementation, so hooking one on an app class whose
+    # superclass chain ends external (UIViewController/UIView) attaches fine
+    # even though no app class overrides it. Found via a real false-positive
+    # `elsewhere` classification on IGRootViewController -[motionEnded:
+    # withEvent:] (a shake-gesture hook): the selector is only implemented on
+    # unrelated UIWindow/UIApplication subclasses in that binary, which the
+    # ancestry walk (rightly) doesn't associate with a UIViewController.
+    "motionEnded:withEvent:",
+    "touchesBegan:withEvent:",
+    "touchesMoved:withEvent:",
+    "touchesEnded:withEvent:",
+    "touchesCancelled:withEvent:",
+    "pressesBegan:withEvent:",
+    "pressesEnded:withEvent:",
+    "pressesCancelled:withEvent:",
+    "remoteControlReceivedWithEvent:",
+}
+@dataclass
+class HookDecl:
+    class_name: str
+    selector: str
+    kind: Literal["instance", "class"] = "instance"
+    added: bool = False
+    required: bool = False
+@dataclass
+class HookResult:
+    class_name: str
+    selector: str
+    kind: Literal["instance", "class"]
+    status: HookStatus
+    detail: str = ""
+    required: bool = False
+    @property
+    def ok(self) -> bool:
+        return self.status in ("ok", "ok-system", "ok-inherited", "added")
+def _is_system_class(name: str) -> bool:
+    return name.startswith(_SYSTEM_PREFIXES) or name in (
+        "UITableViewCell",
+        "UIColor",
+        "UIFont",
+        "UIWindow",
+        "UIView",
+        "UIViewController",
+    )
+def _ancestry(analysis: MachOAnalysis, name: str) -> list[str]:
+    chain: list[str] = []
+    seen: set[str] = set()
+    cur: str | None = name
+    while cur and cur in analysis.classes and cur not in seen:
+        seen.add(cur)
+        chain.append(cur)
+        cur = analysis.classes[cur].super_name
+        if cur is None:
+            break
+    return chain
+def verify_hooks(analysis: MachOAnalysis, hooks: list[HookDecl]) -> list[HookResult]:
+    results: list[HookResult] = []
+    for hook in hooks:
+        cls = hook.class_name
+        sel = hook.selector
+        mc = analysis.classes.get(cls)
+        if hook.added:
+            # The tweak ADDS the method. If the binary references the selector
+            # (selrefs) but no class implements it, the app is calling into a
+            # hole that this add fills — exactly the intended state.
+            if sel in analysis.selectors:
+                results.append(
+                    HookResult(
+                        cls, sel, hook.kind, "ok", "app references this selector; the tweak provides it", hook.required
+                    )
+                )
+            else:
+                results.append(
+                    HookResult(
+                        cls, sel, hook.kind, "added", "method added by the tweak; absence expected", hook.required
+                    )
+                )
+            continue
+        if mc is None:
+            if cls in analysis.classnames:
+                results.append(
+                    HookResult(
+                        cls,
+                        sel,
+                        hook.kind,
+                        "unverified",
+                        "class exists (classname section) but the walk missed it (likely attaches)",
+                        hook.required,
+                    )
+                )
+            elif cls.startswith("_Tt"):
+                # Swift-mangled class absent from the parsed table. Not a
+                # system class — labelling it ok-system would hide drift. The
+                # hook may well attach (the walk misses Swift classes too), so
+                # report honestly instead.
+                results.append(
+                    HookResult(
+                        cls,
+                        sel,
+                        hook.kind,
+                        "unverified",
+                        "Swift class not in the parsed class table (mangled name; the walk missed it)",
+                        hook.required,
+                    )
+                )
+            elif _is_system_class(cls):
+                if sel in analysis.selectors or sel in _SYSTEM_SELECTORS:
+                    results.append(
+                        HookResult(
+                            cls,
+                            sel,
+                            hook.kind,
+                            "ok-system",
+                            "system class; selector referenced by the app or a known system API",
+                            hook.required,
+                        )
+                    )
+                else:
+                    results.append(
+                        HookResult(
+                            cls,
+                            sel,
+                            hook.kind,
+                            "unverified",
+                            "system class; selector not referenced by the app binary",
+                            hook.required,
+                        )
+                    )
+            else:
+                if contains_string(analysis, cls):
+                    # The name exists as a standalone cstring in some image but
+                    # the class-table walk missed it — a parser gap, not a
+                    # rename. Soft-fail instead of calling it missing.
+                    results.append(
+                        HookResult(
+                            cls,
+                            sel,
+                            hook.kind,
+                            "unverified",
+                            "class-name string present in a binary image but the class-table walk missed "
+                            "it (likely attaches)",
+                            hook.required,
+                        )
+                    )
+                else:
+                    results.append(
+                        HookResult(cls, sel, hook.kind, "missing-class", "class not found in the binary", hook.required)
+                    )
+            continue
+        # class present — walk the ancestry for the selector
+        chain = _ancestry(analysis, cls)
+        pool = "cls" if hook.kind == "class" else "inst"
+        found = False
+        found_at: str | None = None
+        for ancestor in chain:
+            methods = getattr(analysis.classes[ancestor], pool)
+            if sel in methods:
+                found = True
+                found_at = ancestor
+                break
+        if found:
+            if found_at == cls:
+                results.append(HookResult(cls, sel, hook.kind, "ok", f"on {cls}", hook.required))
+            else:
+                results.append(
+                    HookResult(cls, sel, hook.kind, "ok-inherited", f"inherited from {found_at}", hook.required)
+                )
+            continue
+        # Not in the parsed hierarchy. Two soft cases before we call it broken:
+        # (a) a system superclass method (UIView etc.) — attaches via inheritance;
+        # (b) the selector exists in the binary but the parser missed the method
+        #     list entry (chained-fixup decode gaps) — likely on this class.
+        chain_classes = [analysis.classes[c] for c in chain]
+        ends_in_system = any(
+            (c.super_name == "«external»" or (c.super_name or "").startswith(("NS", "UI"))) for c in chain_classes
+        )
+        if sel in _SYSTEM_SELECTORS and ends_in_system:
+            results.append(
+                HookResult(
+                    cls,
+                    sel,
+                    hook.kind,
+                    "ok-inherited",
+                    "system superclass method (attaches via inheritance)",
+                    hook.required,
+                )
+            )
+            continue
+        if sel in analysis.selectors:
+            pool_of = "cls" if hook.kind == "class" else "inst"
+            parsed_anywhere = any(sel in getattr(c, pool_of) for c in analysis.classes.values())
+            if parsed_anywhere:
+                results.append(
+                    HookResult(
+                        cls,
+                        sel,
+                        hook.kind,
+                        "elsewhere",
+                        "selector exists in the binary but not on this class/ancestors (hook would no-op)",
+                        hook.required,
+                    )
+                )
+            elif sel in analysis.methnames:
+                # Declared as a method name somewhere (a protocol, category or a
+                # method list the walker did not decode) — the hook may well
+                # attach; keep it soft.
+                results.append(
+                    HookResult(
+                        cls,
+                        sel,
+                        hook.kind,
+                        "unverified",
+                        "selector declared as a method somewhere (protocol/category/undecoded list) "
+                        "but not in any parsed class method list (likely attaches)",
+                        hook.required,
+                    )
+                )
+            else:
+                # Referenced (NSSelectorFromString/performSelector/optional
+                # protocol sends) but declared as NO method anywhere in the
+                # binary — no IMP exists to swizzle, so class_getInstanceMethod
+                # returns NULL and the hook cannot attach.
+                results.append(
+                    HookResult(
+                        cls,
+                        sel,
+                        hook.kind,
+                        "referenced-only",
+                        "selector referenced by the binary but not declared as a method anywhere "
+                        "(no IMP to swizzle; the hook cannot attach unless a system superclass provides it)",
+                        hook.required,
+                    )
+                )
+        else:
+            if contains_string(analysis, sel):
+                results.append(
+                    HookResult(
+                        cls,
+                        sel,
+                        hook.kind,
+                        "unverified",
+                        "selector string present in a binary image but not in any parsed method list "
+                        "(parser may have missed it)",
+                        hook.required,
+                    )
+                )
+            else:
+                results.append(
+                    HookResult(
+                        cls,
+                        sel,
+                        hook.kind,
+                        "missing-selector",
+                        "selector not found anywhere in the binary",
+                        hook.required,
+                    )
+                )
+    return results
+def failing(results: list[HookResult]) -> list[HookResult]:
+    return [r for r in results if not r.ok]

ipa_forge/machO/__init__.py ADDED Viewed

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