Skip to content

fix(apps): bind signatures to packaged app content - #34469

Closed
bolichen97 wants to merge 1 commit into
mainfrom
fix/sec-v4
Closed

bolichen97 wants to merge 1 commit into
mainfrom
fix/sec-v4

Conversation

@bolichen97

@bolichen97 bolichen97 commented Nov 10, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: Make a publisher's app signature bind the packaged content used at installation, activation and executable-resource registration.

A signature can remain valid when packaged files change. Installed apps also lack a signed-content check at later activation boundaries.

Why it matters

Fleets that require signatures need those checks to identify the publisher's packaged content, including backend code, hook modules, scripts, agents and skills.

Not a goal

  • Seal installed app trees or widen the OS sandbox's scope.
  • Sign gateway-provisioned dependencies or replace HMAC with asymmetric keys.
  • Add checks at every UI request, linked skill read, MCP session start or cron fire.

What changed (motivation → approach → change)

The signature covered manifest fields but not packaged file contents. Scheme 2 signs the complete manifest and a SHA-256 inventory matching the install copy. Existing admission and execution boundaries compare the signed package and the manifest object they use. Publisher-source runtime entries and tracked, inventory-excluded files in reused registry checkouts are refused without changing installed runtime-data preservation.

Signed Python hooks and normal imports compile verified source. Threaded hook preparation clears every in-tree cache and the app-specific active external mirror under both the path spelling the hook sees and its canonical path, through pinned directories, refusing cleanup failures while leaving unrelated caches and the process-wide prefix unchanged. A cache-preparation failure before a lifecycle script is a failed script result, so enable rolls back and uninstall still removes the backend and runtime. Python children and signed registry install scripts use fresh external caches. Registration carries its actual manifest, builtin admission requires shipped provenance, and boot refuses prompts as well as backends without aborting other apps on a failed record write. The admission exemption at enable and in both boot passes applies only when the install is builtin-owned, declares the shipped backend entry, and that backend resolves inside the shipped package, so an app shadowing a builtin name is checked like any other. A self-registered app whose installed directory holds no packaged file is admitted on its manifest signature; any packaged file found there is still compared. A malformed trust_keys value makes the policy fail closed instead of stopping startup. Signed Node provisioning honours a packaged lockfile with npm ci, without rewriting it; lockfile-free apps retain non-writing installation. Any attempted npm provisioning is followed by a content check before Node starts, including failed npm runs. Signed-content refusals reach one shared, payload-free security audit boundary. Boot persists disable only for proven signature or content refusals; policy denials and unreadable state remain refused for that boot and recover on a later boot.

src/kiro_crew/cli_commands_app.py implements publisher signing, src/kiro_crew/cli_parser_agent.py declares its arguments, and src/kiro_crew/cli_commands.py exposes dispatch. Publisher, notification and security docs describe the contract and limits. .github/black-baseline.txt removes the now-formatted backend file from the shrinking formatting baseline.

Backwards compatibility

Breaking: Fleets with require_signature must re-sign apps. A build or onInstall that changes packaged files is refused for signed apps. Signed Node apps ship their final lockfile. Signed local install/update sources cannot seed root data or app-crons.json; registry publisher trees also cannot carry root .app_secret, including entries produced by build/install scripts. Installed runtime data stays preserved and outside the inventory.

Writer sweep on origin/main @ 32d5f13: no shipped app.json declares a signer. Signature verification uses AppManifest.signing_payload in app admission. A separate downstream-edition owned-source sweep found no signer or caller of signing_payload, require_signature or trust_keys. External publishers using the earlier payload must re-sign. Without a signature policy, source-copy and npm provisioning behavior remain unchanged. Boot bans, allowlist denials, unreadable manifests and inventory I/O errors do not change persisted enablement. The app remains down in that boot and can recover when the policy or fault is resolved. Only proven signature or packaged-content refusals persist disable; a persistence failure still refuses the app in that boot.

Reader: src/kiro_crew/apps/admission.py:app_admission_denied -- app -- source and activation callers supply the tree; source-only refusals do not apply to installed runtime data.
Reader: src/kiro_crew/apps/backend.py:_start_app_backend_body -- app -- the executed manifest and backend tree are checked before spawn.
Reader: src/kiro_crew/apps/module_loader.py:load_app_module -- app -- prepared verdict includes off-loop cache cleanup; synchronous fallback remains; paired no-policy controls pass.
Reader: src/kiro_crew/apps/lifecycle_scripts.py:run_lifecycle_script -- app -- script text is bound to the verified setup declaration.
Reader: src/kiro_crew/apps/bridges_sources.py:_registration_denied -- app -- agents, skills, cron and MCP callers verify the manifest they register.
Reader: src/kiro_crew/apps/bridges_crons.py:_admitted_app_cron_defs -- cron -- signed definitions come from the verified manifest rather than the unsigned record.
Reader: src/kiro_crew/apps/manager_activation.py:enable_app -- app -- an installed origin claim cannot grant the shipped builtin exemption.
Reader: src/kiro_crew/apps/backend_runtime/startup.py:start_enabled_app_backends -- app -- admission failures keep apps down even when saving the disabled record fails.

Tests

Proof: not provable -- other: the regression files below were run red on the parent head and green on this head; the full-diff revert proof was PROVEN at 5249a228a0c3

File Covers
test/test_app_signed_external_register.py a self-registered app signed with kirocrew app sign activates at boot, enable and restart; a file planted in its metadata directory is refused; code run from that directory is still refused; no-policy control
test/test_app_signed_round4.py malformed trust_keys fails closed without raising; a cache-preparation failure is a failed script result, enable rolls back and uninstall still removes the app; listing and unlink failures propagate; the lexical-path mirror is cleared when the app is reached through a linked ancestor; a traverse-only ancestor does not block cleanup; no-policy controls
test/test_app_signed_content.py, test/test_app_signed_round3.py, test/test_app_signed_review_repairs.py, test/test_app_signed_audit.py, test/test_app_signed_provisioning.py, test/test_app_signed_cache_mirror.py signed inventory, publisher roots, hook cache preparation, shared audit boundary, npm provisioning

New regressions were red on the parent head (test_app_signed_external_register.py: 3 failed; test_app_signed_round4.py: 15 failed, then 7 failed for the lexical-mirror and traverse-only cases) and green on this head. On this head the signed-app files, the link-screen and facade tree scans, and the lifecycle, uninstall, module-loader and route-registry files pass locally (262 passed, 2 skipped; 626 passed on the wider signed set). isort, flake8, black, mypy on the touched modules, the flake-pattern ratchet and the repository semgrep rules pass. The full suites, Windows and macOS run in GitHub Actions.

Manual verification

A cross-platform harness runs isolated gateways (own home, loopback-only ephemeral port) from the base and from this head:

  • Repro: a signed app whose backend/server.py changed after signing is admitted on the base and refused on this head, at install and after a change to the installed copy; an unchanged signed app installs and enables on this head.
  • Existing apps, no signature policy: 15 GitHub-catalog apps install and enable the same way on the base and on this head, both fresh and after a base-installed home boots on this head; todo-ledger and dynatrace are refused on both because their manifests declare crons without the cron permission.

Linux arm64 at the parent head: repro PASS, every existing app identical on base and head. Results on this head for Linux x86-64, Windows Server 2025 and macOS, including three apps from a second, self-hosted git registry, are posted as a PR comment when each host finishes.

Screenshots / video

N/A. No UI change in this PR.

Related Issues

Closes #34319

Sibling sweep

Swept: signing payload consumers, inventory exclusions versus copied/source-executed entries, installed-content checks, resource-registration guards, builtin provenance and every hook cache-preparation caller.
Sibling: src/kiro_crew/apps/manager_install.py -- changed here
Sibling: src/kiro_crew/apps/registry_pipeline/install_clone.py -- changed here
Sibling: src/kiro_crew/apps/registry_pipeline/install.py -- changed here
Sibling: src/kiro_crew/apps/bridges_register.py -- changed here
Sibling: src/kiro_crew/apps/bridges_skills.py -- changed here
Sibling: src/kiro_crew/apps/bridges_mcp.py -- changed here
Sibling: src/kiro_crew/apps/lifecycle.py -- changed here
Sibling: src/kiro_crew/apps/backend_runtime/startup.py -- changed here
Sibling: src/kiro_crew/apps/signed_imports.py -- changed here

Pattern harvest

Rule candidate: review-prompt
Pattern: Bind signatures to executable package bytes and the exact manifest consumed. Source entries excluded from the inventory must not enter execution unsigned. Prepared verification must include blocking cleanup and surface traversal errors.

Residuals and maintainer decision

The installed tree remains writable. Check-then-use races remain, including direct file loaders that bypass the verified-source finder. Gateway-provisioned .venv and its .pth, node_modules, and data/.kirocrew-deps are not signed publisher content. The UI bundle is served per request, skills remain live links, stdio MCP is started per session by the external harness, and cron scripts are read at fire time without a new per-use check. Reused registry checkouts reject publisher-tracked files under inventory-excluded names; generated, untracked dependency directories remain permitted. The root-only unsigned source-runtime check also applies. HMAC requires the verifier to hold the shared secret; asymmetric keys and commit pinning are follow-ups. The backend restart re-vet in backend_runtime/restart.py still exempts a record whose origin is builtin, as on the base; aligning it with the enable and boot provenance check is a follow-up.

needs-a-decision: Should installed app trees become read-only for sandboxed agents? This PR leaves that OS-layer scope decision to the maintainer and adds no seal.

Checklist

  • One squashed commit, published with an explicitly authorized SHA-pinned lease.
  • Source and docs describe the same signed-content contract.
  • Prior no-policy controls and real gateway behavior recorded.
  • Local GPT and Opus review run on this head; GitHub review lanes re-run on push.
  • Current-head GitHub CI and review readiness green.

Contribution License Agreement

Contributions are provided under the project's Apache-2.0 license.

@KiroCrewCaptain

KiroCrewCaptain commented Nov 10, 2026 •

Copy link
Copy Markdown
Collaborator

Code change approver recommendation: A person should decide

Why: the decider thinks the change is probably fine but estimates a 30% chance that this change introduces a defect, above the 12% limit for approving on its own.

Scheme 2 signs the whole manifest plus a SHA-256 list of every packaged file. Under require_signature, that list is checked at install, enable, boot, backend spawn, lifecycle scripts, hook loads and resource registration. Signer and verifier share one file walk that matches the install copy's exclusions. The builtin admission exemption at enable, boot and registration now requires shipped provenance (is_installed_builtin_app), and every shipped builtin uses a module-style backend, so none loses its exemption. Boot persists a disable only for a proven content mismatch. With no policy, the new checks return early; the MCP rebuild gate matches live registration's existing execution decision. The restart-path builtin exemption is a declared residual, not a gap in the content check, because the spawn re-checks content from the executed path. The GPT lane's blocking finding is a fail-closed edge case. I found no concrete regression, data-loss or fail-open path, so I approve with non-blocking notes.

An automated recommendation, not a review: a maintainer still decides. It approves on its own only when the estimated chance of a defect is at most 12% and the change has at most 400 changed lines. Decider v3c (217fe607) · commit 7beca76b3d · 9824 changed lines. If this recommendation is wrong, reply here: replies are how the approver is evaluated.

@bolichen97

Copy link
Copy Markdown
Contributor Author

PR Policy portability finding: rebutted for 3479d58. The only matched added line is segments = path.split("/") in apps/signed_content.py:declared_path_error. This parses a serialized fileDigests key, whose documented wire format is an NFC-normalized relative POSIX path on every host. It does not split or assemble a native filesystem path. Native filesystem access uses Path(entry.path), Path(root) and os.scandir. Splitting the raw key deliberately retains empty, dot and parent components so the validator can refuse them; a normalizing path parser would erase that evidence. The POSIX-format inventory contract is documented in the manifest reference and exercised by the signed-content tests. I am applying the existing posix-only-approved exception for this one wire-format false positive, not declaring the application POSIX-only. Windows CI and all security checks remain required.

@bolichen97 bolichen97 added the posix-only-approved Cross-Platform Portability findings reviewed and accepted as intentionally POSIX-only label Nov 10, 2026
@github-actions

github-actions Bot commented Nov 10, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ⏭️ skipped

Revision 7beca76b3d8cd6bbdd3ea1241ac12a93308aa4f5 touches no user-facing surface (no changes under website/ or committed screenshots), so the UX review was skipped. Does not block merge.

@github-actions

github-actions Bot commented Nov 10, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — ✅ PASS

Design-level review of 7beca76b3d8cd6bbdd3ea1241ac12a93308aa4f5 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

Design-Verdict: PASS

Nothing blocks: dropping scheme 1 is declared as Breaking: with a re-sign path, and a refused app is only held down for that boot, so the change can be walked back.

Notes

  • The scheme-1 compatibility pins were removed on purpose, not treated as gaps (test_a_scheme_1_signature_no_longer_verifies). Fleets running require_signature with apps signed under scheme 1 will see every one refused at the next boot until it is re-signed. Worth a release-note line beyond the PR body.
  • The real guarantee is detection at the moments the checks run. The installed tree stays sandbox-writable and HMAC verifiers hold the signing secret. The spec states both limits; keep them out of user-facing "tamper-proof" wording.
  • The rules for metadata-only directories of self-registered apps (declarative=True, _activation_tree) add a second trust path that is easy to drift. Consider one owner for "which tree is authoritative" before more callers appear.

[DESIGN-REVIEWED] 7beca76

Description read

[DESCRIPTION-READ] cd9299c2cbaaf04fde311a6a2d4bedd9c46452fc6024f7ef87e7c316d8bc6c6a

That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Nov 10, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — ✅ PASS

Premise-level review of 7beca76b3d8cd6bbdd3ea1241ac12a93308aa4f5 — why this exists and whether the shipped surface is the smallest honest version. Updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

First-Principles-Verdict: PASS

Nothing blocks. Every item follows from the stated defect: a signature stayed valid after packaged files changed. One note: the PR re-spells a signing primitive the repo already has.

Notes

  • Item 1 — duplicate of src/kiro_crew/platform/admission.py:canonical_signing_bytes / hmac_signature, which that file calls "the ONE canonicalization every KiroCrew trust-root signature is taken over". The PR rewrites both app-side spellings and still hand-rolls them: json.dumps(payload, sort_keys=True, separators=(",", ":"), allow_nan=False) in manifest.py:signing_payload and hmac.new(secret.encode("utf-8"), ...) in signed_content.py:app_signature. Grep for hmac_signature|canonical_signing_bytes outside platform/admission.py finds 2 consumers; the app path is not one of them. These spellings already existed on base, so this is a note, not a block. Subtraction: delete the inline json.dumps/hmac.new and call the shared pair instead.

What this change ships

Inventory (10 items) — 8 justified

Intent: let a fleet that requires signatures trust that a signed app runs exactly the files its publisher signed. This is a FIX.

  1. A signature now covers the whole app.json plus a SHA-256 of every packaged file, so old-scheme signatures stop verifying — justified
  2. At boot, enable and restart, and before a backend, hook or lifecycle script starts, the installed files are checked against the signed list — justified
  3. Agents, skills, crons and MCP servers are registered from the verified manifest, not from the unsigned record — justified
  4. New kirocrew app sign command writes signer, file list and signature — justified
  5. Python hooks, children and MCP launches use a gateway-chosen bytecode cache, and stale caches are cleared first — justified
  6. Signed Node apps install from their lockfile with npm ci, and the files are re-checked after any npm run — justified
  7. Publisher trees that carry runtime entries, or tracked files left out of the inventory, are refused — justified
  8. A bell note names each app a boot refused over its signature, and the next step — rides along
  9. Boot now persists "disabled" only for a proven signature or content mismatch; a policy denial refuses for that boot only — rides along
  10. The builtin exemption needs shipped provenance, and a malformed trust_keys fails closed instead of crashing startup — justified

[FIRST-PRINCIPLES-REVIEWED] 7beca76

Description read

[DESCRIPTION-READ] 32a33bf795fe1fbf7b041192d41099b699989c6c86ea630aeb52e490c573d3d3

That sha256 names the PR description this verdict read. Recompute it with .github/scripts/pr-description-capture.sh; if it differs, the description changed after this verdict was formed and any finding drawn from the description is unproven.

@github-actions github-actions Bot added the readiness: action required A blocking check or review needs attention label Nov 10, 2026
@github-actions

github-actions Bot commented Nov 10, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — 🔴 changes requested (blocking)

Reviewed 7beca76b3d8cd6bbdd3ea1241ac12a93308aa4f5 — this comment is updated in place on each push.

Blocks: with require_signature on, gateway boot now SHA-256s every packaged file of every enabled app several times before the dashboard socket binds. That is per-file work on the boot path, which the blocking boot-path rule forbids.

BLOCKING — src/kiro_crew/apps/bridges_sources.py:187
or _installed_content_refusal(app_name, app_root, manifest, declarative=declarative) / or _activation_admission_denied(app_name, action=action, caller="app_bridge")
Trigger: require_signature: true with enabled non-builtin apps. server.py:1039 awaits _start_app_backends (server_runtime/app_platform.py, changed here) before site.start(). That reaches start_enabled_app_backends. Its first pass runs app_admission_denied(action="boot"), which calls _activation_tree, then packaged_inventory (full hash), then signed_content_refusal (another full hash). Next, register_app and reconcile_app_skills each go through _registration_denied, which runs both verified_installed_manifest (_activation_tree plus signed_content_refusal) and app_admission_denied again. The second pass then repeats app_admission_denied(action="boot").
Outcome: before the dashboard accepts requests, each app's packaged tree is read and hashed about ten times. Boot latency therefore grows with the number of packaged files and bytes across all enabled apps. That is the "work whose cost scales with file counts" that the rule bans on the boot path.
Anchor: no-new-work-on-gateway-boot-path
Fix: compute each app's signed-content verdict once per boot pass and reuse it in the admission, registration and spawn checks. Make _activation_tree stop at the first packaged file instead of hashing the whole tree. Or move the content comparison off the pre-bind path, after site.start(), before the backend spawns.

[BLOCK-MERGE] 7beca76
[OPUS-REVIEWED] 7beca76

Verdict parsed from the review's SHA-scoped output markers for commit 7beca76b3d8cd6bbdd3ea1241ac12a93308aa4f5.

False positive or not applicable? A repository writer can comment:
/ai-review override fable 7beca76b3d8cd6bbdd3ea1241ac12a93308aa4f5 false-positive: <reason, 20 to 500 characters>

@github-actions

github-actions Bot commented Nov 10, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — 🔴 changes requested (blocking)

GPT 6.1 found at least one blocking issue that must be resolved before merging 7beca76b3d8cd6bbdd3ea1241ac12a93308aa4f5. 1 of 1 blocking finding(s) are security-class and were withheld from adjudication, so the blocking verdict stands.

This comment is updated in place on each push.

BLOCKING -- src/kiro_crew/apps/signed_content.py:130 -- Case-aliased manifests invalidate their own signed inventory

if is_uncopied_name(name) or (not parts and name in _ROOT_EXCLUDED):
Trigger: On a case-insensitive Windows or macOS filesystem, kirocrew app sign reads a manifest named App.json through app.json; sign_app_dir then calls packaged_inventory, whose case-sensitive exclusion includes that manifest’s pre-signing bytes.
Outcome: Signing reports success but rewrites the inventoried manifest, so signature-required installation immediately refuses the newly signed app without any subsequent publisher change.
Anchor: defect
Fix: Exclude the actual manifest regardless of directory-entry casing, or reject noncanonical manifest casing before writing the signature.
Sites: src/kiro_crew/apps/signed_content.py:309 records the inventory during signing; src/kiro_crew/apps/signed_content.py:258 recomputes it during verification.
[BLOCK-MERGE] 7beca76
[GPT-REVIEWED] 7beca76

Adjudication (Opus 5.5) — is blocking on each finding proportionate?

F1 (fenced): I confirmed the defect, but it does not lead to unbounded harm. It needs a manifest whose on-disk name has non-canonical casing (e.g. App.json) on a case-insensitive filesystem:

  • Conditions: sign_app_dir reads the manifest by the literal path root / "app.json" (signed_content.py:296–301). The inventory skips only the exact lowercase name, because the root exclusion test is case-sensitive (name in _ROOT_EXCLUDED, :47 and :130). So App.json goes into fileDigests (:309) and is then rewritten by atomic_write (:311).

  • Outcome and recovery: the app fails closed. verify_inventory recomputes the inventory (:258) and returns either "does not match its signed digest" or "signed but missing" (:265–268), so a require_signature admission refuses the app with a visible error. Nothing unsigned or tampered gets admitted. The publisher recovers by renaming the file to app.json and signing again.

  • Rarity: the repo's tooling does not produce this casing, and on a case-sensitive host the app.json read at :301 would not find the file at all. The worst case is an app that refuses to install, not a weaker security ceiling.

    [ADJUDICATION] 7beca76 total=0 uphold=0 downgrade=0
    [GPT-ADJUDICATED] 7beca76

    [ADJUDICATION-FENCED] 7beca76 fenced=1 flagged=1
    FLAG F1 src/kiro_crew/apps/signed_content.py:130 -- Real but fail-closed: only a non-canonically cased App.json on a case-insensitive filesystem reaches it (read via the literal app.json at :301, case-sensitive exclusion at :130), and the result is a loud admission refusal at :265-268, fixed by renaming to app.json and signing again, with no credential, privilege or governance exposure.
    [GPT-ADJUDICATED-FENCED] 7beca76

🏷️ Fenced finding(s) machine-flagged as likely edge case

The security fence keeps these findings blocking regardless of adjudication; the only clearance path is a human override. The annotate-only pass judged the condition combination each one requires extreme, and pre-drafted the override rationale below. A repository writer must independently verify a rationale before posting it — it is machine-authored, and a wrong override on a security-class finding ships exactly the class the fence exists to stop.

  • F1 src/kiro_crew/apps/signed_content.py:130 — Real but fail-closed: only a non-canonically cased App.json on a case-insensitive filesystem reaches it (read via the literal app.json at :301, case-sensitive exclusion at :130), and the result is a loud admission refusal at :265-268, fixed by renaming to app.json and signing again, with no credential, privilege or governance exposure.

    /ai-review override gpt 7beca76b3d8cd6bbdd3ea1241ac12a93308aa4f5 <class>: Real but fail-closed: only a non-canonically cased App.json on a case-insensitive filesystem reaches it (read via the literal app.json at :301, case-sensitive exclusion at :130), and the result is a loud admission refusal at :265-268, fixed by renaming to app.json and signing again, with no credential, privilege or governance exposure.
    

Replace <class> with the class that records what you did. These findings are real, so for an accepted risk use owner-decision (link the decision comment in the reason) or deferred #<N> (a tracked follow-up issue); false-positive only if you verified the finding is wrong. Not not-applicable: that class files the override as a rule mismatch in the audit.

False positive or not applicable? A repository writer can comment:
/ai-review override gpt 7beca76b3d8cd6bbdd3ea1241ac12a93308aa4f5 false-positive: <reason, 20 to 500 characters>

@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Nov 10, 2026
@bolichen97
bolichen97 disabled auto-merge November 10, 2026 17:03
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Nov 10, 2026
@bolichen97

bolichen97 commented Nov 10, 2026 •

Copy link
Copy Markdown
Contributor Author
  • Signed Node provisioning ignores the packaged lockfile span=52636b39ef40

fixed in 898a514: Signed provisioning uses npm ci when package-lock.json or npm-shrinkwrap.json exists; the lockfile-free branch remains non-writing. Root/nested and no-policy regressions are written; GitHub CI verification is pending.

@bolichen97

bolichen97 commented Nov 10, 2026 •

Copy link
Copy Markdown
Contributor Author
  • Signed Node provisioning ignores the packaged lockfile span=0a32be773082

fixed in 898a514: The signed lockfile branch uses npm ci and preserves pins and integrity hashes without rewriting the lock. Signed apps without locks retain install --no-package-lock; no-policy behavior remains unchanged. Written regressions cover both package directories; GitHub verification is pending.

@bolichen97

bolichen97 commented Nov 10, 2026 •

Copy link
Copy Markdown
Contributor Author
  • Signed-content refusals are missing from the security audit span=6a0c5b272d78

fixed in 898a514: The shared verified_installed_manifest boundary submits a best-effort denied SEL event for signature, tree and script refusals, including direct and wrapper callers. App, executed path and reason are recorded without script text, manifest payload or secrets. Audit failure preserves the refusal. Regression verification is pending in GitHub CI.

@bolichen97

bolichen97 commented Nov 10, 2026 •

Copy link
Copy Markdown
Contributor Author
  • Windows skips directory-link checks the harness can support span=94cbd8584189

fixed in 898a514: Directory inventory and publisher-signing refusal tests use make_dir_link, exercising Windows junctions without privileged symlinks. The file-link case skips only an actual unsupported-operation or unavailable-privilege error. Refusal assertions remain; Windows CI verification is pending.

@bolichen97

Copy link
Copy Markdown
Contributor Author

Forward-only repair 898a514 preserves the original public commit 3479d58 as its first parent and incorporates main ed80c1d as its second parent. The PR has two commits; no public history was rewritten. The uninstall overlap preserves both protected-state cleanup and app-pycache cleanup. Windows traversal-refusal assertions now match the quoted OSError filename. Auto-merge is disabled. Current-head tests and review verification are delegated to GitHub Actions; no local execution result is claimed.

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: checking Automated validation is still running labels Nov 10, 2026
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Nov 10, 2026
@bolichen97
bolichen97 enabled auto-merge (squash) November 11, 2026 13:21
@github-actions github-actions Bot added readiness: passed Eligible automated validation passed for the current revision and removed readiness: checking Automated validation is still running labels Nov 11, 2026
@bolichen97

Copy link
Copy Markdown
Contributor Author

Rebased: main moved in files this PR also touches since this head went green (.github/black-baseline.txt, the app-kit docs, docs/architecture/mcp.md and src/kiro_crew/apps/ modules among them) (1238a18 on 9ee4420 -> 454fb1f on 7663020); CI re-running.

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: passed Eligible automated validation passed for the current revision labels Nov 11, 2026

@buluoray buluoray left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Request changes on 454fb1f. Every point in our CHANGES_REQUESTED review 6593e5b is fixed and mutation-tested. The signed-hook preparation now clears the app's subtree under the external bytecode prefix, through pinned directories, and fails closed on a linked mirror or a cleanup error. The two broken tests are repaired. The new delta (self-managed registry apps verify and run from the publisher checkout; self-registered apps with an empty metadata directory admit declarative registrations on signature alone; MCP -X pycache_prefix) tightens or keeps fail-closed. Caveat for the lead: the live head has NO real CI, GPT or Opus results. The author cancelled CI, and GPT/Opus/Design/UX/First Principles failed on "API rate limit exceeded". The patch is identical (git range-diff "=") to 1238a18, where all 82 non-skipped checks passed and GPT and Opus both reported no blocking findings. The base differs (main moved in touched files), so the re-run on 454fb1f must go green before merge. Lead note (c139, reclassified from APPROVE after the rate-limited lanes were re-run and both posted [BLOCK-MERGE] on 454fb1f; I read GPT comment 6763915013 and Opus comment 6763884669): REQUEST_CHANGES, security. The points from our earlier review 6593e5b stay fixed. Two new findings hold. (S1, GPT, security-class, adjudication upheld) Signed content is checked once (src/kiro_crew/apps/backend.py:532), then provision_app_deps (src/kiro_crew/apps/backend.py:725) runs pip with write access to the app tree (src/kiro_crew/apps/backend_runtime/provisioning.py:861-899, cwd=root). A dependency that ships as a source package can run a build hook that rewrites backend/server.py. Only the npm branch checks the content again (src/kiro_crew/apps/backend.py:1054-1068); the Python path and src/kiro_crew/apps/bridges_mcp.py:976-978 and :1030 go straight on to spawn or register. So with signatures required, the backend can run source that does not match the publisher's signed inventory. Fix: verify the final packaged tree against the execution manifest after dependency provisioning and before spawning or registering. (D1, Opus) A boot under require_signature records every unsigned, scheme-1-signed or untrusted-key app as disabled by its owner (src/kiro_crew/apps/admission.py:567 returns _SignatureRefusal; src/kiro_crew/apps/startup.py:178, :238 call _disable_denied_app). These are outcomes of the policy, not tampering, so after the administrator relaxes the policy or restores the key the apps stay off and each must be re-enabled by hand. Fix: return the _SignatureRefusal marker only after a trusted signer's signature was checked and failed; a missing signature, an unknown signer or an unverifiable scheme should refuse this boot without persisting a disable. We never override security findings. Decisive lines: src/kiro_crew/apps/signed_imports.py:181-214 (clear_app_bytecode clears the app's mirror under sys.pycache_prefix), src/kiro_crew/apps/module_loader.py:384, test/test_app_signed_cache_mirror.py::test_external_mirror_cannot_supply_unsigned_direct_loader_bytecode, test/test_app_signed_review_repairs.py:99-103, test/test_apps_registry_identity_admission.py:425, src/kiro_crew/apps/admission.py:582-585

@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Nov 11, 2026
@bolichen97

Copy link
Copy Markdown
Contributor Author

Rebased: main moved in 11 files this PR also touches, from base 7663020f50f7 to base e8283ceb857d:

  • .github/black-baseline.txt
  • docs/app-kit/publishing-guide.md
  • docs/architecture/mcp.md
  • docs/system-specs/modules/app-kit-platform.md
  • docs/system-specs/modules/app-notifications.md
  • docs/system-specs/modules/cli.md
  • docs/system-specs/modules/security.md
  • src/kiro_crew/cli_commands.py
  • src/kiro_crew/cli_commands_app.py
  • src/kiro_crew/cli_parser_agent.py
  • test/link_screen_sites.py

The same push also adds the app MCP materialization gate: app MCP entries carry an x-kirocrew-app provenance marker, and both the collector and the locked default-spec merge apply the registration admission decision (execution trust, fleet admission, signed content) to app-prefixed keys and to slash-free aliases. A URL-only shortcut applies only when the emitted entry is URL-only too. The PR's changed test files plus the MCP merge suites pass locally (1763 passed).

@buluoray buluoray left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Request changes on 81cbc2d. Requesting changes on 81cbc2d (security). The new commit adds a useful guard: when the agent spec is rebuilt, each app's MCP servers now pass the same admission and signed-content decision as live registration, and a copy already on disk cannot bring back an entry that registration refused. Two mutations of this guard turn 7 and 5 tests red. But neither point from our review on 454fb1f is fixed, because the PR's changes to backend.py, provisioning.py, admission.py and startup.py are identical on both heads. (1) The app backend still checks its signed content once (src/kiro_crew/apps/backend.py:532) and then provisions Python dependencies (src/kiro_crew/apps/backend.py:725). That step runs the package installer with the app directory as its working directory and write access to it (src/kiro_crew/apps/backend_runtime/provisioning.py:861-899). A dependency's build step can therefore change a signed file, and the backend is then started with no second check. Only the npm branch checks again (src/kiro_crew/apps/backend.py:1054-1068). The MCP registration path has the same order (src/kiro_crew/apps/bridges_mcp.py:978 and :1030). The new rebuild check narrows that MCP window, but the backend path stays open. With signatures required, a publisher whose dependency misbehaves, or anyone who controls a dependency, can get unsigned source run as if it were signed. Please check the final tree against the signed inventory after dependency provisioning and before starting or registering. (2) A boot under required signatures still marks every app that is unsigned, signed by an unknown key or signed with an old scheme as disabled by its owner (src/kiro_crew/apps/admission.py:567, src/kiro_crew/apps/backend_runtime/startup.py:179 and :239). If an administrator later relaxes the policy or restores the key, those apps stay off and each one must be turned back on by hand. Please save the disable only when a trusted key's signature was checked and did not match; in other cases, refuse this boot without saving a disable. Also, Backend Lint is red because black would reformat test/test_app_bridges_mcp.py:674, so no test shard ran on this head. GPT and Opus were cancelled on this head and have not reviewed it. Decisive lines: src/kiro_crew/apps/backend.py:532, src/kiro_crew/apps/backend.py:725, src/kiro_crew/apps/backend_runtime/provisioning.py:861-899, src/kiro_crew/apps/bridges_mcp.py:978, src/kiro_crew/apps/bridges_mcp.py:1030, src/kiro_crew/apps/admission.py:567, src/kiro_crew/apps/backend_runtime/startup.py:179, src/kiro_crew/apps/backend_runtime/startup.py:239, test/test_app_bridges_mcp.py:674

@bolichen97

Copy link
Copy Markdown
Contributor Author

Rebased: main moved in no files this PR touches, from base e8283ceb857d to base 26e8e9e1e743.

The same push adds:

  • A one-time migration on the first default-spec rebuild that runs this code: an unmarked, slash-free MCP entry that holds a command and that no current source declares (scope with its own transport, card addition, managed or edition server, or an app the collector emitted) is removed, with one warning per name in the gateway log. Completion is recorded once; later rebuilds keep entries added afterwards.
  • A scope that takes over a carried launch replaces its transport as a unit, so no old args, env, URL or headers stay under the user's server.
  • The black-gate and autouse-monkeypatch fixes for two test fixtures.

The PR's changed test files plus the MCP merge suites pass locally (1834 passed).

@buluoray buluoray left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Request changes on 49c1e83. Requesting changes on 49c1e83 (security and existing users). The new commit fixes the formatting problem we raised and adds a one-time cleanup of old MCP entries, which is backed by tests (turning the cleanup off makes 18 of them fail). The two security points from our last review are still open, because the PR's changes to backend.py, admission.py and startup.py are the same as on the previous head. First, the app backend still checks its signed content once and then installs Python dependencies into the app directory, and it starts the backend with no second check. A dependency's build step can therefore change a signed file and have it run as signed content. Only the npm path checks again. Please compare the final tree with the signed file list after dependencies are installed and before the backend starts or MCP servers are registered. Second, a boot that requires signatures still saves an owner disable for every app that is unsigned, signed by a key that is not trusted, or signed with the old scheme. If an administrator later relaxes the policy or restores the key, those apps stay off until someone turns each one back on. Please save the disable only when a trusted key's signature was checked and did not match. The new cleanup also changes things for existing users on every fleet, including fleets with no signature policy. On the first rebuild it removes any command-based MCP entry in the default agent spec that has no app or card mark and that no current source declares, including entries a person added by hand. It writes a log warning with the name but keeps no copy of the removed settings. The PR description does not mention it. Please say this in the description, and either keep a copy of what was removed or limit the cleanup to entries that an app wrote before. Decisive lines: src/kiro_crew/apps/backend.py:532, src/kiro_crew/apps/backend.py:725, src/kiro_crew/apps/backend.py:1058, src/kiro_crew/apps/admission.py:567, src/kiro_crew/apps/backend_runtime/startup.py:179, src/kiro_crew/apps/backend_runtime/startup.py:239, src/kiro_crew/agent_materialization/legacy_mcp.py:61-97, src/kiro_crew/agent_materialization/default_spec_commit.py:458-471, src/kiro_crew/agent_parts/spec_rebuild.py:685

@bolichen97

Copy link
Copy Markdown
Contributor Author

Rebased: main moved in no files this PR touches, from base 26e8e9e1e743 to base ce89396c9550.

The same push addresses the blocking GPT finding on 49c1e830 (rebuilt signed MCP Python launches could skip the bytecode-cache preparation registration applies): the collector and the locked default-spec merge now keep a signed Python stdio entry only when its -X pycache_prefix= argv pin and PYTHONPYCACHEPREFIX agree and point directly under the gateway's own run/app-pycache/<app>/ with no linked component and outside the app tree; any other entry is dropped, and registration re-adds it. Collection allocates nothing. Registration output is unchanged. The PR's changed test files plus the MCP merge suites pass locally (2140 passed).

@buluoray buluoray left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Request changes on c53ffe5. Requesting changes on c53ffe5 (security and existing users). This push rebases onto a newer main and adds a check that MCP entries rebuilt for a signed Python app use a bytecode cache directory outside the app's files. That check is tested: removing it in either place where it runs makes 16 and 90 tests fail. The three points from our last review are still open, because the PR's changes to backend.py, admission.py, startup.py and legacy_mcp.py are the same as on the previous head. First, the app backend still checks its signed content once and then installs Python dependencies into the app directory, and it starts the backend with no second check, so a dependency's install step can change a signed file before it runs. Only the npm path checks again. Second, a boot that requires signatures still saves an owner disable for every app that is unsigned, signed by a key that is not trusted, or signed with the old scheme, so those apps stay off after an administrator relaxes the policy or restores the key. Please save the disable only when a trusted key's signature was checked and did not match. Third, the one-time cleanup still removes command-based MCP entries that exist only in the default agent spec, including entries a person added by hand, on every fleet. It keeps no copy of the removed settings, and the PR description still does not mention it. Please either keep a copy or limit the cleanup to entries that an app wrote, and describe it in the PR. Decisive lines: src/kiro_crew/apps/backend.py:532, src/kiro_crew/apps/backend.py:725, src/kiro_crew/apps/backend.py:1058, src/kiro_crew/apps/admission.py:566-567, src/kiro_crew/apps/backend_runtime/startup.py:178-179, src/kiro_crew/apps/backend_runtime/startup.py:238-239, src/kiro_crew/agent_materialization/legacy_mcp.py:61-97

@bolichen97

Copy link
Copy Markdown
Contributor Author

Rebased: main moved in src/kiro_crew/apps/backend.py and src/kiro_crew/apps/bridges_crons.py, from base ce89396c9550 to base 52cc80f67838. The backend.py hunk takes main's _loopback_gateway_origin() refactor (this PR does not change it); main's new nested cron-restore check in reconcile_app_crons_for_execution now delegates to this PR's _cron_restore_denied, which passes the manifest and the declarative flag and fails closed when the source cannot be read.

The same push:

  • Removes the one-time legacy MCP cleanup from this PR. The residual it targeted (an unmarked, slash-free app alias written before this change whose manifest is already gone keeps launching) exists on main too, which has no alias gating; it moves to a follow-up so its design can be done together with the built-in app migration.
  • Adds a migration-compat check to test_an_adopted_record_registers_its_server_from_the_adopted_tree: an adopted former built-in is not treated as a built-in, and its repository-bound grant admits MCP collection and hook/cron activation.

The PR's changed test files plus the MCP merge, adoption and cron suites pass locally (2173 passed).

@buluoray

Copy link
Copy Markdown
Contributor

Follow-up on head 86e38e5bec43. One blocker before 0.13.0-rc.1, on fleets that turn on require_signature.

What happens on upgrade. At boot, an app that is unsigned, signed with an unknown key, or signed with the old scheme is treated as a signature refusal. src/kiro_crew/apps/backend_runtime/startup.py then calls _disable_denied_app() in both boot passes (around L178 and L238), which calls disable_app(). So the app is saved as owner-disabled. On main, the same app only skips that one boot. After the upgrade, every old-signature app stays off for good.

What the user sees. Nothing tells them: the only trace is a logger.warning. From their side, the app's pages and tools just disappear. The saved state looks as if they disabled it themselves, and if they turn it back on, the next boot turns it off again. (I read this from the code; I have not checked it in the UI.)

Suggested fix.

  1. Save the disable only when a trusted key's signature fails to match, which means the content was changed. For unsigned, unknown-key or old-scheme apps, skip this boot only, as main does.
  2. When an app is blocked or disabled for its signature, show the user a notice that names the app, says why, and says what to do (for example, update or re-sign it).

Still open from the earlier review (S1). The signed content is checked once. Then the Python dependencies are installed into the app directory, and nothing checks the content again. The npm path does check again. Running installed_content_refusal once more after provision_app_deps would close this. Main has no check here, so this is not a regression. It is a gap in the guarantee this PR adds.

@bolichen97

Copy link
Copy Markdown
Contributor Author
  • span=298eeff65084 App provenance breaks capability-editor connection selection

fixed in 97fbd7c: dashboard/handlers/agent_capabilities._connections strips the rendered spec's x-kirocrew-app record before a connection is offered, and agent_capabilities._rows omits it from editable transport values, so attaching an app's existing connection passes the transport allowlist.
The default-spec app gating is unchanged: the record stays on the rendered entry the locked merge reads. Regressions: test_an_app_connection_from_the_rendered_spec_attaches_without_its_provenance and test_editor_rows_omit_the_app_provenance_record fail on 86e38e5 and pass here.

@buluoray buluoray left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Request changes on 74a7566. Requesting changes on 74a7566. This push only declares the new launch check in signed_mcp.py in the link-screen baseline, which fixes the PR's own red guard tests. No product code changed, so the main blocker is still open. When a fleet requires signatures, a boot saves a permanent owner disable for every app that is unsigned, signed by a key the fleet does not trust, or signed with the old scheme. On main such an app is only skipped for that boot. Because this PR makes every old-scheme signature fail, the first boot after upgrade turns those apps off for good, and the user only gets a log line. Please save the disable only when a trusted key's signature was checked and the content did not match, and tell the user which app was turned off, why, and what to do. Separately, there is still a gap in the promise this PR makes: the signed content is checked once, then Python dependencies are installed with the app directory as the working directory, and the backend starts and MCP servers register with no second check. Only the npm path checks again. Main has no check here, so this is not a regression. Decisive lines: src/kiro_crew/apps/admission.py:567, src/kiro_crew/apps/backend_runtime/startup.py:41-51, src/kiro_crew/apps/backend_runtime/startup.py:179, src/kiro_crew/apps/backend_runtime/startup.py:239, src/kiro_crew/apps/backend.py:535, src/kiro_crew/apps/backend.py:728, src/kiro_crew/apps/backend.py:1042-1046, src/kiro_crew/apps/bridges_mcp.py:976-978, src/kiro_crew/apps/backend_runtime/provisioning.py:899

@bolichen97

Copy link
Copy Markdown
Contributor Author
  • span=83652f845cb5 Signing rejects supported UTF-8-with-BOM manifests

fixed in 41117c1: signed_content.sign_app_dir parses app.json with user_json.loads_user_json, the reader install and verification use, so a BOM-prefixed manifest they accept can be signed.
Regression: test_a_bom_prefixed_manifest_can_be_signed fails on 74a7566 and passes here.

@bolichen97

Copy link
Copy Markdown
Contributor Author
  • span=75c0b42f90bc lifecycle hooks load from the metadata-only app directory

fixed in 41117c1: LifecycleDispatcher._invoke (verify_hook_source) and _resolve_hook (load_app_module) take their root from lifecycle._hook_root, which is admission.signed_execution_root(app, app_dir(app)), the same root routes use; under a signature policy a signed self-managed app's hooks load and are verified from its publisher checkout, otherwise the root is unchanged.
Regression: test_a_signed_self_managed_apps_startup_hook_loads_from_its_checkout fails on 74a7566 and passes here.

@bolichen97

Copy link
Copy Markdown
Contributor Author

@buluoray thanks, both points are fixed in 55030fd.

1. Boot no longer saves a permanent disable for apps it cannot verify.

  • Only one case persists an owner disable: a signature from a trusted key verifies, and the packaged files do not match it (admission._is_signature_refusal, used at both boot passes in backend_runtime/startup.py).
  • Unsigned apps, untrusted signers, and signatures that do not verify (including the old scheme) are refused for that boot only, as on main. They stay installed and enabled, and they start once the cause is fixed.
  • Every signature refusal at boot now raises a bell note (apps/boot_refusal_notice.py, delivered on the system.apps channel from dashboard/server_runtime/app_platform.py). The note names the app, says what happened, and gives the next step. No note tells the user to sign the refused tree themselves.
  • Two effects worth knowing:
    • An app.json edited after signing makes the signature fail to verify, so it now blocks for one boot at a time instead of disabling the app.
    • The note repeats on every boot until the cause is fixed.
  • Test: test_boot_persists_only_a_trusted_content_mismatch_and_tells_the_user covers all four kinds at both boot passes.

2. Signed content is checked again after Python provisioning.

  • Backend spawn (apps/backend.py): if requirements.txt existed before pip ran, the signed tree is checked again before the backend starts. The check is keyed on that pre-pip state, so a pip step that deletes requirements.txt cannot skip it. A refusal, or an exception during the check, stops the spawn.
  • Backend-less stdio MCP registration (apps/bridges_mcp.py): the same check runs before any command is written to the MCP config. A refusal or an exception deregisters and registers nothing.
  • Tests: test_backend_spawn_checks_signed_content_after_pip, test_a_pip_step_that_removes_requirements_cannot_skip_the_second_check, test_backend_spawn_refuses_when_the_post_pip_check_raises, test_stdio_registration_checks_signed_content_after_pip, test_stdio_registration_refuses_when_the_post_pip_check_raises.

Bind publisher signatures to the manifest and packaged file inventory at
installation, activation and executable-resource registration. Preserve
no-policy behavior and existing runtime data.

Use interpreter cache options for signed Python MCP launches, preserving
isolation flags. Verify self-managed registry execution against its
publisher checkout and keep metadata files outside that authentication.

@buluoray buluoray left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Approve on 7beca76. This PR binds each app signature to the files the app ships, and checks those files again right before installed app code runs. The rebase onto main changed one test: it now says that a null author or licence is signed as written, which matches how this PR signs the whole app.json document. Main's new chat slot permission and main's fix for a null author or licence both survive, and the signature covers both. All three points from our earlier change request still hold on this head, and each has a test that fails without it. One edge case remains: on a case-insensitive disk, a manifest saved as App.json instead of app.json signs without error and is then refused at install. No tool or template in the repository writes that name, nothing unsigned or changed is ever let in, and the publisher fixes it by renaming the file and signing again. Two review lanes block this head. One block is that edge case. The other is a startup cost: under a signature policy, boot hashes each app's packaged files more than once. A maintainer has to decide both blocks before this can merge. Decisive lines: src/kiro_crew/apps/manifest_sections.py:117-118,598,642-643,679 (PR's comment-only hunks plus main's #36356 chatSlots field, both present); src/kiro_crew/apps/manifest.py:898-915 (signing_payload signs the document as written, so chatSlots and the #36426 null author/licence are covered); src/kiro_crew/apps/signed_content.py:47,130,234,260-274,297-311 (GPT F1: fail-closed only); src/kiro_crew/apps/admission.py:496-522,610-613,638 (D1a); src/kiro_crew/apps/backend_runtime/startup.py:179-181,240-242 (D1a/D1b); src/kiro_crew/apps/backend.py:733-747 and src/kiro_crew/apps/bridges_mcp.py:1033-1048 (S1)

@bolichen97

Copy link
Copy Markdown
Contributor Author

Closing this PR. The signed-content check is moving to the App SDK instead of the gateway.

Why: binding a signature to every packaged file means hashing each enabled app's tree. Under require_signature that check sits on the gateway boot path, before the dashboard socket binds, which the no-new-work-on-gateway-boot-path rule forbids for work that scales with file counts. Sharing one hash per boot pass reduced the cost but did not remove it, and moving app activation after the bind is a larger boot-order change than this fix should carry.

Fleets without a signature policy were never affected. Tracking continues in #34319.

The branch fix/sec-v4 is kept, including the post-provisioning re-check after pip and npm and its tests, for reuse in the SDK work. One more point for that work: a root entry such as App.json that differs from a reserved name only by case must be refused when signing, or kirocrew app sign produces an inventory that invalidates itself on case-insensitive filesystems.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

area: security merge conflict Branch has merge conflicts with its base — author must resolve before merge posix-only-approved Cross-Platform Portability findings reviewed and accepted as intentionally POSIX-only

Projects

None yet

Development

Successfully merging this pull request may close these issues.

security: an app's signature does not cover its packaged files

4 participants