ipa-forge 0.1.0__py3-none-any.whl

ipa_forge/patch/schema.py

@@ -0,0 +1,118 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Pydantic schema for the external YAML/JSON patch-definition contract.
+
+The core engine understands these operation *types* but never a specific
+bundle id or byte pattern -- those only ever live in user-supplied definition
+files.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated, Any, Literal
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class VersionExact(BaseModel):
+    exact: str
+
+
+class VersionRange(BaseModel):
+    min: str | None = None
+    max: str | None = None
+
+
+class TargetSpec(BaseModel):
+    bundle_id: str
+    version: VersionExact | VersionRange
+
+
+class BinaryReplaceSpec(BaseModel):
+    type: Literal["binary_replace"]
+    id: str
+    executable: str
+    pattern: str
+    replacement: str
+    expected_matches: int = 1
+    arch: str | None = None
+
+
+class ResourceReplaceSpec(BaseModel):
+    type: Literal["resource_replace"]
+    id: str
+    path: str
+    source: str
+
+
+class ResourceAddSpec(BaseModel):
+    type: Literal["resource_add"]
+    id: str
+    path: str
+    source: str
+
+
+class ResourceRemoveSpec(BaseModel):
+    type: Literal["resource_remove"]
+    id: str
+    path: str
+
+
+class DylibInjectSpec(BaseModel):
+    type: Literal["dylib_inject"]
+    id: str
+    executable: str
+    # The load path to add as an LC_LOAD_DYLIB/LC_LOAD_WEAK_DYLIB entry (e.g.
+    # "@rpath/libFoo.dylib"), not a source file to copy in -- getting the
+    # dylib itself into the bundle is a separate resource_add operation, so
+    # this stays a single-responsibility Mach-O load-command edit.
+    install_name: str
+    arch: str | None = None
+    load_command: Literal["LC_LOAD_DYLIB", "LC_LOAD_WEAK_DYLIB"] = "LC_LOAD_DYLIB"
+
+
+class PlistEditSpec(BaseModel):
+    type: Literal["plist_edit"]
+    id: str
+    action: Literal["set", "remove"]
+    key: str
+    value: Any = None
+    path: str = "Info.plist"
+
+    @model_validator(mode="after")
+    def _value_required_for_set(self) -> PlistEditSpec:
+        if self.action == "set" and self.value is None:
+            raise ValueError("plist_edit with action 'set' requires a non-null 'value'")
+        return self
+
+
+PatchSpec = Annotated[
+    BinaryReplaceSpec | ResourceReplaceSpec | ResourceAddSpec | ResourceRemoveSpec | DylibInjectSpec | PlistEditSpec,
+    Field(discriminator="type"),
+]
+
+
+class HookSpec(BaseModel):
+    """Declare a runtime hook the patch set relies on, so `forge` can verify
+    it against the actual binary and catch silent no-ops on version drift."""
+
+    class_name: str = Field(alias="class")
+    selector: str
+    kind: Literal["instance", "class"] = "instance"
+    added: bool = False
+    """True when the tweak adds the method itself (logos' %new) -- absence is
+    expected and counts as a pass; presence in selrefs confirms the app calls it."""
+    required: bool = False
+    """Fail the run when this hook can't attach (missing class/selector or
+    selector-only-elsewhere). Non-required hooks only warn."""
+
+    model_config = {"populate_by_name": True}
+
+
+class PatchDefinition(BaseModel):
+    target: TargetSpec
+    patches: list[PatchSpec] = Field(
+        min_length=1, description="At least one operation -- an empty definition is always a mistake."
+    )
+    hooks: list[HookSpec] | None = None
+    """Runtime hook targets to verify against the binary before patching;
+    catches silent hook no-ops when a new app version renames/removes classes."""

ipa_forge/patch/version.py

@@ -0,0 +1,25 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Minimal dotted-version comparison for CFBundleShortVersionString matching.
+
+Non-numeric segments are stripped ("1.0.0-beta" parses to (1, 0, 0)), so
+range matching treats suffixed and clean versions as equal. `VersionExact` in
+patch/schema.py deliberately uses raw string equality instead -- exact:
+"1.0.0" will not match a bundle whose version is "1.0.0-beta".
+"""
+
+from __future__ import annotations
+
+
+def _parse_segment(digits: str) -> int:
+    try:
+        return int(digits)
+    except ValueError:  # unreachable: digits is already filtered to [0-9]
+        return 0
+
+
+def parse_version(v: str) -> tuple[int, ...]:
+    parts = []
+    for segment in v.split("."):
+        digits = "".join(ch for ch in segment if ch.isdigit())
+        parts.append(_parse_segment(digits))
+    return tuple(parts)

ipa_forge/patches.py

@@ -0,0 +1,76 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Patch-set registry: one canonical definition per app.
+
+The layout convention: ``patches/<app>/<app>.yaml`` (version lives *inside*
+the definition's ``target.version``, not in the directory name). The GUI and
+CLI use this to discover which patch set applies to a given IPA and to warn
+on version mismatch without blocking.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from ipa_forge.patch.loader import PatchLoadError, load_patch_definition
+from ipa_forge.patch.schema import VersionExact
+
+_DEFAULT_PATCHES_DIR = Path(__file__).resolve().parent.parent / "patches"
+
+
+def patches_root() -> Path:
+    """The patch-set root; overridable via IPA_FORGE_PATCHES_DIR (tests use
+    a temporary tree instead of the repo's patch sets)."""
+    import os
+
+    override = os.environ.get("IPA_FORGE_PATCHES_DIR")
+    return Path(override) if override else _DEFAULT_PATCHES_DIR
+
+
+@dataclass(frozen=True)
+class PatchSet:
+    name: str  # directory name, e.g. "youtube"
+    definition: Path  # path to the canonical <app>.yaml
+    bundle_id: str
+    version_spec: str  # "exact: 21.32.4" or "min: … max: …" summary
+
+    @property
+    def version_exact(self) -> str | None:
+        # only exact specs are interesting for the GUI warning
+        spec = self.version_spec
+        return spec.split("exact: ", 1)[1].strip("'\"") if "exact:" in spec else None
+
+
+def discover_patch_sets(patches_dir: Path | None = None) -> list[PatchSet]:
+    """Scan ``patches/*/<name>.yaml`` (the canonical definition per app)."""
+    base = patches_dir or patches_root()
+    if not base.is_dir():
+        return []
+    sets: list[PatchSet] = []
+    for app_dir in sorted(base.iterdir()):
+        if not app_dir.is_dir() or app_dir.name.startswith("."):
+            continue
+        candidate = app_dir / f"{app_dir.name}.yaml"
+        if not candidate.is_file():
+            continue
+        try:
+            definition = load_patch_definition(candidate)
+        except PatchLoadError:
+            continue  # not a definition we can parse; skip
+        version = definition.target.version
+        spec = (
+            f"exact: {version.exact}" if isinstance(version, VersionExact) else f"min: {version.min} max: {version.max}"
+        )
+        sets.append(
+            PatchSet(
+                name=app_dir.name,
+                definition=candidate,
+                bundle_id=definition.target.bundle_id,
+                version_spec=spec,
+            )
+        )
+    return sets
+
+
+def find_patch_sets_for_bundle(bundle_id: str, patches_dir: Path | None = None) -> list[PatchSet]:
+    return [p for p in discover_patch_sets(patches_dir) if p.bundle_id == bundle_id]

ipa_forge/pipeline.py

@@ -0,0 +1,235 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""End-to-end pipeline orchestration: the 17 stages described in the
+architecture doc, from raw .ipa in to AltStore-Classic-ready .ipa out.
+"""
+
+from __future__ import annotations
+
+import tempfile
+import warnings
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from ipa_forge.bundle.ipa import extract_ipa, load_bundle, repack_ipa
+from ipa_forge.bundle.models import AppBundle
+from ipa_forge.hooks.verify import HookDecl, verify_hooks
+from ipa_forge.hooks.verify import failing as hook_failures
+from ipa_forge.machO.objc import analyze_bundle
+from ipa_forge.manifest import Manifest, ProfileManifestEntry, sha256_of
+from ipa_forge.patch.base import PatchContext
+from ipa_forge.patch.engine import apply_all, dry_run_all
+from ipa_forge.patch.loader import PatchLoadError, build_operations, load_patch_definition
+from ipa_forge.patch.resolver import resolve_definitions
+from ipa_forge.patch.schema import PatchDefinition
+from ipa_forge.signing.backend import SigningBackendError
+from ipa_forge.signing.pipeline import sign_bundle, sign_target_path
+from ipa_forge.signing.profile import ProfileError, load_profile_pool, validate_profile
+from ipa_forge.signing.provider import LocalIdentityProvider, SigningProvider, VerifyResult, resolve_identity
+from ipa_forge.validators.archive_validator import validate_final_archive
+from ipa_forge.validators.bundle_validator import validate_bundle
+from ipa_forge.validators.ipa_validator import IpaValidationError, validate_ipa_structure
+
+
+class PipelineError(Exception):
+    pass
+
+
+@dataclass
+class PipelineResult:
+    manifest: Manifest
+    output_path: Path | None
+    verify_results: list[VerifyResult] = field(default_factory=list)
+
+
+def _hook_decls(definition: PatchDefinition) -> list[HookDecl]:
+    return [
+        HookDecl(
+            class_name=h.class_name,
+            selector=h.selector,
+            kind=h.kind,
+            added=h.added,
+            required=h.required,
+        )
+        for h in (definition.hooks or [])
+    ]
+
+
+def _verify_definition_hooks(bundle: AppBundle, definition: PatchDefinition) -> list[dict[str, object]]:
+    """Verify the definition's declared hooks against the app's main binary.
+    Returns the hook report (list of dicts). Raises PipelineError when a
+    required hook cannot attach."""
+    decls = _hook_decls(definition)
+    if not decls:
+        return []
+    analysis = analyze_bundle(bundle)
+    results = verify_hooks(analysis, decls)
+    bad_required = [r for r in hook_failures(results) if r.required]
+    if bad_required:
+        detail = "; ".join(f"{r.class_name} {r.selector}: {r.status} ({r.detail})" for r in bad_required)
+        raise PipelineError(f"required hook verification failed: {detail}")
+    return [
+        {
+            "class": r.class_name,
+            "selector": r.selector,
+            "kind": r.kind,
+            "status": r.status,
+            "detail": r.detail,
+            "required": r.required,
+        }
+        for r in results
+    ]
+
+
+def run_pipeline(
+    ipa_path: Path,
+    patch_definition_path: Path,
+    identity_query: str,
+    profile_paths: list[Path],
+    output_path: Path,
+    *,
+    provider: SigningProvider | None = None,
+    dry_run: bool = False,
+    no_sign: bool = False,
+    allow_version_mismatch: bool = False,
+) -> PipelineResult:
+    """profile_paths accepts one or more .mobileprovision files. A single
+    profile signs every target, exactly as before per-extension profiles
+    existed. Supplying more than one lets nested app extensions / watch apps
+    be matched and signed with their own profile by their own bundle id --
+    see signing/pipeline.py::sign_bundle and signing/profile.py::ProfilePool."""
+    provider = provider or LocalIdentityProvider()
+
+    with tempfile.TemporaryDirectory(prefix="ipa_forge_") as tmp:
+        work_dir = Path(tmp)
+
+        # Stages 1-3: validate + extract, inventory, parse Info.plist
+        try:
+            validate_ipa_structure(ipa_path)
+        except IpaValidationError as e:
+            raise PipelineError(str(e)) from e
+        app_path = extract_ipa(ipa_path, work_dir / "extracted")
+        bundle = load_bundle(app_path)
+        validate_bundle(bundle)
+
+        # Stage 4: resolve applicable patch definitions (bundle_id + version match)
+        try:
+            definition = load_patch_definition(patch_definition_path)
+        except PatchLoadError as e:
+            raise PipelineError(str(e)) from e
+        matched = resolve_definitions(bundle, [definition], ignore_version=allow_version_mismatch)
+        ops = [op for d in matched for op in build_operations(d)]
+        if not ops:
+            # F1: a single user-supplied definition that matches nothing is
+            # almost always a mistake (typo'd bundle id or version range).
+            # Warn in dry-run so version-gate checks still work; refuse to
+            # produce an unpatched IPA in a real run.
+            warnings.warn(
+                f"patch definition '{patch_definition_path}' matches 0 patch operations for "
+                f"{bundle.bundle_id} v{bundle.version} (definition targets "
+                f"{definition.target.bundle_id}); nothing will be applied",
+                stacklevel=2,
+            )
+            if not dry_run:
+                raise PipelineError(
+                    f"patch definition '{patch_definition_path}' matches no operations for "
+                    f"{bundle.bundle_id} v{bundle.version} (definition targets "
+                    f"{definition.target.bundle_id}); refusing to produce an unpatched IPA"
+                )
+
+        if (
+            allow_version_mismatch
+            and bundle.bundle_id == definition.target.bundle_id
+            and bundle.version != getattr(definition.target.version, "exact", None)
+        ):
+            warnings.warn(
+                f"version mismatch allowed: definition targets "
+                f"{definition.target.bundle_id} "
+                f"{getattr(definition.target.version, 'exact', '?')} but the IPA is "
+                f"{bundle.bundle_id} v{bundle.version}; hook verification below "
+                f"is the safety net",
+                stacklevel=2,
+            )
+
+        # Stage 4.5: verify declared runtime hooks against the actual binary --
+        # catches silent hook no-ops on version drift before anything mutates.
+        hook_report = _verify_definition_hooks(bundle, definition)
+        ctx = PatchContext(bundle=bundle, patch_source_dir=patch_definition_path.parent)
+
+        # Stage 5: dry-run gate -- hard fail before anything mutates
+        dry_results = dry_run_all(ops, ctx)
+        failed_dry = [r for r in dry_results if r.status != "dry_run_ok"]
+        if failed_dry:
+            raise PipelineError(
+                "patch dry-run validation failed: " + "; ".join(f"{r.op_id}: {r.message}" for r in failed_dry)
+            )
+
+        if dry_run:
+            manifest = Manifest.from_patch_results(
+                ipa_path, bundle.bundle_id, bundle.version, bundle.build, dry_results
+            )
+            manifest.hook_report = hook_report
+            return PipelineResult(manifest=manifest, output_path=None)
+
+        # Stages 6-8: apply resources -> binary patches -> dylib injection (fixed order)
+        results = apply_all(ops, ctx)
+        failed_apply = [r for r in results if r.status == "failed"]
+        if failed_apply:
+            raise PipelineError(
+                "patch application failed: " + "; ".join(f"{r.op_id}: {r.message}" for r in failed_apply)
+            )
+
+        # Stage 9: re-validate bundle consistency post-mutation
+        validate_bundle(bundle)
+
+        # Stage 10: emit manifest, before signing
+        manifest = Manifest.from_patch_results(ipa_path, bundle.bundle_id, bundle.version, bundle.build, results)
+        manifest.hook_report = hook_report
+
+        if no_sign:
+            # Unsigned output for AltStore-style installers, which perform
+            # their own signing (and profile generation) at install time.
+            # The payload is patched but carries no code signature, matching
+            # what AltStore Classic accepts as input.
+            repack_ipa(bundle.extraction_root, output_path)
+            validate_final_archive(output_path, work_dir / "final_check", expect_profile=False)
+            manifest.output_sha256 = sha256_of(output_path)
+            return PipelineResult(manifest=manifest, output_path=output_path)
+
+        try:
+            # Stage 11: load + validate provisioning profile(s)
+            profiles = load_profile_pool(profile_paths)
+            main_profile, _ = profiles.select_for(bundle.bundle_id)
+            validate_profile(main_profile, bundle.bundle_id)
+            manifest.profile = ProfileManifestEntry(
+                uuid=main_profile.uuid,
+                team_id=main_profile.team_identifier,
+                expiration=str(main_profile.expiration_date),
+            )
+
+            # Stages 12-13 (entitlement reconciliation + profile embedding, per
+            # target -- each profile-bearing target selects its own profile by
+            # its own bundle id) and stage 14 (recursive bottom-up codesign):
+            identity = resolve_identity(provider, identity_query)
+            sign_bundle(bundle, provider, identity, profiles)
+
+            # Stage 15: verify every signed bundle/dylib, then a final deep+strict pass on the app bundle
+            sign_paths = {sign_target_path(t) for t in bundle.executables}
+            sign_paths.discard(bundle.root)
+            verify_results = [provider.verify(p) for p in sign_paths]
+            verify_results.append(provider.verify(bundle.root, deep=True))
+            failed_verify = [v for v in verify_results if not v.ok]
+            if failed_verify:
+                raise PipelineError(
+                    "codesign verification failed: " + "; ".join(f"{v.target}: {v.message}" for v in failed_verify)
+                )
+        except (ProfileError, SigningBackendError) as e:
+            raise PipelineError(str(e)) from e
+
+        # Stage 16: repackage
+        repack_ipa(bundle.extraction_root, output_path)
+
+        # Stage 17: final validation -- re-extract the produced IPA from scratch
+        validate_final_archive(output_path, work_dir / "final_check")
+
+        manifest.output_sha256 = sha256_of(output_path)
+        return PipelineResult(manifest=manifest, output_path=output_path, verify_results=verify_results)

ipa_forge/signing/__init__.py

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

ipa_forge/signing/backend.py

@@ -0,0 +1,111 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""The only module in ipa_forge permitted to invoke codesign/security directly.
+
+Per the architecture's hard constraint, Apple's code signature format is never
+reimplemented -- everything here shells out to Apple's own tooling.
+"""
+
+from __future__ import annotations
+
+import plistlib
+import re
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+class SigningBackendError(Exception):
+    pass
+
+
+@dataclass
+class Identity:
+    sha1: str
+    name: str
+
+
+_IDENTITY_LINE = re.compile(r'^\s*\d+\)\s+([0-9A-Fa-f]{40})\s+"(.+)"$')
+
+
+def list_identities() -> list[Identity]:
+    result = subprocess.run(
+        ["security", "find-identity", "-v", "-p", "codesigning"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        raise SigningBackendError(f"security find-identity failed: {result.stderr}")
+
+    identities = []
+    for line in result.stdout.splitlines():
+        m = _IDENTITY_LINE.match(line)
+        if m:
+            identities.append(Identity(sha1=m.group(1), name=m.group(2)))
+    return identities
+
+
+def decode_provisioning_profile(path: Path) -> dict[str, Any]:
+    """Decode a .mobileprovision (a CMS-signed plist) via `security cms -D -i`,
+    per Apple's own recommended inspection procedure."""
+    result = subprocess.run(
+        ["security", "cms", "-D", "-i", str(path)],
+        capture_output=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        raise SigningBackendError(
+            f"failed to decode provisioning profile {path}: {result.stderr.decode(errors='replace')}"
+        )
+    return plistlib.loads(result.stdout)
+
+
+def codesign_sign(target: Path, identity: str, entitlements_plist: Path) -> None:
+    result = subprocess.run(
+        [
+            "codesign",
+            "--force",
+            "--sign",
+            identity,
+            "--entitlements",
+            str(entitlements_plist),
+            str(target),
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        raise SigningBackendError(f"codesign failed for {target}: {result.stderr}")
+
+
+def codesign_verify(target: Path, deep: bool = False) -> None:
+    args = ["codesign", "--verify"]
+    if deep:
+        args.append("--deep")
+    args += ["--strict", "--verbose=4", str(target)]
+    result = subprocess.run(args, capture_output=True, text=True, check=False)
+    if result.returncode != 0:
+        raise SigningBackendError(f"codesign verification failed for {target}: {result.stderr}")
+
+
+def codesign_dump_entitlements(target: Path) -> dict[str, Any]:
+    # `:-` is deprecated by Apple in favor of plain `-` but is the only form
+    # that emits a directly-parseable plist to stdout on current codesign;
+    # `-` emits a human-readable dump instead. Revisit if Apple removes it.
+    result = subprocess.run(
+        ["codesign", "-d", "--entitlements", ":-", str(target)],
+        capture_output=True,
+        check=False,
+    )
+    stderr = result.stderr.decode(errors="replace")
+    if result.returncode != 0:
+        if "code object is not signed at all" in stderr:
+            # Expected for a freshly extracted IPA before our own signing pass
+            # has run -- not an error, just "no entitlements yet".
+            return {}
+        raise SigningBackendError(f"failed to dump entitlements for {target}: {stderr}")
+    if not result.stdout.strip():
+        return {}
+    return plistlib.loads(result.stdout)

ipa_forge/signing/pipeline.py

@@ -0,0 +1,99 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Recursive bottom-up signing orchestration + per-bundle provisioning-profile embedding."""
+
+from __future__ import annotations
+
+import shutil
+import warnings
+from pathlib import Path
+
+from ipa_forge.bundle.models import AppBundle, MachOTarget
+from ipa_forge.signing.profile import ProfilePool
+from ipa_forge.signing.provider import SigningProvider, SignResult
+from ipa_forge.signing.reconcile import reconcile_entitlements
+
+_BUNDLE_SUFFIX_BY_KIND = {"main": ".app", "framework": ".framework", "appex": ".appex", "watch_app": ".app"}
+
+# Kinds that own their own Info.plist and can therefore carry their own
+# embedded.mobileprovision. Frameworks/dylibs/other are signed but never
+# embed a profile of their own.
+_PROFILE_BEARING_KINDS = {"main", "appex", "watch_app"}
+
+
+def sign_target_path(target: MachOTarget) -> Path:
+    """The path codesign should actually be pointed at for this target.
+
+    Bundle-kind executables (main app, frameworks, extensions, watch apps)
+    must be signed via their *bundle directory*, not the raw executable file
+    -- otherwise codesign never creates the bundle-level _CodeSignature/
+    CodeResources seal covering Info.plist and other resources, and a later
+    `--verify --strict` on the bundle fails with "a sealed resource is
+    missing or invalid". Flat dylibs (not wrapped in a bundle) are signed
+    directly.
+    """
+    suffix = _BUNDLE_SUFFIX_BY_KIND.get(target.kind)
+    if suffix is None:
+        return target.path
+    for parent in target.path.parents:
+        if parent.name.endswith(suffix):
+            return parent
+    return target.path
+
+
+def embed_provisioning_profile(bundle_dir: Path, profile_path: Path) -> None:
+    dest = bundle_dir / "embedded.mobileprovision"
+    shutil.copyfile(profile_path, dest)
+
+
+def sign_bundle(
+    bundle: AppBundle,
+    provider: SigningProvider,
+    identity: str,
+    profiles: ProfilePool,
+) -> list[SignResult]:
+    """Sign every executable bottom-up. `bundle.executables` is already ordered
+    deepest-nested-first by the inventory walker, so a naive linear pass over
+    it satisfies "sign dependencies before dependents" without hard-coding a
+    bundle layout.
+
+    Each profile-bearing target (main app, app extension, watch app) gets its
+    own profile selected from the pool by its own bundle id, embedded into
+    its own bundle directory, and its entitlements reconciled against that
+    profile independently. Frameworks/dylibs/other have no bundle id of
+    their own and are reconciled against the main app's selected profile --
+    this exactly matches the single-profile behavior this project shipped
+    with before per-extension profiles existed, so a single supplied profile
+    still signs everything as before; only supplying multiple profiles
+    changes anything.
+    """
+    main_profile, main_profile_path = profiles.select_for(bundle.bundle_id)
+
+    results: list[SignResult] = []
+    for target in bundle.executables:
+        if target.kind in _PROFILE_BEARING_KINDS:
+            if target.bundle_id:
+                profile, profile_path = profiles.select_for(target.bundle_id)
+                # F6: legacy single-profile mode uses the lone profile for
+                # every target even when it doesn't authorize this one -- warn
+                # so a mismatched extension doesn't silently ship uninstallable.
+                if len(profiles.entries) == 1 and profile.bundle_id_pattern not in ("*", target.bundle_id):
+                    warnings.warn(
+                        f"profile '{profile.name}' does not authorize '{target.bundle_id}' but will be "
+                        "embedded anyway (single-profile mode); supply a matching --profile for it",
+                        stacklevel=2,
+                    )
+            else:
+                # This bundle's own Info.plist couldn't be read -- fall back
+                # to the main app's profile rather than leaving it unembedded.
+                profile, profile_path = main_profile, main_profile_path
+            embed_provisioning_profile(sign_target_path(target), profile_path)
+        else:
+            profile = main_profile
+
+        original_entitlements = provider.dump_entitlements(target.path)
+        reconciled = reconcile_entitlements(original_entitlements, profile.entitlements)
+        result = provider.sign(sign_target_path(target), reconciled, identity)
+        results.append(result)
+        if target.kind == "main":
+            bundle.entitlements = reconciled
+    return results