From 8b22fe9bb83d658477e3609863cb1bdfbd5f6ba3 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 16:23:47 +0900 Subject: [PATCH 01/42] docs: plan automatic update parity --- .../261107_auto_update_parity/000_plan.md | 263 ++++++++++ .../001_inventory.md | 87 ++++ .../002_gap_ledger.md | 29 ++ .../003_contracts.md | 158 ++++++ .../010_signed_supply.md | 320 +++++++++++++ .../020_activation_admission.md | 386 +++++++++++++++ .../030_desktop_engine.md | 335 +++++++++++++ .../040_package_preparation.md | 171 +++++++ .../050_sidebar_panel.md | 329 +++++++++++++ .../060_linked_updates.md | 449 ++++++++++++++++++ .../070_standalone_updates.md | 66 +++ .../080_child_initiated_updates.md | 108 +++++ .../090_pnpm_updates.md | 111 +++++ .../100_bun_updates.md | 92 ++++ 14 files changed, 2904 insertions(+) create mode 100644 devlog/_plan/261107_auto_update_parity/000_plan.md create mode 100644 devlog/_plan/261107_auto_update_parity/001_inventory.md create mode 100644 devlog/_plan/261107_auto_update_parity/002_gap_ledger.md create mode 100644 devlog/_plan/261107_auto_update_parity/003_contracts.md create mode 100644 devlog/_plan/261107_auto_update_parity/010_signed_supply.md create mode 100644 devlog/_plan/261107_auto_update_parity/020_activation_admission.md create mode 100644 devlog/_plan/261107_auto_update_parity/030_desktop_engine.md create mode 100644 devlog/_plan/261107_auto_update_parity/040_package_preparation.md create mode 100644 devlog/_plan/261107_auto_update_parity/050_sidebar_panel.md create mode 100644 devlog/_plan/261107_auto_update_parity/060_linked_updates.md create mode 100644 devlog/_plan/261107_auto_update_parity/070_standalone_updates.md create mode 100644 devlog/_plan/261107_auto_update_parity/080_child_initiated_updates.md create mode 100644 devlog/_plan/261107_auto_update_parity/090_pnpm_updates.md create mode 100644 devlog/_plan/261107_auto_update_parity/100_bun_updates.md diff --git a/devlog/_plan/261107_auto_update_parity/000_plan.md b/devlog/_plan/261107_auto_update_parity/000_plan.md new file mode 100644 index 00000000000..b4cd323ea7d --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/000_plan.md @@ -0,0 +1,263 @@ +# Automatic update parity — roadmap draft + +OpenCodex already checks for desktop updates and has a guarded package update +orchestrator. This unit extends those owners into a user-controlled automatic +update experience, with the existing sidebar download control as its entry +point. The [inventory](001_inventory.md) separates observed behavior from gaps; +the [gap ledger](002_gap_ledger.md) assigns completion evidence to each one. +The [contract map](003_contracts.md) tracks proposed fields and their owners. +The roadmap's architecture reflection and independent plan audit are complete +for the snapshot recorded below. Each implementation unit remains a proposal +until its own current-base plan audit, tests and applicable independent security +review have passed; no update behavior is claimed to be implemented. + +## Loop specification + +- **Archetype and trigger:** satisfy-spec, scoped HOTL; the requested GOAT + parity work began on 2026-11-07. +- **Work class:** C4 for updater, signing, installation, release and authority + changes; the docs-only roadmap is independently audited before code. GOAT's + built-in discipline was read from the pinned reference revision at + `packages/provider-core/src/server/builtinSkills/goatDiscipline.ts:7`. +- **Goal:** signed, user-controllable updates for desktop and eligible linked + installations; useful progress, deferral and failure states in the sidebar. +- **Non-goals:** modify the user's installed app, services or running proxy; + merge pull requests; publish releases; broaden workflow triggers or + permissions; add optional-subsystem imports to core paths; add telemetry. +- **Verifier:** per-unit failing-first behavior tests, isolated homes and mock + feeds, typecheck and privacy scan, ownership and locale checks, UI screenshots, + exact-head required CI, and independent security review where applicable. + Commands and the source each observes belong in each completed decade plan. +- **Stop:** report each PR ready for coordinator integration only after its + exact-head checks and required reviews pass. Continue until every ledger gap + is closed or a concrete blocker is reported. +- **Memory:** this public unit and the bound Codexclaw goalplan; security + working notes belong in `.tmp/`, never in this directory. +- **Outcomes:** DONE requires the complete audited scope and evidence; + BLOCKED or NEEDS_HUMAN identify missing authority, supply or capability; + BUDGET_EXHAUSTED applies only to an actual bound. +- **Escalation and bounds:** report decisions outside the granted scope to the + coordinator. No token or wall-time bound stated; host limits apply. Keep load + moderate: no full root test suite. User authorized commits, pushes, PRs and + platform proof when needed, but not merge or release publication. A PR-branch + `lane=all` requires an explicit maintainer request on that PR; run it once on + the exact intended head, never redispatch because the head moved or rerun to + green, and cancel owned superseded runs. Ordinary full dispatches are batch + checks on `dev`, as required by `AGENTS.md`. + +## Draft dependency map + +1. **Signed supply and channel contracts.** Determine and implement a + verifiable artifact source for every automatic install surface. Extend + release metadata only when it can preserve existing signing and CI policy; + missing, invalid, or unverifiable signatures must refuse the automatic path. + Desktop stable/preview/nightly labels must correspond to feeds that actually + exist. npm provenance is a candidate for investigation, not yet a verified + consumer contract. Existing explicit package commands retain their behavior. +2. **Automatic activation admission.** Extend the existing automatic restart + fence and handoff (`src/server/management/system-restart.ts:385`) with an + identity-bound, expiring update reservation that proves no work remains and + transfers atomically into shutdown. Release its temporary fence before shutdown waits + for temporary drains. A plain sample of activity is insufficient: the + existing terminal drain aborts turns after its deadline + (`src/server/lifecycle.ts:520`), and an unreleased temporary fence can make + shutdown wait on itself (`src/server/lifecycle.ts:131`). +3. **Desktop staged update engine.** Extend the Tauri owner to check, download + with progress, verify, retain a staged update, and apply through the existing + restart/drain and recovery path. Persist user controls and channel state; + account for stale checks, concurrent commands, unavailable feeds and failed + or interrupted installs. Signature verification stays mandatory. The exact + default is an audit decision; it must be justified against GOAT's defaults + and the user's control requirement. +4. **npm preparation and activation.** Extract verified npm preparation + from the existing transactional swap. Automatic paths + must verify every artifact they execute, including installer dependencies; + unsupported owners remain visible and never silently fall back. +5. **Sidebar and update panel.** Extend the existing session-scoped snapshot + and sidebar download button to express current, available, downloading, + ready and failed states; open a panel with channel, automatic download and + installation controls, release notes, restart and Later. Preserve the native + update-page command boundary and browser package-update behavior. Resolve the + footer version truncation and validate accessibility, locales and geometry. +6. **Linked-machine orchestration.** Reuse Home–Child link identity, pinned + sync and the orchestrated plan/apply path where their contracts fit, while + adding signed-target verification, device-side controls, compatibility and + idle admission, per-machine progress, and failure/recovery reporting. Treat + unavailable identity, incompatibility, unverified signatures and offline + machines as explicit non-success states. Do not equate catalog sync with an + installation update. +7. **Standalone installation support.** Add a signed, owner-bound standalone + adapter and platform-specific recovery after the common supply and admission + contracts exist; do not treat the current standalone refusal as closure. +8. **Child-initiated link transport.** Add a separately authorized Child-pull + update exchange for links without Home-to-Child SSH; keep the existing + management relay read-only and preserve destination consent. +9. **pnpm-owned installations.** Implement and prove the selected global + owner's offline signed preparation, manager-compatible transition and rollback + in `090`; unsupported layouts remain open until proven. +10. **Bun-owned installations.** Implement and prove signed offline + preparation, global metadata/bin ownership, activation and rollback in + `100`; do not treat an ordinary global add as a staged transaction. + +The later units extend the preceding integration contracts: `070` adds a +standalone owner to the linked update coordinator, `080` carries those owners +over the Child-initiated transport, `090` adds a pnpm adapter to both link +directions, and `100` reuses the resulting manager-stage interface for Bun. +Each still has its own local behavior and independently reviewable PR. This +dependency chain preserves the full goal even when an earlier owner is not yet +eligible for automatic activation. + +Each unit will receive a decade-numbered document with its exact file map, +before/after behavior, public contracts, acceptance scenarios and fresh +verifiers. Each produces a separate PR against `dev`; dependency and base +strategy will be resolved in the audited plan. Any updater, package installation, +release, signing or workflow PR requires a separate independent security PASS. +The owner requested no full root suite; record focused coverage and the CI +coverage left outstanding rather than describing an unrun suite as passing. + +## Delivery and base strategy + +Each unit is a separate PR whose base is `dev`, as requested. Do not create a +stack whose child targets another PR. After the docs-only roadmap PR and each +implementation PR reaches exact-head readiness, report its URL, head, checks and +reviews to the coordinator. The coordinator alone decides whether and when to +merge. Once the prerequisite is actually on `origin/dev`, fetch and verify that +head before starting the next unit on a fresh branch from it; revalidate that +unit's prewritten plan against the resulting code. If a prerequisite is not yet +integrated, watch the PR through GOAT and wait for the coordinator rather than +manufacturing a downstream base or merging it here. A PR description uses the +repository's Summary, Verification and Checklist template. GUI PRs link a +reviewable screenshot hosted through `pr-assets`, never committed to the PR +branch. Add `ci:full` when subprocesses, files read as data or generated +outputs require coverage the changed-test import graph cannot discover +(`MAINTAINERS.md:65`). Required CI must complete on the current head. + +For user-facing changes, compare the canonical English installation, +desktop-app and remote-link pages and their existing `fr`, `ja`, `ko`, `ru`, +`tr`, `zh-cn` and `zh-tw` translations; update every affected translation so +it does not contradict the English source. For any docs-site edit, run its +required `cd docs-site && bun install --frozen-lockfile && bun run build` +(`docs-site/AGENTS.md`). GUI has eleven locales and its own locale parity +checks. Review mapped `structure/` owners on each unit; `structure:check` +does not itself establish that the prose accurately describes new behavior. + +## Consultation and audit + +Architect task: `auto-update-parity-architect-01`, read-only, Codex +`gpt-6.1-sol` with xhigh reasoning. Proposal received 2026-11-07 at the pinned +revisions in `001_inventory.md`; the following dispositions are provisional until +the same architect reflects on the concrete plan and the independent audit passes: + +| Decision | Main disposition | +| --- | --- | +| AU-001 installer ownership | Accept: retain distinct native and package owners and their existing mutation gates. | +| AU-002 controls | Accept: separate check, download and installation policy and revalidate before effects; preserve manual activation as the proposed default. | +| AU-003 candidate | Accept with amendment: exact candidate and provenance must satisfy the user's mandatory signature requirement, not just registry SRI. | +| AU-004 preparation | Accept conditionally: staged handles stay owner-held; npm, pnpm and Bun support must be proven individually, not assumed. | +| AU-005 admission | Accept: add a separate reservation unit and explicitly prove the shutdown handoff cannot race admission or wait on its own temporary lease. | +| AU-006 recovery | Accept: distinguish installation from a healthy serving target, preserve Stop/Resume intent and suppress repeat failed targets. Assess GOAT probation parity explicitly rather than treating it as automatic proof. | +| AU-007 Child authority | Accept with amendment: diagnostics do not finish the requested goal; the roadmap must include separately authorized and security-reviewed remote binary updates, not defer them out of scope. Preserve `ocx.sync.fanout/1`. | +| AU-008 channel and rollout | Accept: derive supported feeds from actual signed publication and never invent a nightly or preview channel. Document rollout and policy defaults. | + +The same architect's reflection (`auto-update-parity-architect-reflection-01`) +returned **MISALIGNED**: supply/trust, activity fencing and stop-to-installer +handoff, manager-specific staging, remote authority and resumption, policy and +recovery, sidebar wire/cadence, and exact PR/test mapping were incomplete. The +unit docs subsequently addressed these findings as described below. In particular, the existing restart +route's handoff is not by itself an installer-stop handoff, and peer observations +are not authorization. + +The user's authorization for platform proof operates within the unchanged +`AGENTS.md` CI policy stated above. Subsequent architect reflection and the +independent roadmap audit are recorded below. + +The third reflection (`auto-update-parity-architect-reflection-03`) returned +**MISALIGNED** against the 14-file snapshot: executable manager transitions, +update-stop authority and complete activity fencing, platform recovery actor, +signing/rotation, destination authority and Child-pull transport, future-target +compatibility, and nightly source/CI binding and shared-contract ownership needed +decisions and evidence at that point. The manager units now explicitly require isolated +pre-audit research; `003` specifies a candidate capability descriptor and +`010` owns shared parser/test-vector delivery before `020`. These amendments +were proposals awaiting the later reflections and independent audit below. + +The fourth reflection (`auto-update-parity-architect-reflection-04`) reviewed +snapshot `1498639d17aef1013f99e406fc8ae574588a8f3da558ca6b7a8c5c3456e54cc8` +and returned **MISALIGNED**. Its six material findings concerned bounded native +acquisition; retaining a verified stage and grouped notes; cross-process +admission/readback; platform guardian and remote Desktop handoff; +simultaneous Home/Child compatibility; and manager activation/recovery. The +main agent accepts these findings and has amended `003`, `010`, `020`, `030`, +`050`, `060`, `090` and `100` with candidate contracts and evidence from the +two completed isolated manager investigations. These amendments remain +unverified proposals at that point, not a security PASS. Subsequent architect +reflections and the independent roadmap audit are recorded below. + +Reflection 05 reviewed snapshot +`21bdadc2bc897481027b534a43f48de8704a97b1fb2eb11250c5edf04daa132f` +and returned **MISALIGNED**. The main agent accepted its six remaining +findings: installed channel provenance and browser policy, locale Back +navigation, quit/stopped-runtime health semantics, Windows app/installer +handoff, cross-runtime registry interoperability, and manager-generated output +authority. `003`, `010`, `020`, `030`, `040`, `050`, `090` and `100` now +describe proposed resolutions and falsifiable tests. The installed SQLite +dependency and Node/Bun broker are proposed new reviewed boundaries, not +existing capabilities. + +Reflection 06 reviewed snapshot +`cd9d7c20127a19fc08452c3203f9320ccdbe3d17a81d50aee942fa18d5145b5b` +and found the six preceding design amendments addressed, while requiring the +CI-policy wording above and the native-to-badge channel transport in `003` +and `050`. The main agent accepted both findings. The subsequent audit is +recorded below; implementation proofs, Rust 1.90 and Node 18 interop and the +platform matrix remain gates. + +The independent roadmap audit of that snapshot returned **GO-WITH-FIXES** with +two medium blockers: the desktop badge's old non-null channel DTO lacked an +unknown-provenance migration, and linked-update dashboard actions lacked an +end-to-end management and GUI contract. The main agent accepted both findings; +`003`, `050`, `060` and `080` now propose separate versioned badge and linked +dashboard DTOs, precise legacy/old-server behavior, authorized actions and +future regression tests. The same independent reviewer re-audited these +amendments as recorded below. + +The independent follow-up accepted the badge DTO correction and identified a +remaining Retry A→B request-correlation blocker plus a non-blocking warm-cache +failure presentation issue. The same architect independently identified the +Retry gap. The main agent accepted both; `060` and `080` now specify durable +request-ID readback and replay behavior, while `050` requires stale badge data +to be visibly unknown after a failed latest observation. The subsequent +architect reflection and independent re-audit are recorded below. + +## Roadmap audit disposition + +The same architect's reflection 09 returned **ALIGNED** and independent audit +round 03 returned **PASS** for the 14-file snapshot +`251f5fc6aebd2c28d3c88096caa3033266587c55db3b56f613180b9275350cf9`. +The review closed the badge DTO, linked dashboard action/readback and stale +cache findings; its final round found no new high or critical blocker. The +reviewer checked staged whitespace, the privacy scan, citation ranges and +the changed consumer paths. This disposition records a plan audit only: no +proposed update implementation, artifact signature, platform install, +security review or exact-head PR CI is claimed to have passed. + +Before a PR is marked ready, fetch the current `origin/dev` and revalidate the +inventory and implementation plans on its exact resulting base. The last +audited fetched base was `35d5010f502a8efd973d75c9e7a1b44eecfde777`; its +WebSocket turn admission attaches a workflow lease and its binary GUI switch +uses `role="switch"` and `aria-checked`. Later upstream changes need a new +impact assessment. Every implementation unit remains subject to its own +failing-first tests, required checks and independent security review where +applicable; this roadmap audit is not permission to skip those gates. + +The independent roadmap reviewer must receive the original goal and hard +constraints, the exact plan revision, and the pinned source revisions. The +review must challenge the full file and field chains, reachable negative cases, +cross-version compatibility, source-to-artifact verification, destination +authority, recovery and PR dependency order. It must verify existing commands +and identify candidate commands that do not yet exist or do not observe the +proposed change. Record each finding's acceptance or evidence-backed rebuttal, +amend the plan, and re-review with the same reviewer until blockers are closed; +an architect reflection is not the independent audit. Security-sensitive +working notes remain in `.tmp/`. The review packet will attach the code-review +and search skills and require a normalized verdict. diff --git a/devlog/_plan/261107_auto_update_parity/001_inventory.md b/devlog/_plan/261107_auto_update_parity/001_inventory.md new file mode 100644 index 00000000000..57e09525513 --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/001_inventory.md @@ -0,0 +1,87 @@ +# Update parity inventory + +Baseline: OpenCodex `803d6c0b4dbb4823a9379e485e417f3f9e3d976c`; GOAT +`64e7198988b69941cd2eec5160fd734df9074302` (`origin/dev`). GOAT paths below +refer to that read-only Git revision. The independent architecture inventory +informed this comparison; the roadmap and its independent audit remain open. + +| Surface | Existing evidence | Initial gap to investigate | +| --- | --- | --- | +| Desktop checks | OpenCodex checks after 30 seconds and every six hours (`desktop/src-tauri/src/updater.rs:448`). GOAT starts after 15 seconds and checks every four minutes (`apps/desktop/src/updates/DesktopUpdates.ts:69`, `:1036`, GOAT revision above). | Decide cadence and user controls; do not add a duplicate scheduler. | +| GOAT Electron integration | GOAT wraps the platform updater and installs a request deadline before first use (`apps/desktop/src/electron/ElectronUpdater.ts:90`, `:100`, `:120`, GOAT revision above); its test verifies lazy initialization and that deadline (`apps/desktop/src/electron/ElectronUpdater.test.ts:38`, `:46`). The Electron app wrapper exposes quit/relaunch and the before-quit-for-update event (`apps/desktop/src/electron/ElectronApp.ts:166`, `:174`, `:234`, GOAT revision above). Automatic-update tests cover pause, retry, reservation and busy-at-admission cases (`apps/desktop/src/updates/DesktopUpdates.automatic.test.ts:91`, `:116`, `:271`, `:652`, GOAT revision above). | Use bounded requests and verify equivalent behavior through Tauri's own owner; no Electron code is imported into OpenCodex. | +| Desktop download and install | OpenCodex downloads through the pinned updater, which verifies the signature, before its guarded restart and install; failed install can recover the runtime (`desktop/src-tauri/src/updater.rs:388`, `desktop/src-tauri/src/updater.rs:423`). | Expose progress and verified staged readiness while preserving signature verification and drain/recovery. | +| Desktop badge | The desktop snapshot includes a session, version, availability, timestamp and phase (`src/update/desktop-badge.ts:4`); the badge projection currently exposes availability and unknown but discards the phase (`src/update/desktop-badge.ts:74`). | Carry authoritative progress and failure states to the footer without treating missing or stale evidence as current. | +| Sidebar | `gui/src/components/sidebar-github-row.tsx:77` polls the badge and `:157` renders the existing download button; `gui/src/App.tsx:591` opens the native update page on desktop. The version is rendered at `gui/src/App.tsx:602` and deliberately ellipsized by `gui/src/design/bridge.css:429`. Native update commands require the trusted update page (`desktop/src-tauri/src/lib.rs:267`). | Make that button the requested stateful update-panel entry and resolve the reported truncated version; retain browser/package behavior and the existing native command origin boundary. | +| Package updates | The Node launcher imports the existing orchestrated plan/apply, installation ownership, transactional install and guarded runtime mechanisms (`bin/ocx.mjs:50`, `bin/ocx.mjs:69`). The CLI advertises latest/preview plans and token-bound apply (`bin/ocx.mjs:1322`). npm publication uses trusted publishing with generated provenance (`.github/workflows/release.yml:1152`). | Reuse ownership and guarded apply contracts, and require the requested publisher signature verification for update artifacts. Validate a concrete signed supply and its availability before treating provenance as a solution. Distinguish package and signed desktop-bundle supply. | +| Package notification | Version cache refresh interval is 20 hours, with a 40-hour maximum cache age (`src/update/notify.ts:19`); background refresh is detached when stale (`src/update/notify.ts:182`). The in-process scheduler honors `OCX_DISABLE_UPDATE_CHECK=1`, avoids unsupported installers and backs off after failed checks (`src/update/refresh-scheduler.ts:24`, `:52`, `:87`). | Preserve the existing opt-out and no-refresh semantics while adding explicit independent controls. | +| Browser dialog | The existing dashboard update dialog offers latest/preview, checks, errors, restart choice and an explicit update action (`gui/src/pages/dashboard-dialogs.tsx:29`). | Keep its installed-package semantics consistent with any shared state and copy. | +| Channels | OpenCodex's configured Tauri feed uses `latest.json` (`desktop/src-tauri/tauri.conf.json:68`); release verification generates that manifest only with the updater signing key and requires signatures in that case (`.github/workflows/release.yml:824`). npm uses `latest` and `preview` tags (`.github/workflows/release.yml:1051`). GOAT publishes stable and nightly feeds; its documented preview is a PR build, not a third published feed (`docs/internals/release-channels.md:19`, `docs/internals/release-channels.md:80`, GOAT revision above). | Establish actual artifact availability before presenting a channel as usable; never invent a nightly feed or treat a digest as a signature. | +| GOAT update states and policy | GOAT's state includes install policy, available and downloaded versions, release notes, download percent and retry information (`apps/desktop/src/updates/updateMachine.ts:18`, GOAT revision above). Its default downloads and restarts when local servers are idle **or on quit**; alternatives are install on quit and paused, with manual update still available (`docs/user/updating.md:120`, `:128`). WSL servers that cannot report idleness defer idle restart until quit or manual installation (`:136`). The coordinator disables electron-updater's implicit auto-download and install-on-quit and controls the sequence itself (`apps/desktop/src/updates/DesktopUpdates.ts:1398`); the paused policy blocks automatic downloads (`:620`). | Model the full state and user-controlled sequence without confusing library flags with the actual product policy. | +| Linked machines | Home fan-out sync selects and version-checks the Child executable before invoking sync (`structure/remote-link.md:9`, `src/link/ssh-argv.ts:281`); this is configuration sync, not evidence of binary update capability. OpenCodex already derives link compatibility from authenticated relay version and peer features (`src/link/compatibility.ts:71`, `src/remote/features.ts:44`). GOAT describes exact-build updates, idle gating and protocol-range compatibility (`docs/internals/remote-updates.md:19`, `:100`, GOAT revision above). GOAT's runtime supply documents HTTPS plus `SHA256SUMS`, without detached signatures (`docs/internals/remote-updates.md:163`, GOAT revision above). | Extend the existing compatibility and authorization owners for update capabilities rather than duplicating them; prove signed provenance and safe remote execution separately from sync. The user's signature requirement is stricter than the referenced runtime supply and remains mandatory. | +| Fan-out and orchestrator contracts | [PR #8100](https://github.com/lidge-jun/opencodex/pull/8100) merged to `dev` as `4948c04d9ced0cae90779ce03196088cc97aa906`. Current source advertises `sync.home-fanout/1` and `update.orchestrated/1` (`src/cli/capability-contracts.ts:1`). Fan-out waits for a current Home catalog, skips client-initiated/disconnected links, bounds concurrency to three and records per-Child results (`src/cli/sync-fanout.ts:99`). | Preserve both advertised contracts and avoid converting catalog sync into implicit binary installation; add a separately versioned update operation. | +| Server rollout and recovery | GOAT's server auto-update is on by default and separately disableable; stable/nightly remain on their channel and preview/dev/PR do not auto-update (`structure/decisions/ADR-0019-update-compatibility.md:50`, GOAT revision above). Stable waits 48 hours then rolls out over 72 hours, nightly rolls out over 12 hours without soak, and missing publication time is ineligible (`apps/server/src/cloud/autoUpdatePolicy.ts:79`). Busy activation retries every 10 minutes; a failed target is suppressed (`structure/decisions/ADR-0019-update-compatibility.md:57`, `:64`). A launcher trial needs exact-version and protocol health within 30 seconds, followed by 10 minutes' probation and owner-checked snapshot rollback (`:69`). | Assess each guarantee against OpenCodex's actual installation and service model; checksums alone must not be presented as publisher signature verification. | +| Isolated mock feed | GOAT's mock server serves files from a configured real root on localhost (`scripts/mock-update-server.ts:19`, `:111`, `:144`, GOAT revision above); its tests reject traversal and escaping symlinks (`scripts/mock-update-server.test.ts:23`, `:50`). Its release smoke uses a temporary root and validates merged manifests (`scripts/release-smoke.ts:216`, `:298`, GOAT revision above). | Build equivalent isolated fixtures for Tauri and package formats with test-only keys, bounded responses, failure injection and no access to real homes. GOAT's preview manifest smoke fixture is not evidence of a published preview feed. | +| Telemetry | GOAT updater code emits internal logs and spans (`apps/desktop/src/updates/DesktopUpdates.ts:485`, `:1232`, GOAT revision above). GOAT documents product usage and relay telemetry and an opt-out (`docs/user/telemetry.md:3`, `:23`, GOAT revision above); its desktop observability layer can export logs/traces to configured OTLP endpoints (`apps/desktop/src/app/DesktopObservability.ts:778`, `:803`, `:826`, GOAT revision above). This does not establish a dedicated updater analytics event. | Do not describe GOAT as categorically telemetry-free. The OpenCodex implementation must introduce no update telemetry; verify network destinations and privacy scan. | + +The coordinator described the desktop sidebar's existing footer and requested +states: current, available, downloading percentage, ready to restart and failed; +the panel should provide channel selection, automatic download and install +controls, release notes, restart and deferral. No screenshot is present on this +host. Defaults, supported channels, exact source changes and verification +remain decisions for the audited roadmap, not claims of implemented behavior. + +Baseline verifier discovery on 2026-11-07, before implementation: after +`bun install --frozen-lockfile` at the repository root and in `gui/`, +`bun test tests/update/update-desktop-badge.test.ts tests/update/update-badge.test.ts` +passed 17 tests. From `gui/`, +`bun test tests/sidebar-version-layout.test.ts tests/sidebar-rows.test.ts` +passed 12 tests. The first pair exercises badge source modules; the second pair +checks sidebar source and header styling, not rendered footer geometry. The +initial runs failed because the checkout had no installed dependencies; the +GUI test paths also need to be run from `gui/` or explicitly prefixed with `./`. +These baseline results do not prove any future change. + +Further baseline verifier discovery on 2026-11-07: +`bun test tests/clients/desktop-update-surface.test.ts tests/ci-workflows/release-desktop-scripts.test.ts` +passed 48 tests, including the existing desktop-page harness and release +signature verifier. `bun test tests/cli/sync-fanout.test.ts +tests/clients/link-peer-compatibility.test.ts` passed 22 tests, exercising +the existing fan-out classifier and link compatibility implementation. These +tests directly read or import their existing owners; they do not prove any +future signed package or remote-update design. + +`bun run structure:check` also passed at the baseline (exit 0). Its script +checks the `structure/` manifest, source ownership and invariant bindings +(`scripts/structure-ssot.ts:299`, `:518`, `:573`); it does not validate this +`devlog/` roadmap's correctness. Roadmap review is a separate human/independent +audit, and new structure files must be staged before rerunning that gate. +`bun run typecheck` passed at the baseline (exit 0; 2,326 files, no type +errors). This checks TypeScript, not Rust, rendered UI or this prose roadmap. +`bun run privacy:scan` passed after staging the draft unit, because that scanner +enumerates tracked/indexed files (`scripts/privacy-scan.ts:64`). Re-run it on +the final staged roadmap before publication. +`bun test tests/lab/core-lab-boundary.test.ts` passed 25 tests (exit 0); it +checks protected core import graphs and the synchronous Lab activation window. +`bun test tests/test-layout.test.ts tests/test-layout-tooling.test.ts` passed +29 tests (exit 0), including the repository membership oracle and expected +fixture comparison. It checks test placement and map consistency, not whether +the planned regression tests are adequate. +`bun scripts/file-size-ratchet.ts` passed (exit 0) on the baseline; it reads +the repository baseline and current file sizes without updating the caps +(`scripts/file-size-ratchet.ts:212`, `:224`). +The ratchet's general threshold is 2,000 lines and Rust is not among its +scanned extensions (`scripts/file-size-ratchet.ts:4`). At this baseline +`src/update/job.ts` has 1,986 lines and no per-file baseline entry, leaving +only 13 additional lines before it reaches the rejected threshold. Prefer a +sibling module for substantive additions; recheck current counts after each +prerequisite lands. A missing baseline entry does not mean a tracked file is +untracked by Git. + +The bundled desktop page is `desktop/ui/update.html`; its existing status, +check and install commands are guarded to that page in +`desktop/src-tauri/src/lib.rs:267` and `desktop/src-tauri/src/window.rs:115`. +`tests/clients/desktop-update-surface.test.ts:38` exercises the page and its +command boundary. The dashboard receives desktop state via +`src/server/management/sidebar-routes.ts:137`, whose store strictly validates +the snapshot field set (`src/update/desktop-badge.ts:31`); any additional state +must be designed end to end, including older shells and stale sessions. diff --git a/devlog/_plan/261107_auto_update_parity/002_gap_ledger.md b/devlog/_plan/261107_auto_update_parity/002_gap_ledger.md new file mode 100644 index 00000000000..2c7be1d87d3 --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/002_gap_ledger.md @@ -0,0 +1,29 @@ +# GOAT versus OpenCodex update gap ledger + +Evidence and source revisions are in [001_inventory.md](001_inventory.md). +Every row is **open** until its named unit ships and its acceptance evidence is +recorded. A baseline check or draft plan does not close a gap. + +| Requested capability | Existing OpenCodex surface | Gap owner and closure evidence | +| --- | --- | --- | +| Background discovery and cadence | Package cache scheduler and Tauri six-hour checks | `030`, `040`: policy-controlled, bounded checks and failure/backoff tests; user can disable them. | +| Stable, preview and nightly selection | npm latest/preview; Tauri latest feed | `010`, `030`, `040`, `050`: signed channel metadata, actual publication routing, no implicit channel changes, unavailable-feed state. Feed publication itself is outside this task and must be reported if outstanding. | +| Signed download and verification | Pinned Tauri updater verifies bytes; package path checks registry SRI | `010`, `030`, `040`, `070`, `090`, `100`: exact signed artifact and complete executable closure, offline positive/negative verification and owner-bound stage for each owner. | +| Download progress and staged readiness | Tauri download currently occurs inside installation | `030`, `050`: distinguish progress, verified ready and unknown; retain or re-establish stage with safe recovery. | +| No-interruption automatic activation | Terminal drain can abort turns at its deadline | `020`, `030`, `040`, `060`: fenced idle admission, owner-bound stop, race and long-stream tests, safe deferral. | +| Restart, Later and user controls | Explicit desktop install and package dialog | `030`, `040`, `050`: persisted independent check/download/install controls, defined default, explicit install-on-quit option, Later and restart behavior across quit/restart. | +| Sidebar state and release notes | Existing availability dot and update page | `050`: current, available, downloading percentage, ready and failed state; safe localized panel, release notes and keyboard/visual proof. | +| Sidebar version readability | Footer version currently ellipsizes | `050`: stable and long version geometry and accessible full value at relevant viewport/zoom sizes. | +| Failure, rollback and health | npm transaction rollback and desktop failed-install recovery | `030`, `040`, `060`, `070`, `090`, `100`: signed recovery material, durable journal, target health, probation, failed-target suppression, recovery and uncertainty tests for each owner. | +| Linked-machine update and sync | Home fan-out sync, peer features and compatibility | `060`, `080`: separate authenticated update contract for both link directions, independent Child updates, destination policy and Desktop owner bridge, target compatibility, durable fleet resumption, per-Child results and post-update sync; sync alone does not close this gap. | +| Standalone installation updates | Standalone release artifacts exist; current orchestrated plan refuses unsupported ownership | `070`: signed platform artifact, owner-bound replacement, guarded stop, rollback and health proof for every supported target. | +| Telemetry-free update behavior | Existing update checks and local logging | All units: no new update telemetry, bounded local status and passing privacy scan. GOAT's broader telemetry is documented in `001`; do not misstate it. | +| Mock and isolated testing | Existing isolated update fixtures and GOAT mock reference | `010` and each implementation unit: test keys, local mock feed, isolated homes and no real service or installation changes. | +| Security, docs and delivery | Existing ownership, release and test gates | Each unit: independent security PASS where required, docs/locale/structure sync, Lab boundary, file-size/test-layout guards, exact-head CI and a `dev` PR reported to the coordinator without merging. | + +Open design blockers: signed trust-root provisioning and rotation, exact +manager-specific signed staging and rollback, complete activity fencing and +stop-to-installer handoff, remote operation authorization and future-version +compatibility metadata, nightly publication routing, cross-platform recovery, +and exact field-chain/test mapping. Their resolution and independent audit are +required before the roadmap can be locked. diff --git a/devlog/_plan/261107_auto_update_parity/003_contracts.md b/devlog/_plan/261107_auto_update_parity/003_contracts.md new file mode 100644 index 00000000000..5da7009d802 --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/003_contracts.md @@ -0,0 +1,158 @@ +# Proposed update contracts — draft + +These names bind the roadmap drafts to one vocabulary; none is implemented or +approved yet. Security review must resolve exact encoding, authorization and +rotation before a unit is executable. Existing `ocx.update.plan/1`, +`ocx.update.result/1`, `ocx.sync.fanout/1` and desktop v1 snapshots remain +compatible contracts; do not add fields to their strict parsers in place. + +| Contract and fields | Creation → serialization → parsing → consumers | +| --- | --- | +| `ocx.update.root/1`: `schema`, `revision`, `expiresAt`, `rootKeys`, `rootThreshold`, `releaseKeys`, `releaseThreshold`, `channels` | The initial root is embedded in the shipped clients from the repository's existing pinned updater key (`010`); Node/Bun and native builds consume the same generated public-key bytes and a test compares them with `desktop/src-tauri/tauri.conf.json`. A root file is signed over its exact UTF-8 bytes by detached, bounded signature records. A later revision is accepted only when both old and new thresholds verify, the revision increases and the record is unexpired; the highest accepted root is stored atomically by the owning installation. Unknown, expired, rollback or unverifiable roots refuse automation. No private keys are embedded or created by local tests. | +| `ocx.update.release/1`: `version`, `channel`, `sequence`, `sourceCommit`, `rolloutNotBefore`, `targets` | Release builder creates the exact metadata and signs its bytes (`010`); saved/served as bounded UTF-8 bytes; `signed-supply.mjs` verifies signature before strict parsing; policy, package and remote selection consume the resulting verified candidate (`040`, `060`). Native Desktop selects its updater target and delegated artifact key only from the verified record, then separately verifies the artifact through Tauri (`030`). Unknown schema or signature is refused, not coerced. | +| `ocx.update.tree/1`: `version`, `target`, `entries` with path/type/mode/size/digest and internal-link target | Build after package preparation (`010`); signed release record binds the exact inventory bytes and archive digest; strict extractor and `signed-tree.mjs` validate the complete set before execution; package adapter and recovery consume the verified stage (`040`). No transport may introduce extra tree entries. | +| `ocx.link-capabilities/1`: exact version, channel, target and artifact digest; provided and required protocols; update actions; installer, recovery and journal-reader versions | Release builder emits bounded descriptor bytes and binds their digest in the signed target record (`010`); shared strict parser verifies the binding before returning typed data; fleet comparator checks each candidate and retained recovery artifact (`060`). Absence is unknown, not a capability inferred from version. | +| `ocx.update.policy/1`: `revision`, `channel`, `check`, `download`, `install` | Native and package policy owners create and atomically persist their own records (`030`, `040`); strict parser accepts only known values, distinguishes missing from corrupt, and never silently enables automation on corrupt state. Coordinator captures revision before effects, rechecks it at download and activation, and panel displays owner-projected values (`050`). Remote requests carry a destination revision but cannot change it (`060`). | +| `ocx.update.prepared/1`: `operationId`, candidate identity, stage identity/digest, installation owner, policy revision | Installer owner creates only after verification (`030`, `040`); persists bounded private recovery metadata where supported; owner reconstructs/reverifies bytes after restart. Admission consumes the opaque operation identity and exact stage binding (`020`); UI receives only state, not authority (`050`). Invalid or stale bindings refuse. | +| `ocx.update.activation/1`: operation ID/generation, runtime instance, endpoint, installation owner, candidate/stage digest, policy revision, deadline | Local update coordinator creates descriptor after verified preparation (`020`); authenticated stop transport carries bounded bytes; runtime admission parses under its locks and returns an owner-bound permit; the external stop owner commits or cancels it. No dashboard snapshot, peer observation or existing unkeyed plan hash is treated as permission. | +| `ocx.update.stop/1`: operation identity, disposition, runtime-exit and manager observations, teardown state | Receipt-backed stop owner produces after admission (`020`); native/CLI installer parses and verifies process exit and exact operation; only a proved stop permits swap. Unknown or lost responses are reconciled and never trigger another installer. Old clients do not invoke this contract. | +| `ocx.desktop.update/2`: current version, candidate identity/channel, phase, bounded progress/error, policy revision and values, release-note text, deferred state | Native updater owns and creates the panel result (`030`); local update-page commands return it and accept only validated candidate IDs or policy revisions (`050`). The bundled page renders text safely. This contract is not accepted from the dashboard origin and does not grant installation authority. | +| Desktop snapshot v2: `schema`, `sessionId`, `sequence`, `currentVersion`, `latestVersion`, `available`, `checkedAtMs`, `phase`, `progressPercent`, `errorCode`, `installedChannel`, `policyChannel`, `candidateChannel` | Native publisher creates the bounded projection (`030`, `050`) from the verified installed provenance, current policy and verified candidate respectively; each channel is `latest`, `preview`, `nightly` or null when unavailable. The body-authenticated session transport remains capped at 1 KiB; `desktop-badge.ts` accepts v1 or strict v2 and preserves per-session ordering. Badge values are display observations, never installation authority. A successful v1 publication may advertise `snapshotSchemas: [1, 2]` in the response; absent advertisement keeps v1. Auth/transport failures do not negotiate. V1 lacks provenance and cannot imply preview from version spelling. Release notes do not enter this projection. | +| `ocx.desktop.badge/2`: `schema`, `sessionId`, `currentVersion`, `latestVersion`, `updateAvailable`, `unknown`, `phase`, `progressPercent`, `errorCode`, `installedChannel`, `policyChannel`, `candidateChannel` | The server's session-scoped snapshot store produces a display-only projection; the separately versioned desktop badge GET serializes it, the GUI strictly parses and renders it (`050`). All three channels and unavailable session/version fields are nullable; never infer channel from version. Legacy GET keeps its old DTO when provenance is known and representable, otherwise returns an explicit non-success unavailable result. Package badge and legacy DTO shapes do not change. | +| `ocx.link-update.envelope/1`, `ocx.link-update.request/1`, `ocx.link-update.result/1`: operation identity, link, candidate, destination policy revision, expiry and action | Home creates bounded request after local selection (`060`); pinned SSH carries it to the destination; Child authenticates and validates link, local policy, candidate and owner under the proper locks before effects; Child journal emits idempotent status and Home fleet journal reconciles it after restart. Existing sync and read-only management relay remain separate. Exact proof format and lock sequence remain open. | +| `ocx.link-update.grant/1`: grant identity/epoch, Home public key identity, Child/configuration/installation and link binding, allowed actions and expiry | Destination owner explicitly approves and persists a local grant (`060`); Child validates it and its current local policy before an operation; Home cannot create or widen that grant remotely. Revocation, relink and key rotation invalidate the old binding. No credential or private key appears in status projections. | +| `ocx.link-update.dashboard-status/1`, `ocx.link-update.dashboard-action/1`, `ocx.link-update.dashboard-action-readback/1` | Home's authenticated management owner projects bounded, destination-scoped journal evidence and accepts revision-bound operator actions (`060`); request-ID readback binds original and resulting operations after a lost acknowledgement. The GUI validates responses and presents only observed outcomes. Destination-local grants and policy remain authoritative and the read-only relay is unchanged. | + +The new field names above must be reflected verbatim in each unit's final +file map and tests. The proposed per-platform signed tree is a publisher +attestation of final build output; it is not a claim of reproducible builds. +Avoid sensitive data in all status records and logs. Capability absence or an +unknown schema produces an explicit unavailable/unknown result, never a +fallback to an unverified install. + +## Exact release-candidate binding + +`ocx.update.release/1` is a closed object containing `schema`, `version`, +`channel`, positive safe-integer `sequence`, full source commit, +`rolloutNotBefore`, `receipt`, `releaseNotes` and a bounded nonempty `targets` +array. `receipt` binds a SHA-256 and size. Each unique target has an exact +platform/architecture/owner-compatible `id`, `artifactKind`, `artifact` +(`sha256`, `size`, `signatureBox`, `signerFingerprint`), `tree` (null for +native bundle formats or signed inventory digest/size), `capabilities` +(descriptor digest/size), and approved source/asset identity. Reject duplicate +target IDs, malformed hashes, missing fields and unknown enums. A consumer +never accepts an arbitrary filesystem path or URL from a caller as install +authority. `010` derives the approved release URL and `030` enforces its +production transport policy. + +The release builder first verifies the exact source, four version files and +artifact set and emits a bounded `ocx.update.verification/1` receipt containing +source commit, version, channel, workflow run/attempt, version-source digests +and ordered asset digests/sizes. The receipt does not contain the later release +record or its own digest. After verification, the signed release record binds +the exact receipt bytes and artifacts, avoiding a circular digest. Target +selection returns a candidate ID derived from a domain separator, the exact +release-record SHA-256 and the length-prefixed target ID. It is a lookup value, +not a replacement for an owner-held prepared handle or consent. + +`010` owns the shared strict parser and golden vectors; `030`, `040`, `060` +and `070` create their owner-specific prepared state only from the verified +candidate. Tests must reject changed receipt/target/signature/bytes, wrong +channel or owner, ambiguous targets, same-sequence substitutions and an +unverified release listing. The selected candidate, policy revision and actual +owner are rechecked before every side effect. Old strict output schemas remain +separately decoded. + +## Publisher payload and manager output + +The publisher-signed tree inventory is an exact closed set for publisher +payload: every listed file/link/type/mode/digest must match and no unlisted +publisher payload is accepted. Package-manager output is a separate local +owner record, never relabeled publisher-signed. Each supported manager/version +adapter has a closed allowlist of generated metadata and bin/link paths, parsed +schemas and canonical wrapper templates; bind every target and path to the +selected installation, global/bin/cache/store identity and verified payload. +Reject unknown generated entries, executable text that differs from an +adapter-owned exact template, links escaping allowed roots, unexpected paths, +unrecognized manager versions/layouts and missing or conflicting ownership. +Do not use a locally generated checksum as publisher authentication. + +The adapter journals the exact validated generated-output digest and owner +identity for readback and recovery; that digest detects drift but does not by +itself authenticate the manager. Manager execution is permitted only through +the selected trusted installed manager and under installation-scoped exclusion; +verify the signed consumed inputs and installed payload again before any new +candidate executable runs. A nonparticipating or unknown writer remains an +explicit unresolved boundary under `020`, not an assumed lock guarantee. +Per-manager tests cover every allowed metadata/wrapper class, foreign entries, +path changes, unsupported layouts and interrupted recovery. The actual supported +version/platform allowlist is enabled only after those tests and independent +security review pass. + +## Signed-root draft encoding + +The root is a strict JSON object with `schema: "ocx.update.root/1"`, positive +integer `revision`, RFC3339 `expiresAt`, `rootKeys` and `releaseKeys` as bounded +arrays of `{keyId, algorithm, publicKey}`, integer thresholds, and `channels` +as a distinct subset of `latest`, `preview`, `nightly`. `algorithm` is the +explicit Tauri-compatible minisign prehashed format; `keyId` is the full +public-key fingerprint, with the format's short identifier checked as well. +Each release-key entry additionally names its nonempty `channels` and `roles` +subsets; a target may select it only for an explicitly delegated channel and +role. Root-key entries have no release delegation fields. Allowed release +roles are `release`, `tree`, `desktop-artifact`, `standalone-artifact` and +`guardian-artifact`; threshold and unique-key checks apply separately to the +role being verified. +Detached signatures carry `{keyFingerprint, signatureBox}` in the envelope +defined in `010` and authenticate the exact file bytes. Reject duplicate keys, duplicate JSON names, thresholds outside the +unique key count, unknown fields and unsupported algorithms. Initial threshold +is one pinned root key and one delegated release key; a feed cannot add a new +root without the rotation rule above. The signature-envelope proposal and +required cross-runtime test vectors are in `010`; they require independent audit. + +The native candidate bridge must first verify the release record through the +same trusted root, select an exact `(channel, version, target, artifact digest)` +tuple, then construct the pinned Tauri updater's release input from that +verified record. The updater verifies the artifact signature on download and +again on install. Cached metadata is reconstructed with `restore_update`, +which requires signed-version binding; a mismatch, unsigned version or +unavailable verifier yields no ready stage. This applies to fresh checks too: +unsigned feed version or channel labels never select installation authority. + +## Future link compatibility descriptor + +`ocx.link-capabilities/1` is a closed JSON object with `schema`, `version`, +`channel`, `target`, `artifactSha256`, `homeProvides`, `childRequires`, +`updateActions`, `installerAdapters`, `recoveryProtocols` and +`fleetJournalReaders`. Each of the last six fields is a bounded array of +unique `{id, version}` pairs: `id` is a stable ASCII protocol/adapter/action +identifier and `version` is a positive integer. Arrays express exact supported +versions, not ranges inferred from release strings. Empty arrays are explicit; +missing, malformed, duplicated or unknown schema data is `unknown`. The +signed target record binds the digest and length of the exact descriptor bytes; +the descriptor's artifact digest and target must equal the selected target. +This avoids a circular release-record digest. A descriptor for a retained old +artifact must itself be publisher-authenticated and bound to that exact +artifact; a current peer report is not a substitute. + +Add `compatibilityEpoch` and `compatibilityVectorSha256` to the descriptor. +The vector is canonical encoding of the provided/required protocols, update +actions, recovery and journal-reader versions relevant to interoperation, with +strict ordering and duplicate rejection. Publisher release checks certify that +every artifact declaring the same epoch and vector implements that vector; a +changed vector requires a new epoch. The artifact-specific descriptor still +binds version, target and digest, while the shared vector identifies the +compatibility horizon rather than claiming different artifacts have the same +digest. The release verifier must test this invariant against the source-owned +feature and protocol implementations before signing. + +The `060` comparator first verifies both descriptors and their exact artifact +bindings. For each required `{id, version}` in the Child's `childRequires`, the +Home's `homeProvides` must contain the identical pair. The selected update +action, destination installer adapter, recovery protocol, and journal-reader +version required by the specific operation must likewise be explicitly present +in the relevant descriptor. A valid descriptor with a missing required pair is +`incompatible`; absent or unverifiable evidence is `unknown`. Neither result +permits automatic activation. Comparator test vectors cover all Home/Child and +recovery pairs, same release with different artifact, explicit empty arrays, +unknown schema, duplicate entries and forged or missing descriptor binding. diff --git a/devlog/_plan/261107_auto_update_parity/010_signed_supply.md b/devlog/_plan/261107_auto_update_parity/010_signed_supply.md new file mode 100644 index 00000000000..38de74cc113 --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/010_signed_supply.md @@ -0,0 +1,320 @@ +# Signed supply and channel contracts — draft unit + +**Status:** evidence and design options only. The exact artifact and trust +contract requires the architect proposal, independent security review and +roadmap audit before this becomes an executable unit. + +## Existing supply + +The release verifier expects standalone archives with SHA-256 sidecars, while +its required updater signatures cover desktop updater targets +(`desktop/scripts/verify-release-assets.ts:45`). The Tauri feed names exact +desktop artifact URLs and signatures (`desktop/scripts/updater-manifest.ts:18`). +The verifier pins the configured updater public key and verifies Ed25519 +signatures (`desktop/scripts/verify-release-assets.ts:180`). npm trusted +publishing generates provenance (`.github/workflows/release.yml:1151`); a +publisher-verification contract must be established for the requested update +experience. Integrity metadata alone is not a publisher signature. + +## Required design decision + +The read-only `auto-update-signed-supply-research-01` investigation recommends +publisher-signed, self-contained installation trees as the primary candidate. +Existing npm provenance remains an alternative, but its entire executable +dependency closure and offline verification are not yet established. The +proposal is not a security review or proof that artifacts already exist. +Prove a reproducible, offline-testable signature contract for the *exact bytes* +used by every automatic installation, including publisher, version, platform, +channel, key rotation and artifact-to-install binding. A release must never be +published as part of this task. + +Proposed signed supply consists of a versioned trust root +(`ocx.update.root/1`), a release record (`ocx.update.release/1`), a complete +tree inventory (`ocx.update.tree/1`) and a directly signed tree archive for +each supported platform. Sign exact UTF-8 metadata bytes, not a reconstructed +serialization. The release record binds source commit, version, channel, +sequence, target, archive digest and size, and tree-inventory digest. The tree +inventory covers every executable and dependency, including Bun, native keyring, +optional native modules and generated compatibility assets. Reject duplicate or +unknown fields, unsupported algorithms, invalid paths and oversized input. +The release builder freezes the tree only after package preparation +(`package.json:71`). + +Proposed initial trust root: the existing updater public key already pinned in +`desktop/src-tauri/tauri.conf.json:68`, using the Tauri-compatible +Ed25519/BLAKE2b signature format and verifier precedent +(`desktop/scripts/verify-release-assets.ts:186`). The release record and tree +archive must each verify under a release key delegated by that pinned root; +a feed-provided key alone is never a trust root. Root revision updates require +authorization from both the currently trusted and replacement roots; persist +the highest accepted revision and channel sequence. A lost or compromised root +requires a separately authorized manual software/key recovery; do not silently +trust a replacement from the feed. Test fixtures use separate keys only. + +The research lane also proposed a two-of-three offline root. The initial plan +does not assume three existing maintainer keys or perform a key ceremony; it +starts from the repository's existing publisher trust anchor. Security audit +must assess that operational tradeoff, the exact signer availability and +rotation procedure before implementation. No private signing material is +created, requested or used during this task's local tests. + +## Proposed detached signature format and rotation + +The existing release verifier parses the Tauri public-key box as `Ed`, an +eight-byte key ID and 32 public-key bytes, and its updater signature as `ED`, +an eight-byte key ID and a 64-byte signature +(`desktop/scripts/verify-release-assets.ts:155`, `:186`). `ED` verifies ordinary +Ed25519 over the BLAKE2b-512 digest of the **exact input bytes**, followed by +the minisign global signature over the raw signature and trusted comment +(`:204`, `:212`). It is not Ed25519ph. Keep Tauri's base64-wrapped minisign +signature box for artifacts; do not invent a different cryptographic meaning +for an existing `.sig` file. + +For root, release and tree metadata, propose a separate closed +`ocx.update.signatures/1` JSON envelope `{schema, signatures}`. Each entry is +`{keyFingerprint, signatureBox}`, where `keyFingerprint` is lowercase SHA-256 +of the 32-byte Ed25519 public key and `signatureBox` is canonical standard +base64 of the four-line Tauri minisign box. Each signature authenticates the +exact accompanying metadata file bytes; no parse-and-reserialize step occurs +before verification. The expected metadata schema and verification role are +chosen by the consumer and checked after cryptographic verification; a root +record cannot be accepted as a release record. Limit root metadata to 64 KiB, +release metadata to 1 MiB, tree inventory to 16 MiB, signature envelope to +64 KiB, and keys/signatures to 16 per role. Reject duplicate fingerprints, +noncanonical encodings, unknown algorithms, short packet IDs that disagree with +the full authorized key, malformed UTF-8, invalid global comments, duplicate +JSON keys and schema/role mismatches. Initial key threshold is one, as stated +above; threshold counting is over distinct authorized full fingerprints. + +The embedded initial root delegates release keys per channel and role; the +verified release record selects exactly one authorized artifact key fingerprint +for each target. The native client verifies the root and release first, selects +the target's delegated key, then passes the corresponding verified minisign +public-key box to the updater builder's `pubkey` override. The locally installed +`tauri-plugin-updater` 2.14.1 exposes this override in `src/updater.rs:348`; +the signed target digest and signature still bind the exact downloaded bytes. +The existing release verifier currently checks the configured pinned updater +key (`desktop/scripts/verify-release-assets.ts:202`), so the supply unit must +update it to check only an authorized delegated key and exercise both old and +rotated configurations. Root rotation accepts a strictly higher root revision +only when signatures by distinct keys meet both the current-root and proposed- +root thresholds; write the validated root and high-water mark atomically before +using newly delegated keys. Replayed or partially authorized root transitions, +unknown channels, mismatched key IDs and an interrupted persistence step refuse. + +For desktop assets require a verified minisign trusted comment containing the +matching signed version on both fresh and restored updates. The pinned plugin +enforces this on restored metadata, but its fresh-check behavior depends on +`require_signed_version` (local crate `src/updater.rs:673`, `:1928`); the +implementation must set and test that option or prove an equivalent mandatory +check. Include shared fixture-key vectors for valid and invalid boxes, changed +bytes/comments/version, old/new root threshold transitions, replay, partial +write and cross-channel key selection. Run the existing Rust plugin verifier and +the Bun/Node verifier against the same fixture bytes; differing results block +the unit. Operational signer provisioning, offline root custody and recovery +after lost keys still require a separate independent security PASS. + +## Platform and owner matrix to implement + +| Surface | Existing published build targets in source | Required automatic behavior | +| --- | --- | --- | +| Tauri desktop | macOS arm64/x64, Windows x64, Linux x64 AppImage/deb (`desktop/scripts/updater-manifest.ts:30`) | Use the signed desktop feed for the exact bundle target; a missing target/channel is unavailable. Verify actual release assets and the Linux bundle-type selection. | +| Standalone runtime | macOS arm64/x64, Windows x64, Linux x64/arm64 (`scripts/standalone-targets.ts:7`) | A signed exact-platform artifact and an owner-specific replacement/recovery contract are required; current standalone ownership is not automatically eligible. | +| npm global | npm-owned package roots and bin links; platform-specific dependency tree selected by installation | Provide a signed complete tree for each supported platform and prove ownership, bin compatibility, stage and rollback. Missing closure is unsupported. | +| pnpm and Bun global | Existing owner-specific global operations, not a proved download-only stage | Implement and independently verify each manager's signed offline staging, activation, shims and rollback. Until proven, show unsupported; these rows remain open parity work. | +| mise, source, unknown or foreign owner | Existing plan refuses them (`src/update/orchestrated-plan.ts:28`) | Keep the refusal and provide the owning tool's manual guidance. A desktop-owned bundle uses the native desktop owner, never a package-manager swap. | + +The release record's `targets` entries must identify platform/architecture, +owner-compatible artifact kind, signed archive size/digest, signed tree digest +and supported link capability metadata. They are a closed list of what the +release actually produced, not inferred from the host version. Tests must prove +each advertised target has a matching signed artifact and that an unlisted +target cannot be selected. + +Each signed release record also binds bounded, plain-text release-note items +to its exact version and channel. The panel may gather verified same-channel +records newer than the installed version through the selected candidate and +format them under the bounded grouping contract in `050`; an untrusted +release listing locates records but supplies no authenticated notes or count. +Missing history remains explicitly unknown and never changes artifact trust. + +Client preparation verifies signed metadata and archive bytes, extracts as +data without lifecycle scripts, validates every inventory entry and rejects +unlisted entries, then binds the owned stage and installation identity to an +opaque prepared handle. At activation, reacquire the existing ownership and +sync/update guards, revalidate the handle and stage, and execute only the +verified absolute paths after the guarded stop. The client must not fetch a +replacement dependency or run a package lifecycle script after verifying a +different archive. Publisher-signed output authenticates the publisher's +artifact; it is not a claim that the build is reproducible from source. + +The user requires signatures for automatic updates, stronger than GOAT's +documented HTTPS-plus-checksum runtime supply +(`docs/internals/remote-updates.md:163`, GOAT reference revision). A missing, +invalid, unknown-publisher or mismatched signature yields a visible refusal, +never a fallback to unsigned bytes. The package unit must migrate every +affected manual and automatic installation path to verified supply while +preserving the command's documented interface; compatibility with existing +installations does not waive the new signature requirement. + +Channel parity is an open deliverable, not a UI-label substitution: current +release authority accepts `main`/`latest` and `preview`/`preview` +(`scripts/release.ts:499`, `.github/workflows/release.yml:1051`), while GOAT +publishes a distinct nightly feed. The final design must specify how a signed +nightly feed would be produced under the existing workflow trigger and +permission constraints, how preview and stable feeds are selected and +authenticated, and how a client behaves before a feed has actually been +published. This task may implement and test the release machinery but may not +publish a release. An unavailable feed remains an explicit outstanding item, +not proof of parity. + +The research lane proposes separate signed stable, preview and nightly +manifests through the existing manual release workflow. The earlier idea of +stamping a version into a workflow checkout after CI is rejected: current +release publication requires successful push CI for the exact source commit +(`.github/workflows/release.yml:1077`) and all version sources to match that +commit (`scripts/ci/release-preflight.sh:59`). A transformed source tree has +not received that proof and this task cannot weaken the CI policy. + +Concrete release-routing proposal for audit: keep the existing +`workflow_dispatch` event, `main`/`preview` ref guard and job permission sets. +On the `preview` ref, add `nightly` as an explicit distinct release channel +and npm dist-tag, with the existing `X.Y.Z-preview.YYYYMMDD[.N]` version shape +already committed in all four version sources. The channel comes from signed +metadata and the explicit release input, not the prerelease spelling; a +nightly publication must not move `latest` or `preview`. A maintainer prepares +the version through the repository's normal release-line process and waits for +the existing successful push CI on that exact preview commit before dispatch. +This preserves the documented preview branch version shape while giving the +nightly channel its own signed feed. No part of this task creates the release +commit or publishes a release. + +The four sources are `package.json`, `desktop/src-tauri/tauri.conf.json`, +`desktop/src-tauri/Cargo.toml` and the `opencodex-desktop` entry in +`desktop/src-tauri/Cargo.lock` (`scripts/release-version-sources.ts:153`). +Keep the expected-SHA/trusted-dispatch gate and exact commit CI proof. In every +packaging and publishing job, checkout that SHA and verify the four sources +against the selected version before generating assets; no workflow-side version +stamp is allowed. A signed release record binds channel, version, source SHA, +the verification-receipt digest and each target artifact digest. The receipt +also records the release workflow run/attempt and the exact four source-file +digests; verification checks the source bytes against the checkout and receipt +before signing. Release-generated packaging output is separately identified and +verified, not represented as a tested source commit. + +Update both early and final branch/tag/version gates, release argument parsing, +cross-channel global-floor checks, prerelease classification and resume logic +together (`scripts/release.ts:499`, `scripts/ci/release-preflight.sh:34`, +`.github/workflows/release.yml:1051`, `:1371`). The operator selects an unused +version that satisfies `version-line.ts`'s existing global tag floor and dev +pre-move checks; no assumption that `nightly` sorts after `preview` is made. +Resume is valid only for the same SHA, version, signed record and artifact +digests, with the existing publication-side identity checks intact. Fixture +tests must show nightly cannot move either existing dist-tag, that all sources +and the exact-SHA CI gate remain binding, and that changed or absent receipts +fail closed. npm trusted-publisher configuration and the initial signed feed +remain operational prerequisites; no feed is claimed live until separately +published by a maintainer. + +Because nightly and preview share the `-preview.*` version spelling, a version +string cannot identify the channel. Every supported installed owner stores an +owner-private authenticated provenance record binding installation identity, +exact artifact digest, signed release-record digest and channel. The installer +writes it only after verification and preserves it across startup and recovery; +the new code verifies the release record and actual owner before trusting it. +For a legacy installation without a provenance record, a stable version can +bootstrap as `latest` only with matching authenticated evidence; an ambiguous +prerelease is `channel-unknown` until the owner explicitly selects a channel +and a verified release establishes provenance. Corrupt, missing or conflicting +records never fall back from nightly to preview. A channel switch is an explicit +policy change and invalidates prior candidate authority. + +Update the complete channel field chain: Node launcher `bin/ocx.mjs:129`, +`src/update/index.ts:78`, `:229`, `src/update/refresh-scheduler.ts:58`, +`src/update/notify.ts`, `src/update/job.ts:226`, +`src/update/orchestrated-arguments.mjs`, `src/update/orchestrated-entry.ts`, +`src/update/desktop-badge.ts:87`, management routes in +`src/server/management/config-routes.ts:948`, and the browser owners named in +`050`. New three-channel check/apply requests use separately versioned routes +and schemas; preserve existing two-channel wire shapes. A new nightly owner +refuses legacy check/apply requests that would infer preview, returning an +actionable upgrade-client state. A new server receiving an old Desktop snapshot +without authenticated channel projects `unknown` rather than asserting preview. +Do not send a nightly artifact to an old updater that cannot preserve its +channel. Test first install, lost/corrupt policy, old/new clients and rollback, +and prove no inferred cross-channel installation occurs. + +For discovery, the client may inspect the GitHub release listing as an +untrusted index to locate a channel-specific signed record at an exact release +tag. Only a verified `ocx.update.release/1` record selects a target and +version; listing order or a mutable dist-tag is never installation authority. +Each immutable release attaches its own signed channel metadata and matching +desktop feed, rather than requiring an existing published asset to be edited. +Missing, stale, malformed, unavailable or unverified metadata leaves the +channel unknown or unavailable. The first in-scope release infrastructure unit +must prove exact source-version and record-to-artifact binding with fixtures; +this routing is still a proposal until the independent security audit passes. + +Proposed rollout for unattended package and fleet activation: stable waits 48 +hours after a signed rollout-not-before value, then opens deterministically +across local buckets over 72 hours; preview and nightly open over 12 hours only +for an explicitly selected channel. The bucket is computed locally from a +random per-installation identifier and exact target version, is never sent as +telemetry, and is stable across retries. Missing or invalid signed time, +unsupported channel, a downgrade and the recorded failed target are ineligible. +Manual checks can show an ineligible release and explain its wait; explicit +manual installation still requires signature and owner checks. GOAT's own +stable/nightly rollout constants are documented at +`apps/server/src/cloud/autoUpdatePolicy.ts:79` in the reference revision; this +proposal deliberately defines preview as a separate opt-in OpenCodex channel. +The current desktop manifest's `pub_date` is generated before publication +(`desktop/scripts/updater-manifest.ts:69`); it is not authenticated actual +publication time. Persist per-channel the highest verified sequence, its exact +release digest and version, and the latest accepted wall time in private owner +state, with an atomic write before automatic effects. A lower sequence, or the +same sequence with a different digest, is refused; an equal sequence and digest +is a retry of the same candidate. Root revision has its own independent +high-water mark. Record first observation per exact candidate; unattended +eligibility uses the later of signed `rolloutNotBefore` and local first-seen, +plus the channel delay. If the clock is unreadable or earlier than the last +accepted time, retain the state and defer until corrected. Test rollback, +restart, same-sequence substitution and write failure. These local checks do +not establish a trusted wall clock against a deliberate forward jump; document +that limit and do not describe them as a publication timestamp proof. + +## Candidate file map to resolve + +| Operation | Path | Purpose and evidence | +| --- | --- | --- | +| MODIFY if needed | `.github/workflows/release.yml`, `desktop/scripts/verify-release-assets.ts`, `desktop/scripts/updater-manifest.ts` | Produce and verify the selected signed supply and channel-specific manifests from exact release inputs; preserve the existing verified-bundle handoff (`release.yml:859`) and no new triggers, broadened permissions or unpinned third-party actions. | +| NEW | `src/update/signed-supply.mjs`, `src/update/signed-tree.mjs`, `src/update/prepared-install.mjs` and declaration siblings | Resolve signed metadata, verify bounded exact bytes and complete tree inventory, and retain an owner-held prepared handle. Final APIs, root provisioning, archive extraction and every caller remain audit blockers. | +| NEW | `src/update/update-contracts.mjs`, `src/update/update-contracts.d.mts`, `tests/update/update-contracts.test.ts`, `tests/fixtures/update-contracts/` | Own the first implementation of closed root, release, tree, policy, prepared, activation and capability-descriptor parsers plus shared test vectors described in `003_contracts.md`. `010` lands these before `020` consumes them; downstream owners create records and enforce their own authority. Register the test in both test-layout maps. The comparator remains owned by `060`. Exact exports and byte encodings still require final audit. | +| NEW | `scripts/build-update-tree.ts`, `desktop/scripts/sign-update-supply.ts` | Produce final self-contained per-platform trees and sign the verified bundle in an existing authorized release job; no additional workflow triggers, permission expansion or unpinned third-party actions. Bind exact SHA, toolchain and lock inputs in the signed release record. | +| NEW | `scripts/generate-update-trust-root.ts`, `src/update/trust-root.json` and a generated native resource under `desktop/ui/` | Derive identical initial public trust-root bytes from the existing Tauri public key, with deterministic output and a `--check` mode. The source key is public; tests compare Node/Bun and native inputs byte-for-byte. Never embed private signing material. Persist subsequent verified root revisions under the respective installation's private update state, not in the replaceable package tree. | +| NEW | `tests/helpers/mock-update-server.ts` and isolated fixture builders | Serve only test-generated signed metadata and artifacts from an isolated real root on loopback, using a test key, never the real install or production key. Mirror GOAT's bounded-root and traversal/symlink tests (`scripts/mock-update-server.ts:37`, `:144`; `scripts/mock-update-server.test.ts:23`, GOAT reference revision) and add controllable truncation, wrong-signature, timeout and progress responses. Verify a new helper is actually imported by the focused tests. | +| MODIFY if needed | `src/update/orchestrated-plan.ts`, `src/update/orchestrated-entry.ts`, `bin/ocx.mjs` | Bind automatic plan/apply to exact verified artifact identity while retaining current runtime ownership and token checks (`orchestrated-plan.ts:21`). Avoid widening existing explicit commands by accident. | +| MODIFY | `tests/ci-workflows/release-desktop-scripts.test.ts`, `tests/ci-workflows/release-pipeline-contract.test.ts`, focused `tests/update/` | Failing-first signature, publisher identity, tampered bytes, missing metadata, target/channel mismatch, fail-closed and release receipt tests. Register new domain test files in both layout and expected-fixture maps. | +| MODIFY | Source owners named by `structure/INDEX.md`; public update and release docs and translated pages | Describe only shipped behavior and supported channels; do not advertise a feed without a proven publisher. | + +The candidate file map is not the final implementation. Enumerate every +creation, serialization, parsing and consumer site for any new contract before +locking the plan. Design an isolated fixture with a dedicated test key or +test identity; never use production signing secrets. Prove that a verified +payload is the payload actually installed, not just a separately verified copy. + +## Acceptance and verification to ground + +- A correctly signed target with the expected identity and metadata succeeds in + an isolated home. Wrong key or publisher, altered bytes, absent signature, + wrong version/platform/channel, stale metadata and failed verification all + stop before installation or runtime mutation. +- Desktop stable and preview/nightly choices correspond only to signed feeds + the release workflow actually publishes. Unsupported choices are explicit; + no downgrade or cross-channel move occurs implicitly. +- Release dry-run fixtures verify exactly the assets that would be attached; + receipt version and commit bind the verified set. Tests prove no workflow + trigger, permission or unpinned-action expansion. +- Run the targeted release-script and update tests, `bun run typecheck`, + `bun run privacy:scan`, `bun run structure:check`, and exact-head CI with an + independent security PASS. Confirm every command's actual inputs and record + fresh results before locking or review readiness; no full root suite. diff --git a/devlog/_plan/261107_auto_update_parity/020_activation_admission.md b/devlog/_plan/261107_auto_update_parity/020_activation_admission.md new file mode 100644 index 00000000000..08de406d33b --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/020_activation_admission.md @@ -0,0 +1,386 @@ +# Automatic activation admission — draft unit + +**Status:** architect proposal received; exact contract and diff need independent +roadmap audit before implementation. This unit precedes any automatic restart. + +## Problem and contract + +The ordinary terminal shutdown starts a permanent admission fence, waits for +temporary drains and active turns, then aborts remaining turns after its deadline +(`src/server/lifecycle.ts:520`). Automatic installation must not rely on that +deadline as an idle check. A temporary drain cannot be held while the shutdown +path waits for temporary drains (`src/server/lifecycle.ts:131`). + +The existing automatic restart path already acquires a temporary fence, allows +an authority veto and transfers to permanent shutdown before releasing that +fence (`src/server/management/system-restart.ts:385`, `:439`). Extend and +reuse that handoff where its ownership and timeout contract fits; do not build +a competing restart path. It does not by itself prove the complete update-specific +idle, candidate and policy contract proposed below. + +An automatic update therefore needs a runtime-owned, operation- and +installation-bound reservation. It fences new data-plane admission, checks all +relevant activity, and exposes an expiring, one-use capability. Immediately +before activation it revalidates runtime identity, target, policy, owner and +idle while the fence remains held. An atomic handoff sets the existing permanent +shutdown latch and releases this reservation before shutdown waits for temporary +drains. Busy, uninspectable, expired, cancelled or changed state releases the +temporary fence and keeps the runtime serving. Exact ownership and failure +semantics must be reviewed against all runtime entry points; the reservation +is not proof that untracked work is idle. + +## Activity owners to fence + +The admission contract must be implemented across these distinct owners; a +single sampled count is insufficient. The exact fence APIs and cross-process +behavior remain audit blockers until verified in the implementation map. + +| Owner | Current evidence | Required automatic-update treatment | +| --- | --- | --- | +| Proxy turns and streamed responses | `tryAdmitTurn` checks `isDraining` (`src/server/lifecycle.ts:174`); admitted turns are tracked (`:365`, `:538`). | Acquire the existing global temporary fence before observing zero; hold it until transfer/cancel. A turn admitted before the fence blocks activation. | +| Codex WebSockets | Registry and metric owner `src/codex/websocket-registry.ts:3`, `:51`; lifecycle reports it separately (`src/server/lifecycle.ts:369`). | Determine whether a connection is idle or executing; fence new work at its actual admission owner. If that distinction cannot be proved, defer while any connection is present. | +| Cursor background shells | `src/adapters/cursor/native-exec-shell.ts:379`; lifecycle reports and shuts them down (`src/server/lifecycle.ts:370`, `:536`). | Treat active or unknown shell work as busy; block new shell creation before idle is accepted. Never rely on forced shutdown to terminate a shell. | +| Storage mutation slots | `src/storage/storage-mutation-coordinator.ts:35`, `:71`, `:91`. | Fence new mutation admission and require all relevant slots idle; account for other processes and unavailable ownership evidence. | +| Storage worker reservations | `src/storage/worker-lifecycle.ts:40`, `:92`, `:118`. | Fence worker starts and require no owned or uninspectable work; prove any process-tree exit before activation. | +| Tracked background work | `src/lib/background-work.ts:21` tracks already-started promises. | Fence creation before work starts and require all registered work settled; merely sampling the current list cannot prevent a later start. | +| Optional subsystems and plugins | `src/server/background-lifecycle.ts` starts periodic work; registered teardown hooks are separate from proof of idle. | Register quiescence owners through core-owned slots and defer when active or uninspectable; preserve the Lab import boundary. | + +These metrics do not prove that this is an exhaustive inventory. Trace all +background and optional owners reachable in the running configuration before +locking the plan; an unknown owner must keep automatic activation deferred. + +Proposed acquisition sequence for one attempt is the home-scoped sync/update +mutex, installation ownership lease, global turn fence, WebSocket admission +fence, background-shell fence, storage mutation/worker admission fence, then +registered background/optional-owner quiescence. Each fence closes admission +before its owner is observed. `tryAdmitTurn`, `tryReserveCodexWebSocket`, shell +spawn admission, `tryBeginStorageMutation`, `tryReserveStorageWorker` and +`withStorageWorkerSpawnGate` must consult their owner's reversible fence. A +missing participant, unconfirmed cleanup or uninspectable other process makes +the result unknown and releases this attempt's fences. The updater's own +status/journal path is excluded from the data-plane fence but still uses its +own serialized operation owner. Release acquired fences in reverse order on +precommit refusal. Do not hold client/configuration transactions across RPC or +installer waits; preserve `N → L → C` where those locks are needed. The exact +cross-process exclusion and exhaustive owner roster remain audit blockers. + +### Concrete participants and queued work + +The update admission owner maintains a core-owned registry of the active +participants for the actual runtime instance. Each registration supplies +`closeAdmission(operationId)`, `inspectClosed(operationId)` and +`releaseAdmission(operationId)`; registration, close and inspection identify the +same owner generation. Close happens synchronously before observing work; a +missing registration, changed generation, failed close or unknown inspection +defers. Composition registers enabled optional owners through a core slot; no +core request-path file imports an optional subsystem. A temporary close is not +the existing terminal shutdown and must be reversible without discarding work. + +| Participant | Concrete admission sites to change and test | Required zero/queue rule | +| --- | --- | --- | +| HTTP and streamed turns | `src/server/admitted-http-turn.ts:26`, `src/server/index/serve-options.ts:1756`, `src/server/responses/jev-model-invoke.ts:139`, and `src/server/claude-messages.ts:1043` call `tryAdmitTurn` | All admitted turn leases settle before commit. A racing request either acquires before closure and blocks the update, or receives the existing retryable admission refusal. | +| Codex WebSockets and WebSocket turns | `src/server/index/serve-options.ts:629`, `src/server/index/websocket-handler.ts:296`, `src/codex/websocket-registry.ts:28` | Close upgrade/turn admission; in v1 any live connection is busy, since connection-idle semantics are unproven. A close result must be observed, never forced. | +| Cursor background processes | `src/adapters/cursor/native-exec-shell.ts:421` gates before `:433` spawn | Close before acquiring a new shell lease; any live or unconfirmed child blocks. No forced kill is used to turn busy into idle. | +| Storage mutations | `src/storage/storage-mutation-coordinator.ts:83`, `src/storage/cleanup-job.ts:41`, `src/storage/restore-job.ts:292`, `src/storage/policy-job.ts:389`; Log Guard separately calls `noteStorageMutationCompleted` from `src/server/management/storage-log-guard-routes.ts:165` | Gate before all mutations, including the Log Guard path that does not currently acquire a slot. An already admitted slot or unknown other process is busy/unknown; an epoch update alone is not an admission fence. | +| Storage workers | `src/storage/worker-lifecycle.ts:91`, `:126`; worker creators in `src/storage/policy-job.ts:310` and `src/storage/restore-job.ts:164` | A queued reservation counts as work before a Worker exists. A reversible update fence must not use shutdown's destructive queue cancellation as its idle proof; queued work completes or the attempt defers. Require confirmed worker closure and OS join before zero. | +| Tracked background creation | `src/config/paths.ts:53`, `src/oauth/anthropic-session-affinity-store.ts:127`, `src/codex/auth-api/pool-mode-gate.ts:340`, `src/codex/auth-context.ts:1575`, `src/server/index.ts:818`, `src/server/management/codex-cli-update-routes.ts:46` | Introduce a thunk-based admission API before starting work; `trackBackgroundWork` alone receives an already-created promise (`src/lib/background-work.ts:24`). Migrate each creator and test a start racing the closed fence. Required writes are never dropped; if one is queued, defer rather than stop. | +| Process loops and activated optional owners | `src/server/background-lifecycle.ts:88`, `:196`; optional shutdown slots in `src/lib/optional-shutdown-hooks.ts:42`, `:87` | Each active timer or subsystem registers its own reversible admission and in-flight inspection. A periodic tick may be rescheduled only if its owner proves that losing the tick on process restart preserves semantics; otherwise it blocks. Shutdown hooks alone do not establish idle. | + +An update-owned journal/permit write uses its own serialized operation owner +and is exempt from its own data-plane fence; it cannot start unrelated work. +Acquire the outer update/ownership/link locks in the `060` order before the +runtime participant fences; release participant fences in reverse order before +outer locks on precommit refusal. No network or installer wait occurs under the +inner client/config/journal locks. Other processes that can mutate the same +installation or required state must participate in a shared identity-bound +exclusion mechanism or cause an unknown result; a process-local counter is not +cross-process evidence. Enumerate their actual owners and lease protocol before +this unit is locked. + +Add deterministic barrier cases to +`tests/server/update-activation-admission.test.ts`, +`tests/storage/storage-update-admission.test.ts`, and focused tests for each +named creator: pause immediately before admission, close the fence, release the +caller and assert no uncounted work starts; then release the fence and prove +the work resumes or receives its documented refusal. Exercise an already queued +worker, Log Guard, an optional owner absent from the registry and a second +process with unknown ownership. A source-oracle test that checks the enumerated +creator/registration list is an early warning for drift, not proof that all +possible work is registered; call-graph and platform review remain mandatory. + +### Existing cross-process locks and limits + +| Lock | Existing authority | Update requirement | +| --- | --- | --- | +| `U` sync/update mutex | `src/update/sync-update-mutex.mjs:46` takes a nonblocking lock under the canonical OpenCodex home; `src/update/orchestrated-session.mjs:192` holds it during an orchestrated mutation. Delegation is limited to a recorded live parent/child (`sync-update-mutex.mjs:74`). | Reacquire for activation and retain the existing marker and sync exclusion. Different homes have different `U` locks, so `U` alone does not establish exclusivity for a shared installation. | +| `O` service ownership lease | `src/service/ownership-mutation-lease.mjs:46` derives its authority from the final service-state path. `src/update/ownership-transaction.ts:30` spans stop/replacement/recovery and explicitly releases for a service-manager start whose child cannot join, then reacquires before direct mutation. | Preserve the release/reacquire and revalidation behavior. This lock protects its participating ownership mutations; it does not by itself count every data-plane or storage writer. | +| `A` link apply | `src/client/link-home.ts:149` uses an outer SQLite lifecycle lock keyed to the link-apply path before native/lifecycle/config operations. | Preserve its existing ordering and serialize binding changes relevant to a linked update; do not assume it protects standalone, other homes or worker processes. | +| `N → L → C` | `src/client/lifecycle-lock.ts:1` documents native-integration, effective-user lifecycle and configuration ordering; the lifecycle lease is a SQLite transaction (`:57`). | Never acquire `N` inside `L` or hold these inner locks while waiting for network, installer or target health. Recheck bound state after a lock is released. | + +The automatic unit must define an installation-scoped participant authority +whose key is the validated installation/owner identity, not only the invoking +home. Every process capable of mutating that installation or its relevant +runtime state must join or expose an authenticated participant before the +owner can establish zero activity. Map the existing launch and mutation +entrypoints and their failure behavior in the implementation diff; older, +foreign or uninspectable participants make the result unknown. Test two +isolated homes pointing at one fixture installation, an owner change during +the service-manager lease release window, and a process exiting while holding +its participant lease. Automatic activation remains disabled for an owner +until the actual cross-process mechanism and recovery are verified. + +Proposed concrete authority: `src/lib/installation-activity-registry.ts` owns +an effective-user runtime-root registry, keyed by a digest of the canonical +installation path and validated owner identity; each record also binds the +current filesystem identity so replacement or an alias cannot silently join a +different installation. Use a private, no-follow directory and required Windows +ACLs, matching the existing effective-user lifecycle storage approach +(`src/client/lifecycle-lock.ts:31`, `:57`). A short SQLite transaction serializes +participant registration, activity-count changes and update-fence generation; +it is never held across network or installer work. Each participant also holds +an OS-released exclusive SQLite lease in its own private lease file for its +process lifetime. Register only after that lease is held and withdraw before +releasing it. After a crash, a verifier may retire a record only after acquiring +that same lease and confirming the recorded process instance is no longer live; +an unreadable file, ambiguous process or unconfirmed lease is `unknown`. + +The shared storage/locking protocol is SQLite rollback-journal mode with +`busy_timeout=0`, a short registry transaction and one exclusive participant +lease database per process instance. Bun keeps each `Database` handle strongly +owned from acquisition through withdrawal; garbage collection must not release +a live lease. Native Desktop and the guardian use the same SQLite file format +and locking protocol through a directly pinned, bundled `rusqlite = 0.40.2` +adapter (`libsqlite3-sys = 0.38.2` in the resulting lockfile); the current +Desktop lock has neither dependency, so this is a new security-reviewed +dependency and must be locked, built and tested on all supported platforms. +Do not substitute the shell's unrelated `flock`/`LockFileEx` protocol. + +Node 18 cannot assume a native SQLite built-in. Its launcher starts a +publisher-verified, installation-bound bundled Bun broker with a private, +authenticated IPC channel; the broker owns the same SQLite protocol and keeps +the lease handle alive. Register only after the launcher verifies the broker's +process instance and ready receipt. A lost broker or unverified parent makes the +participant unknown and stops new work; a signed broker is obtained and +verified before first use, including bootstrap and rollback. The guardian's +native adapter and broker must observe each other's actual locks, not merely +agree on filenames. Test Bun, Node 18 and native Rust contention in separate +processes, garbage collection, process death and both lease directions on +macOS, Linux and Windows. The isolated macOS Bun/system-SQLite probe is +feasibility only; it does not prove this native adapter or platform matrix. + +All cooperating launch and mutation paths register before opening the selected +installation or starting associated work. Under the short registry transaction, +new work increments its participant count only when no update fence exists; a +fence closes admission before checking every registered count and participant +lease. Closing and inspecting are one generation-bound decision; committing the +existing runtime latch and durable update-stop intent transfers the fence to the +external installer owner. The owner keeps the installation fence through stop, +verified replacement and recovery; a newly started owner joins only through +the recorded operation handoff. Retire the fence only after owner/process +readback and journal reconciliation. Map the concrete CLI, Desktop, service, +linked worker and manager entry points in the implementation and prove each +joins before enabling its adapter. + +This cooperative registry does not restrict an arbitrary same-account process +that ignores it. Before automatic mutation, owner-specific checks must establish +that the selected manager and all known writers participate, and refuse an +unknown or unsupported configuration; the security review must assess the +remaining nonparticipating-writer boundary and any required OS enforcement. +Do not call a database row a system-wide lock. Add +`tests/service/installation-activity-registry.test.ts` with isolated homes and +real competing processes for registration/fence races, stale/dead leases, +replacement identity, two homes sharing one install, process death and +unreadable/foreign writer outcomes. The planned mechanism and every platform's +lease/ACL behavior remain unimplemented until those tests and independent +security review pass. + +## Candidate file changes + +| Operation | Path | Before → after | +| --- | --- | --- | +| NEW if needed | `src/server/update-admission.ts` | Update-specific reservation state and typed outcomes: reserve, inspect, commit, cancel/expire. Capability binds exact process/runtime and selected update operation. No dependency from core runtime into an optional subsystem. | +| MODIFY | `src/server/management/system-restart.ts` | Reuse or extract its existing automatic temporary-fence, veto and shutdown handoff (`:385`, `:439`) as a shared primitive; keep package-tree restart's existing respawn semantics distinct from update stop-to-installer. | +| MODIFY if needed | `src/server/lifecycle.ts` | Existing owner-scoped fence and shutdown latch (`:91`, `:122`) → expose only the minimal activity and atomic transfer seam actually needed; preserve normal shutdown and all existing lease semantics. File-size ratchet may require moving existing code byte-for-byte to an owned sibling. | +| MODIFY | `src/server/management-api.ts`, `src/lib/process-control.ts`, `src/cli/stop-restore.ts`, `desktop/src-tauri/src/runtime_stop.rs`, `desktop/src-tauri/src/exit.rs` | Design a separately authenticated update-stop disposition through the actual receipt-backed `ocx stop` path. The existing `/api/stop` executes teardown and shutdown (`management-api.ts:480`, `:522`), while Desktop calls `runtime_stop::run` (`exit.rs:614`). The automatic disposition must carry the exact reservation and consume it before manager stop/teardown; it must not route to `/api/system/restart`, whose handler supplies no automatic admission callbacks (`system-routes.ts:205`) and normally starts a replacement. Unproven manager ownership or a stop path that cannot preserve the reservation refuses before disruption. The exact authenticated wire format and service-manager ordering remain audit blockers. | +| MODIFY | Focused `tests/service/shutdown-drain.test.ts`, relevant management/update admission and ownership tests | Failing-first race cases using fake clocks, controlled in-flight streams, and isolated runtime identities. New files must be added to test-layout maps and expected shards. | +| MODIFY | `structure/runtime.md`, `structure/ops/service-and-sidecars.md`, `structure/ops/desktop-supervision.md` and any additional mapped owners | Document the shipped seam and bind invariants to real tests; run the ownership gate. | + +The desired disposition is **stop for a verified installer**, not restart the +old package: after reservation and policy revalidation, the existing external +stop owner claims its teardown receipt, transfers the fence into terminal stop, +observes the owned process exit and returns the receipt-bound outcome to the +installer. Only then may the installer activate the already verified stage and +the existing owner start the replacement. A supervisor must not respawn the old +tree between stop and activation; where the current manager cannot guarantee +that, automatic activation remains refused. Failure before irreversible stop +releases the fence and keeps serving; after stop, recovery follows existing +owner-specific rules and never reports health without observing the target. + +For a service, commit durably records `await-external-owner-stop`, fences new +work and returns acceptance without asking the supervisor to restart the old +tree. Only after the external CLI receives or reconciles that acceptance may it +stop the revalidated bound manager and observe inactivity. If the runtime dies +or the reply is lost before the manager action, reconcile the same operation +and recorded runtime/manager state; never substitute a force-stop or a second +operation. Unmanaged and Desktop owners similarly bind the receipt and process +exit before installation. Startup inhibition is a private durable operation +record outside the replaced tree, checked by CLI startup, native supervision, +service startup and recovery before any old-tree launch. Each unsupported +owner stays deferred until its check and recovery path are demonstrated. + +Proposed update-specific descriptor `ocx.update.activation/1` binds an operation +ID and attempt generation, process instance and endpoint, selected installation +and owner, exact verified candidate/stage digest, policy revision, stop owner and +reservation deadline. A dedicated authenticated runtime admission surface offers +`reserve`, `inspect`, `commit` and `cancel`: reserve acquires the required +fences and returns an opaque short-lived permit or a bounded deferral reason; +inspect reports the same attempt; commit rechecks all bindings and makes the +permanent transfer once; cancel releases only the uncommitted attempt. A lost +commit response remains uncertain until observed. Existing restart capabilities, +plan hashes and teardown receipts are not interchangeable with this operation. + +Proposed transport is a dedicated local management endpoint +`/api/update/activation` with `reserve`, `inspect`, `commit` and `cancel` +actions, bounded JSON and a body-bound, operation-scoped local capability +derived from the owning runtime's private process secret. `src/lib/local-management-capability.ts` owns the +existing local capability machinery and is the extension point; the ordinary +restart capability remains unchanged. The permit is an opaque runtime-issued +value with a five-second monotonic lifetime, scoped to the descriptor and +single use. A private operation file carries the update-stop invocation's +descriptor to the bundled CLI without command-line secrets. Neither a public +status response nor the dashboard snapshot contains the permit. This is a +proposed protocol, not evidence of a deployed security boundary. + +The local caller first reads the selected process's private runtime record and +verifies its loopback challenge exactly as the existing bound restart client +does (`src/cli/system-restart-client.ts:93`, `:111`, `:125`). The proposed +mutation capability is a **new** domain-separated HMAC-SHA-256 operation, not +the existing GET-only capability (`src/lib/local-management-capability.ts:60`). +Its input is the exact bounded UTF-8 request body digest, method, fixed path, +runtime PID and port, challenge nonce, action, operation ID, generation and +expiry; use unambiguous length-prefixed fields and compare MACs in constant +time. The owning caller derives it from that runtime record's process secret; +the secret and permit never enter logs, arguments or dashboard state. A +replacement PID, changed record, duplicate JSON key, wrong body, expired nonce +or unsupported capability refuses. Runtime-record access and an attested +connection are local ownership prerequisites, not person-consent or a guarantee +against another process running as the same account. Add a dedicated +`src/lib/local-update-admission-capability.ts`, server verifier and caller +sibling; do not widen the existing local GET allowlist. + +The request is a strict `ocx.update.activation/1` object with `action`, +`operationId`, positive `generation`, `runtimeInstance`, `pid`, `port`, +`installationId`, `ownerKind`, `candidateDigest`, `stageDigest`, +`policyRevision` and `deadlineMs`; `commit` and `cancel` also carry the opaque +permit returned by `reserve`. `inspect` instead uses a fresh process-bound, +body-authenticated request for the operation and generation, without consuming +or requiring a previously consumed permit. A response is the strict +`ocx.update.activation-result/1` with the same operation and generation, +`state` (`reserved`, `accepted`, `deferred`, `refused`, `cancelled`, +`expired` or `uncertain`), bounded `reason`, and permit only on `reserved`. +Runtime admission uses a monotonic five-second deadline for a reservation; +wall-clock request expiry only bounds transport replay. The secret-derived +MAC authenticates each action and body; it is distinct from the one-use permit. +Final encoding vectors and the response readback/authentication chain require +independent security review before implementation. + +The external owner writes a private durable inhibition record outside the +replaceable installation before `commit`, binding operation/generation, +selected owner and runtime instance, prior running intent and stage digest. +Only the owner holding the installation lease can create, advance or clear it; +updates are atomic and durable. Before acceptance, expiry or owner loss releases +the reversible fence and the owner clears the matching intent after confirming +no commit. At acceptance, admission transfers into the existing shutdown latch +and records the matching accepted generation; it cannot expire back to serving. +For service ownership the runtime returns acceptance before the external owner +stops the revalidated manager; for Desktop or unmanaged ownership it enters the +receipt-backed stop path. If the response is lost, the owner reconciles the +same runtime, record and manager/process state; it never invents a second +operation or treats a missing reply as an accepted stop. Readback after runtime +exit/replacement uses the private durable operation journal through an +authenticated local owner, not the dead runtime's process secret; a missing or +contradictory record is `uncertain`. If the owner dies after acceptance and no +mutation started, a successor must reconcile the exact runtime and manager: +an alive runtime with the permanent latch still closed is stopped through the +accepted receipt and observed exited before the same owner's prior running +intent is restored. It must not clear inhibition and call that fenced process +healthy. If state or exit is unknown, retain inhibition and report `uncertain`. +A later explicit Stop/Quit intent takes precedence over restart. Test the lost +reply before and after permit consumption, expired permit, process replacement +and owner death while the old runtime remains alive but permanently fenced. + +Startup readers must include the start path in `src/cli/index.ts:515`, the +service manager's launch entry, Desktop supervision +in `desktop/src-tauri/src/` and the recovery worker. They check the same bound +record before launching an old installation; an unreadable or foreign record +does not grant permission to proceed. The implementation unit must trace the +actual entry paths on each platform and prove no owner bypasses this check; +until then that owner is ineligible for automatic installation. These are +proposed state transitions and ownership requirements, not existing behavior. + +The proposed external entry is `ocx stop --for-update --operation-file +--json`, returning a separately versioned `ocx.update.stop/1` result with +operation identity, stop/manager observation and teardown disposition. The +ordinary stop and existing `ocx-stop/1` stay unchanged. Automatic update-stop +must not take the ordinary forced-stop fallback, and no installer starts on an +unconfirmed exit or ambiguous manager result. These wire shapes and authority +checks still need exact definitions and independent review. + +For Desktop, the native exit coordinator claims the stop and preserves newer +Stop/Quit intent before calling the new stop disposition. For a service, the +external owner reserves idle **before** stopping the bound manager and proves +manager inactivity before activation. For an unmanaged runtime, the external +owner observes process exit before activation. A durable inhibition record +outside the replaceable tree prevents eligible startup owners from restarting +the old tree during activation; owners that do not honor it are not eligible +for unattended installation. Connected-client and guest Desktop paths require +their own equivalent proof and remain open scope until it exists. The complete +cross-process activity roster, startup-owner integration and lock ordering are +still blockers, not assumed capabilities. + +## Required failing-first scenarios + +- A long-lived admitted stream makes reserve or commit defer; it receives no + abort and the runtime remains healthy. Unknown activity is also deferred. +- A turn racing reservation is either admitted before the fence and blocks the + update, or refused after it; it never starts after the idle verdict and before + shutdown. Policy, process identity, selected installation and target are + revalidated under the reservation immediately before commit. +- Cancellation, expiry, owner death, failed verification and a mismatched or + replayed capability release only their own fence. A concurrent unrelated + temporary drain is not released or converted by this operation. +- Successful commit makes shutdown admission permanent atomically, releases the + update reservation, and reaches the existing stop/drain without waiting on + itself. An abort or lost response is classified as uncertain until the owner + is observed; no second installer starts on an unknown outcome. +- Desktop-supervised, service-owned and unsupervised runtimes preserve their + existing ownership and Stop/Resume rules; explicit manual shutdown behavior + and Lab core-path boundary remain unchanged. + +## Candidate verification + +Run the exact focused lifecycle, update admission, desktop ownership, service +and concurrency suites with isolated homes and deterministic barriers; first +demonstrate the regression tests fail on the unfixed behavior. Run +`bun run typecheck`, `bun run privacy:scan`, `bun run structure:check`, the +Lab core-boundary test, and exact-head PR CI. A separate independent security +review PASS is required. Before roadmap lock, resolve the command paths and +prove each observes the changed code; no full root suite. + +Baseline on 2026-11-07: `bun test tests/service/shutdown-drain.test.ts` +passed 22 tests and `bun test tests/server/system-restart-admission.test.ts` +passed 34 tests (both exit 0). The former imports lifecycle and uses isolated +loopback listeners; the latter exercises the restart admission with fake +dependencies. The existing automatic-restart test explicitly verifies that a +turn can be cut at grace expiry, so a separate failing-first automatic-update +case is necessary. These baseline results do not prove the proposed update +admission behavior. + +Proposed new regression files: `tests/server/update-activation-admission.test.ts`, +`tests/cli/cli-update-stop-admission.test.ts`, +`tests/service/update-stop-manager-contract.test.ts`, +`tests/storage/storage-update-admission.test.ts`, +`tests/clients/desktop-auto-update-stop-contract.test.ts`, and +`tests/update/update-activation-handoff.test.ts`. Place each in its listed +domain and register it in both layout and expected-fixture maps. These do not +exist yet and are not claimed as executed verifiers. diff --git a/devlog/_plan/261107_auto_update_parity/030_desktop_engine.md b/devlog/_plan/261107_auto_update_parity/030_desktop_engine.md new file mode 100644 index 00000000000..8427acc4408 --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/030_desktop_engine.md @@ -0,0 +1,335 @@ +# Staged desktop update engine — draft unit + +**Status:** pending the signed-supply and activation-admission units, architect +reflection and roadmap audit. This is a design draft, not an implementation +authorization. + +## Objective and policy proposal + +The desktop app checks its selected published channel, can download a signed +update in the background, exposes progress, and retains a verified stage until +the person chooses to restart or the selected automatic-install policy permits +it. Existing download verification and the ownership-aware drain remain the +only path to installation (`desktop/src-tauri/src/updater.rs:388`, +`desktop/src-tauri/src/exit.rs:546`). + +Proposed defaults: background checks and signed auto-download on; automatic +restart/install off until the user enables it. GOAT defaults to restart when +idle (`docs/user/updating.md:128` at the reference revision), but OpenCodex's +existing drain must not be assumed to prove no request is in flight. This +conservative default avoids a surprise restart while still staging updates; +explicit opt-in may activate only after a tested idle/admission signal and a +fresh guarded drain. If a reliable idle signal does not exist, the enabled +policy must defer with an explanatory state, never silently approximate idle. +The user can turn off automatic download, turn off automatic installation, and +choose Later; manual actions remain possible. Finalize defaults and interaction +with quit after architect reflection and audit. + +The pinned Tauri updater exposes `Updater::restore_update` for cached metadata; +it requires signed-version binding for restored metadata, and `Update::verify` +and `Update::install` verify cached bytes again. This was inspected in the +locally installed `tauri-plugin-updater` 2.14.1 crate (`src/updater.rs:666`, +`:896`, `:911`); the repository pins it at +`desktop/src-tauri/Cargo.toml:32` and locks the registry checksum at +`desktop/src-tauri/Cargo.lock:4285`. Therefore durable staging is a concrete +candidate: persist bounded raw metadata plus private staged bytes, restore with +the current configured updater, verify before showing ready, and verify again +at install. Reject signatures lacking the signed version on restoration; do not +serialize a caller-supplied `Update` or trust a saved ready flag. Cross-platform +filesystem ownership, bounded sizes, atomic publication and cache recovery +still need an exact design and negative tests. +Before relying on restoration, verify in release fixtures that the actual +signing tool emits the signed version required by `restore_update`, including +Windows re-signing; otherwise keep the update available for a fresh check +instead of representing the cached stage as ready. + +The native staged engine owns acquisition in a new +`desktop/src-tauri/src/update_download.rs`. It creates the plugin `Update` +only from the verified release record's exact version, channel, target, +artifact digest/size, signature, approved source and delegated key. Reconstruct +and compare these bindings before each download, restoration and installation; +never accept caller-supplied `Update` fields as authority. Use the existing +pinned `reqwest` and `sha2` dependencies (`desktop/src-tauri/Cargo.toml:20`, +`:23`): read response chunks, count before extending a bounded buffer, hash as +they arrive and abort immediately if the signed size or an implementation +maximum is exceeded. Require exact final size and digest, then call the pinned +plugin's `Update::verify` on those same bytes before publishing ready. On +macOS/Linux, `Update::install` verifies them again at installation; on Windows +the verified guardian backend below performs the mandatory final verification +before its observed installer handoff. Reject +partial or oversized responses and remove only this operation's private +temporary file on cancellation/failure. A Content-Length header is advisory, +never the bound. + +Production acquisition requires HTTPS and a source derived from the verified +release record's approved source/asset identity. Initially allow only the exact +`github.com/lidge-jun/opencodex/releases/download//` source; permit +at most three HTTPS redirects to exact hosts `github.com`, +`release-assets.githubusercontent.com` or `objects.githubusercontent.com`, +without userinfo or non-default ports. Refuse an unlisted host rather than +silently widening this set. Send no management, link or user credentials to the +artifact service or redirect target. A loopback HTTP mock is accepted only by +injected test transport, never a production setting. Cap signed size at 1 GiB; +use a 10-second connect deadline, 30-second idle-read deadline and 20-minute +total deadline, with retryable bounded error codes. Test each hop and timeout, +missing/misleading lengths, exact-size boundary, abort cleanup and wrong target, +digest, signature or version. This is a proposed owner and acceptance contract; +the release-asset host set and platform implementation require audit. + +Proposed persisted desktop policy v1, stored by the native owner under its +app-config directory as `update-policy-v1.json`, is a closed object with +`schema: 1`, monotonically increasing `revision`, `channel` (`latest`, `preview` +or `nightly`), `check` and +`download` (`automatic` or `manual`), and `install` (`manual`, `on-quit` or +`when-idle`). +Defaults are automatic checks and downloads, manual install. A missing record +uses these preferences only when the installed channel is established by the +verified provenance in `010`; ambiguous or missing channel provenance remains +unknown and disables automatic effects. Malformed or unreadable existing records +also disable automatic effects and report an error. Writes are serialized and +atomic; an unsuccessful write never updates effective policy. Every action +captures the revision and rechecks it before download and activation. + +Later records the exact staged candidate as deferred until the person explicitly +installs it or selects a newer candidate; it survives app restart and ordinary +quit. Ordinary quit must not silently install a deferred or manual candidate. +Enabling `when-idle` permits a non-deferred stage only after the admission unit +proves idle and performs the guarded handoff, including an eligible quit. +`on-quit` attempts installation only on an explicit quit. For either policy, +busy or unknown activity defers the update instead of forcing installation; +the ordinary requested quit follows its existing separate semantics. Later +prevents the candidate's automatic installation on quit as well as while idle. +A successful explicit install or a newer candidate clears the previous +deferral; failed targets remain suppressed for automatic retries until a +different candidate or explicit retry. These are proposed contracts for +review, not evidence of implementation. + +Discovery and staging are separate state owners. If a later check fails, +returns no update, or returns the same candidate with no notes, retain a still +verified staged candidate, its ready/install action, Later decision and notes; +surface the check error separately and allow retry. Invalidate the stage when +channel or owner changes, a newly selected candidate, expired or failed +trust/identity verification, or an explicit discard requires it. A policy +revision change invalidates prior activation authority and requires revalidation; +it does not by itself erase a still-valid stage or Later. An invalid stage never +remains installable. Throttle native progress projection +to changed integer percentages or a one-second heartbeat; sidebar polling is a +separate display concern (`050`). Test the check-versus-ready races, stale +completion, deferred stage and retained notes. + +## Proposed durable recovery contract + +Before the first irreversible stop, atomically journal the candidate, prior +version, install owner, policy revision, operation ID and the pre-stop +Stop/Resume intent. States are `prepared`, `activating`, `observing`, +`installed-stopped`, `healthy`, `failed` and `uncertain`; a process restart never turns an +`activating` record into success without target-version and runtime-owner +readback. A failed target is suppressed until an explicit retry or a distinct +candidate. Record only bounded reason codes, no request data or credentials. + +The candidate activation unit must establish a verified recovery path before +enabling unattended installation: retain a separately verified, signed prior +release artifact and the state needed to restore it, or refuse automatic +activation with a visible manual recovery action. If the recorded effective +intent requires a running runtime, a successful installer exit starts +observation; the exact target and owned runtime must answer health within a +bounded 30-second initial window, followed by a ten-minute probation for +runtime failure. If the person explicitly quit or the runtime was intentionally +stopped, verify the installed artifact and record `installed-stopped`; do not +start a runtime just to satisfy health. On the person's next deliberate start, +observe the exact target and start the health/probation window; retain signed +recovery material until it completes. `installed-stopped` is not `healthy`. +A failed trial/probation triggers the verified owner-led +recovery path; it cannot discard state written by another owner. If safe data +restoration cannot be proven, leave the outcome uncertain and require explicit +recovery rather than presenting a rollback as successful. Desktop platform +installer constraints, the actual persistent journal location and state +ownership need platform-specific design and test evidence before plan lock. + +Proposed recovery actor: a verified, destination-owned guardian is started from +an isolated signed recovery payload **before** the native installer handoff. +The guardian and its journal live outside the replaceable app bundle and hold an +operation-specific lease. It observes installer termination and the exact +replacement's startup/health even if the old app exits. If initial health or +probation fails, it invokes only the verified retained recovery artifact through +the appropriate platform owner; it records `uncertain` when termination, owner +intent or state-write ownership cannot be established. A missing authenticated +previous artifact prevents unattended activation; an explicit manual path +shows the owner action rather than claiming automatic rollback. + +On Windows, the guardian must survive the MSI handoff that ends the old app +(`desktop/src-tauri/src/updater.rs:397`), and wait for the installer process +and owned replacement. On macOS and Linux it survives the app relaunch and +observes the same journal. Rollback may select only the exact retained prior +signed artifact named by the operation record; normal channel sequence and +downgrade restrictions remain in force for ordinary selection. Guarded recovery +is a separate bounded exception, not permission to install an arbitrary older +version. The proposed owners are a new +`desktop/src-tauri/src/update_recovery.rs` coordinator and the separately signed +`desktop/update-guardian/` helper described below; packaging and platform +supervision still require proof before automatic activation. + +The pinned updater's Windows handoff is a specific design constraint: in the +locally installed `tauri-plugin-updater` 2.14.1 source, +`src/updater.rs:1013–1050`, it calls `ShellExecuteW` and exits the app without +returning an installer process handle. Merely watching the old app exit cannot +prove that MSI/NSIS finished or that it is safe to start rollback. The +guardian must obtain a trustworthy installer completion observation through a +platform-specific, independently reviewed handoff; if that cannot be proved, +it records `uncertain` and never launches a competing installer. The unit must +choose and test the actual mechanism, including elevation cancellation and a +live installer after guardian death. Do not claim the current plugin exposes a +handle that it does not expose. + +Build the guardian as a separately signed platform artifact and bind its exact +digest in the release record from `010`, rather than assuming a helper inside +the app bundle will survive replacement. The native owner verifies it before +copying it into an account-private update-operation directory outside the +bundle, verifies the copied bytes again, and launches it with a bounded +operation descriptor and no secret command-line arguments. The guardian owns a +durable journal and exclusive operation lease; the replacement app's startup +and any later owner retry reconcile that journal before starting another +installer. A process surviving application exit is not proof of survival +across logout or reboot: define a startup reconciliation path and leave an +interrupted operation `uncertain` until it observes the prior worker/installer +and owner state. No persistent service registration is implied by this plan. + +| Platform/owner | Proposed recovery boundary | Evidence required before enabling | +| --- | --- | --- | +| macOS bundle | A verified guardian outside the `.app` observes the owned bundle replacement and version-bound startup, then applies only the retained verified prior artifact through the approved platform owner. | Signed/notarized helper execution from private storage, app replacement and restoration on the same and different volumes, permission/elevation refusal, guardian loss, Stop/Quit intent and data ownership. | +| Windows MSI/NSIS | A verified guardian outside the installed tree observes a bound installer operation and replacement process; rollback waits for confirmed installer termination. | Installer process/operation identification across elevation and app exit, job/session survival, cancellation, reboots, concurrent installer exclusion and exact-version readback. `ShellExecuteW` success alone is insufficient. | +| Linux AppImage | A verified guardian outside the image observes the owner-bound replacement and can restore the signed prior image. | Same-filesystem replacement/restore, permissions, interrupted write/rename and exact image verification; the pinned updater's internal temporary backup is not a durable probation guarantee. | +| Linux deb | The guardian uses the selected package owner and waits for verified package-manager completion; it never rewrites a system-owned tree directly. | Ownership and privilege checks, cancellation, manager-lock handling, signed previous package restoration and post-install health. If unavailable, report owner action and keep this parity item open. | + +The exit coordinator adds a distinct `quit-for-update` transition before a +normal UserQuit claims the drain. An eligible explicit Quit atomically records +the user's quit intent and claims this transition; an already claimed UserQuit, +newer Stop/Quit, stale stage or busy/unknown activity follows ordinary quit and +skips update activation. A runtime that was already stopped uses a separate +owner-bound absence proof and installation-wide participant fence; it does not +call the live `/api/update/activation` endpoint. An unknown or foreign runtime +still refuses. Tests cover already stopped, absent, running, busy, concurrent +Quit/Stop and quit ownership claimed before update admission. + +Selected implementation direction: add a small independently signed Rust +guardian artifact per supported target under a new `desktop/update-guardian/` +crate, built and verified in the existing release workflow without adding a +trigger or permission. It reads a private versioned operation journal, acquires +the installation-scoped owner lease from `020`, verifies its own approved +operation identity and both signed target/recovery payloads, then records every +handoff transition before performing it. Its stable private operation directory +is under the Desktop owner's app-config directory, outside the replaceable +bundle. Startup reconciliation launches only the recorded verified guardian; +it never starts a second guardian while the original lease or installer status +is live or unknown. No automatic installation is enabled until packaged tests +show this helper survives the relevant application exit and preserves owner +intent on that platform. + +For Windows, the selected direction is a guardian-owned MSI/NSIS launcher using +`ShellExecuteExW` with a requested process handle, after the native plugin's +`Update::verify` and a second guardian-side verification of the exact staged +installer bytes. The helper accepts only the signed target's approved installer +kind and fixed arguments; it must not accept a caller-supplied command. Observe +the returned handle, installer exit and platform installation state before any +health check or rollback. If elevation is cancelled before launch, restore the +prior intent; if launch succeeds but no trustworthy handle or completion state +can be established, retain the operation fence as `uncertain` and never start +another installer. Test elevated/unelevated execution and Windows Installer's +actual completion semantics. Because the current plugin's `Update::install` +does not return the Windows installer handle, this backend replaces that launch +only after preserving its mandatory exact-byte signature/version verification; +it does not disable or weaken verification. Any direct OS binding is pinned, +reviewed and covered by native CI. + +The durable Windows milestones are `guardian-ready`, `app-exit-requested`, +`app-exited`, `installer-started`, `installer-exited`, `installed`, and either +`observing` or `installed-stopped`. The guardian proves its own readiness and +ownership before the app requests a coordinated exit; it waits for the exact +old app process to exit before launching the installer. It records and observes +the installer handle and completion before starting a replacement app, and +never calls the old immediate `complete_restart` while an installer is live. +If old-app exit fails, no installer starts; if UAC is cancelled before launch, +restore the prior intent. Lost replies, guardian death, handle absence or an +unconfirmed installer retain `uncertain` and prevent another installer. A +replacement starts only when the latest recorded intent requests it; a user +quit remains quit. Exercise every milestone with isolated process/installer +fixtures and packaged Windows proof before enabling the capability. + +On macOS and Linux AppImage, retain the pinned plugin's verified `install` path +and have the independently running guardian observe its bound completion, +exact bundle/image identity and health; the guardian restores only the signed +previous artifact when ownership and data-write checks permit it. For Linux +deb, use a separately supervised approved package-manager operation with an +observable process and package-owner readback; a denied privilege prompt or +unknown process outcome remains explicit. Standalone `070` uses the same +signed guardian protocol for its executable owner, with per-platform replace +and restore adapters; it does not infer ownership from a path alone. Each +platform needs failing-first process-loss, reboot/reconciliation, UAC/privilege +and no-concurrent-installer tests before its automatic capability is enabled. + +Bootstrap for an older installation requires a publisher-signed previous +artifact and authenticated metadata that bind the installed owner and exact +version to the retained recovery material. A version string alone is not +proof of installed bytes. If the old release has no verifiable recovery +material, automatic activation stays disabled until an explicit owner-guided +bootstrap establishes it; the signed-supply and release units must create this +path rather than silently treating unsigned historical bytes as rollback proof. +Tests inject failures before and after guardian launch, stop, installer handoff, +replacement startup and probation; they assert the number of concurrent +installers, the selected owner, and the observed signed recovery outcome. + +## Proposed file map + +| Operation | Path | Before → after | +| --- | --- | --- | +| MODIFY | `desktop/src-tauri/src/updater.rs` | Six-hour check and one combined download/install (`:388`, `:448`) → a single owner for check, signed download with progress, staged readiness and guarded install. Preserve generation, claim and tray races (`:28`, `:291`); do not create a parallel installer or introduce a second scheduler. Extract siblings if size or ownership calls for it. | +| NEW | `desktop/src-tauri/src/update_policy.rs` | Typed, validated channel and download/install preferences; define explicit defaults, durable atomic persistence under the desktop app's own config directory, failure behavior and migration from no record. Resolve exact existing persistence convention before finalizing this path. | +| NEW | `desktop/src-tauri/src/update_stage.rs` | Own a staged exact version and the verified package bytes/metadata returned by the pinned updater; retain verification provenance and invalidate on channel or version change. Persist only if the plugin supports safe re-verification across restart; otherwise recover by rechecking and re-downloading rather than asserting an old stage remains verified. | +| MODIFY | `desktop/src-tauri/src/lib.rs`, `desktop/src-tauri/src/tray.rs` | Route UI/tray operations through the same engine and installation claim. New privileged commands remain guarded by the bundled update page; no new capability is granted to the dashboard origin. | +| MODIFY | `desktop/src-tauri/src/exit.rs` only if necessary | Preserve `prepare_restart` ownership, drain and stop confirmation; any idle evidence must be tested and checked again at admission, not inferred from a timer. | +| MODIFY | Desktop Rust tests and `tests/clients/desktop-update-surface.test.ts` | Add tests for state transitions, concurrent check/download/install, failures, settings and restart admission; use injected clock, updater and temporary app homes. Existing test/source registration rules apply to new domain tests. | +| MODIFY | `structure/desktop-shell.md`, `structure/companion.md`, `structure/ops/desktop-supervision.md`, `structure/runtime.md`, `structure/ops/service-and-sidecars.md` and any other affected owner identified in `structure/INDEX.md`; user docs | Review all mapped owners (`structure/INDEX.md:182`); update each whose documented contract changes. Sync relevant translations. | + +## Required scenarios + +1. Startup and subsequent checks use one bounded scheduler. Offline, timeout, + stale or malformed feed shows a retryable failure or unknown, not current; + a delayed older check cannot overwrite a newer result or active install. +2. A trusted test feed returns an exact signed update; progress becomes visible + and readiness is emitted only after the pinned plugin verifies the bytes. + Missing, corrupt, wrong-key, wrong-channel or superseded artifacts never + become installable. Test signing uses a dedicated fixture key and isolated + storage; never use production credentials or a real installation. +3. Auto-download disabled, auto-install disabled and Later each prevent the + corresponding automatic effect. Changing a preference during a pending + action is rechecked at its mutation boundary. Unknown or malformed settings + fail safely and remain visible as an error. +4. Automatic install requires enabled policy, current verified exact stage, + proven idle, the reservation handoff in `020_activation_admission.md`, a + fresh admission recheck and `prepare_restart` success. An + active request, foreign/unknown owner, failed drain, quit race or changed + stage defers/refuses without replacing the package. Manual install still uses + the same guarded drain. +5. A failed installation invokes the existing recovery owner and reports the + failure; a restart returning on the old version is not called success. A + failed target must not enter a tight automatic retry loop. Explicit retry + is possible. Windows handoff and Linux package type stay covered. +6. With `on-quit`, an idle, non-deferred verified stage is offered to the + guarded installer only at explicit quit. Busy or unknown activity skips the + update; Later, manual mode and failed-target suppression prevent it. With + `when-idle`, the same eligible quit path is available. Test quit races and + verify no in-flight request is interrupted by update activation. + +## Candidate verification + +Run failing-first focused Rust tests and the desktop update-page tests against +isolated homes and a local mock update server; verify the real pinned plugin's +signature rejection as well as injected state-machine failures. Run root +`bun run typecheck`, `bun run privacy:scan` and `bun run structure:check`; +collect exact-head PR checks and an independent security review PASS. The +candidate `cargo test --locked --manifest-path desktop/src-tauri/Cargo.toml` +and platform-specific test commands must be grounded and cost-checked before +roadmap lock. No full root suite. A PR-branch `lane=all` requires an explicit +maintainer request on that PR; run it once on the exact intended head, never +redispatch after a head moves or rerun to green, and cancel owned superseded +runs. Ordinary full dispatches remain batch checks on `dev` under `AGENTS.md`. diff --git a/devlog/_plan/261107_auto_update_parity/040_package_preparation.md b/devlog/_plan/261107_auto_update_parity/040_package_preparation.md new file mode 100644 index 00000000000..20242201b40 --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/040_package_preparation.md @@ -0,0 +1,171 @@ +# npm package preparation and activation — draft unit + +**Status:** depends on signed supply and automatic admission; independent +architect reflection and roadmap audit are pending. Do not implement yet. + +## Goal and current behavior + +Support user-controlled staged automatic updates for eligible package-owned +installations while preserving each package manager's ownership, the +sync/update mutex, guarded runtime stop and recovery. npm already stages beside +the live tree and then swaps with backup and rollback, but preparation and +activation are currently one transaction +(`src/update/transactional-install.mjs:388`, `:410`, `:475`). pnpm operates on +its selected global owner (`src/update/pnpm-global-install.mjs:472`); safe +independent staging for pnpm and Bun remains to be demonstrated. Existing +`ocx.update.plan/1` and `ocx.update.result/1` consumers retain their contracts. + +An automatic path must verify the signed exact bytes before installation and +before executing anything acquired as part of the update. npm staging currently +permits Bun's install script (`src/update/transactional-install.mjs:433`), so +the plan must account for transitive executable artifacts and lifecycle scripts, +not only the top-level tarball. If this cannot be proven for a manager, that +manager reports unsupported and performs no automatic mutation until a later +in-scope unit supplies the missing guarantee; this is not goal completion. + +The signed-supply research recommends extracting a signed, self-contained +npm-shaped tree as data, without lifecycle scripts, then reusing the existing +owned sibling swap after verifying the complete signed inventory. Preserve npm +prefix and bin links and refuse incompatible bin mappings. An initial automatic +update also needs an authenticated matching previous tree for recovery; a hash +of a previously unsigned installation is not publisher authentication. + +pnpm's global virtual store and Bun's global metadata/shims need distinct +adapters and isolated proof that the exact signed local bundle can be installed +without fetching or executing unsigned dependencies, and that signed previous +bytes and the manager's links can be restored. Do not rename pnpm store entries +or treat `bun add -g` as preparation. They are separate in-scope units `090` +and `100`; this npm unit cannot close them. + +Preparation holds only its own stage lease; it does not hold the sync/update +mutex while waiting for a person or idle. Activation reacquires the existing +home-scoped sync/update mutex, installation ownership lease and the runtime +reservation in the order established by the existing owner, revalidates the +stage and policy, then performs the receipt-backed stop and atomic swap. The +complete lock order and process-exit fencing must be proven against the +selected manager and platform before the unit is audited. + +The existing `OCX_DISABLE_UPDATE_CHECK=1` environment opt-out +(`src/update/refresh-scheduler.ts:35`) overrides automatic package checks and +downloads even if the stored policy requests them. An explicit manual check +remains available; any new update flow, including a manual install from its +panel, requires the signed-supply verification. Existing explicit CLI behavior +is inventoried separately and is not silently reused as an unsigned fallback. Turning the +environment opt-out off does not clear the user's persisted policy or a +candidate deferral; the UI explains the effective state. + +Persist an operation journal with exact candidate, previous version, owner, +stage identity and `prepared` / `activating` / `observing` / `healthy` / +`failed` / `uncertain` state. Require signed, verified recovery material before +unattended activation. Observe the owned target's version and health within a +30-second initial window and retain rollback material for a ten-minute +probation; do not restore stale data over a newer owner's writes. A failed target +is not retried automatically. A manager unable to guarantee these conditions is +explicitly unsupported until its own implementation unit proves them. + +## Candidate change map + +| Operation | Path | Before → proposed after | +| --- | --- | --- | +| MODIFY | `src/update/transactional-install.mjs` and sibling modules | Extract owner-held `prepare` and `commit` around current isolated staging, tree verification, authorization, swap and rollback. A prepared handle binds verified candidate, exact installation, policy revision and stage identity. Preserve legacy command interfaces and process-tree exit fences while requiring verified supply for installation. | +| MODIFY | `src/update/orchestrated-plan.ts`, `src/update/orchestrated-entry.ts`, `src/update/orchestrated-node-driver.mjs`, `src/update/orchestrated-session.mjs` | Add a separately versioned automatic preparation/activation contract around the existing identity-bound plan and mutation lease. Enumerate construction, transport, decoding, admission and every consumer before locking design; reject stale policy/owner/candidate. Do not change exact-key existing JSON silently. | +| REVALIDATE | `src/update/pnpm-global-install.mjs`, Bun-owned update paths | Preserve their command interfaces and ownership refusals while applying the required signed-supply contract. Manager-specific signed automatic implementations belong to `090` and `100`. | +| MODIFY | `src/update/refresh-scheduler.ts`, package update coordinator sibling | Discovery remains read-only with existing opt-out, cache and backoff; the separately persisted policy owns whether an exact signed target may be downloaded or activated. Integrate admission unit `020`, failed-target suppression and serving-target health readback. | +| NEW | `src/update/automatic-policy.ts`, `src/server/management/update-policy-routes.ts` | The package owner stores a strict `ocx.update.policy/1` record under its effective OpenCodex configuration directory, atomically updates it with a revision check, and exposes authenticated policy reads/changes through the management owner. Missing uses documented defaults; corrupt/unreadable disables automatic effects and reports an error. Never use a dashboard snapshot as authorization. Wire the route through the existing registry with focused authorization tests. | +| MODIFY | `tests/update/update-transactional.test.ts`, `tests/update/update-orchestrated-*.test.ts`, `tests/update/update-pnpm.test.ts`, `tests/update/update-sync-mutex.test.ts`, relevant CLI/GUI tests | Add red-to-green signature, stage integrity, owner, lease, process-exit, retry, policy and race cases using isolated homes and local fake installers. Register new domain test files in both test-layout maps. | +| MODIFY | `structure/ops/service-and-sidecars.md`, `structure/ops/update-supervised-recovery.md`, `structure/ops/desktop-supervision.md`, any other mapped owners; docs-site and matching locales | Describe actual supported managers, controls, recovery and manual guidance. | + +The legacy explicit commands retain their public argument and result shapes, +but do **not** retain unsigned execution as a fallback. Migrate each affected +manual installation entry to the same verified artifact owner; report a clear +refusal if signed supply is absent. Include Node launcher, Bun and dashboard +update paths in the call-graph review and security tests. Manager-specific +support remains an in-scope deliverable, not a reason to execute an unsigned +dependency while waiting for its adapter. + +### Package policy contract + +`src/update/automatic-policy.ts` owns the strict `ocx.update.policy/1` record +at `/update-policy-v1.json`: `schema`, nonnegative safe-integer +`revision`, `channel` (`latest`, `preview`, `nightly`), `check` and `download` +(`automatic`, `manual`), and `install` (`manual`, `when-idle`). For a genuinely +missing record, use the verified installed-channel provenance defined in `010` +and automatic check/download with manual installation. Missing or ambiguous +provenance is `channel-unknown`, not a version-derived preview fallback; an owner +can explicitly choose a channel and establish verified provenance. If the current +channel or install owner cannot be determined, report unknown and do not start +automatic effects. This default permits preparation without a surprise restart; +the current explicit user action is still needed to install until changed. +The Desktop owner additionally supports `on-quit` (`030`); package-owned +background services have no Desktop quit event and reject that value rather +than inventing one. The shared parser accepts the union, and each owner enforces +its own supported values before persisting. + +Use `withConfigMutationLockSync` (`src/config/mutation-lock.ts:96`) for a +short compare-and-swap transaction around an atomic, private no-follow file +write. Parse a valid record and compare `expectedRevision` before writing the +next revision; an unreadable, malformed or unknown-schema existing record is +not treated as missing. Lock/write failure or revision overflow changes +nothing and returns a bounded error. Persist candidate deferral and failed +target identity in the operation owner, not in the channel cache; a policy or +owner change invalidates stale prepared authority. Revalidate the revision at +each effect boundary. The `OCX_DISABLE_UPDATE_CHECK=1` process override blocks +automatic checks and downloads without rewriting the stored policy; the status +must distinguish configured from effective behavior. + +Add authenticated `GET /api/update/policy` and `PUT /api/update/policy` to +`src/server/management/route-registry.ts` and its management dispatcher, with +closed JSON objects and the existing management authentication/CSRF boundary. +GET returns `{schema, policy, effective, error}` where `effective` includes +the environment override and nullable unavailable reason. PUT accepts exactly +`{expectedRevision, channel, check, download, install}` and returns the new +status or a conflict without writing. These routes do not authorize an install +and must not accept the desktop snapshot capability. Old update/check/status +and badge schemas stay unchanged. Add domain-registered +`tests/update/update-automatic-policy.test.ts` and +`tests/server/update-policy-routes.test.ts` for defaults, invalid/missing +records, concurrent revisions, failed writes, environment override, old-client +compatibility and authorization; no real user home is used. + +## Required scenarios + +- Valid signed exact candidate stages without stopping or replacing the running + proxy. Missing, wrong-key, altered, changed target, untrusted transitive + executable or unconfirmed installer exit prevents activation and leaves the + live install untouched. +- Policy, owner, serving root, target, staged tree identity and idle admission + are revalidated before swap. A sync/update conflict, altered stage, changed + channel, ownership handoff or stale reservation refuses without mutation. +- Installation failure restores and verifies the prior tree and applies the + existing manager-aware runtime recovery. A success is distinguished from a + target version serving and passing health; uncertain outcomes never trigger a + duplicate install. Failed targets do not loop automatically. +- Test npm independently on supported platforms; retain interface and ownership + regressions for pnpm and Bun explicit paths while applying signed supply. + Unsupported or externally managed + installers display an honest actionable reason. The `090` and `100` units + remain open until their own automatic adapters are proven. + +## Candidate verification + +Run focused transactional, orchestrated, mutex, supervisor and manager tests +with isolated homes, test keys and mock feed; demonstrate red then green for +the new behavioral regressions. Explicitly run subprocess and source-oracle +tests. Run `bun run typecheck`, `bun run privacy:scan`, `bun run structure:check`, +the core Lab boundary test, and exact-head required PR checks. Obtain an +independent security PASS for package installation and signing. Resolve exact +test commands and prove their input coverage before locking the roadmap. No +full root suite; the coordinator receives a PR and evidence, not a merge. + +Baseline verifier discovery, 2026-11-07: `bun test +tests/update/update-orchestrated-plan.test.ts` passed seven tests using +temporary homes and injected child behavior. `bun test +tests/update/update-transactional.test.ts -t 'manifest verifies|happy path +swaps'` passed two tests and filtered out ten; it uses temporary package trees +and an npm stub. These checks exercise existing plan and transactional owners, +not signature verification or the proposed split prepare/commit contract. + +`bun test tests/update/update-refresh.test.ts -t 'package cache refresh'` +passed 16 tests with 17 filtered out (exit 0) against the existing scheduler's +injected clock and lookup. This verifies existing refresh/coalescing/backoff and +opt-out behavior; it does not read a future policy file or prove signed updates. diff --git a/devlog/_plan/261107_auto_update_parity/050_sidebar_panel.md b/devlog/_plan/261107_auto_update_parity/050_sidebar_panel.md new file mode 100644 index 00000000000..ddeff0a9f39 --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/050_sidebar_panel.md @@ -0,0 +1,329 @@ +# Sidebar and update panel — draft unit + +**Status:** pending architecture proposal, upstream engine contract and +independent roadmap audit. Do not implement from this draft yet. + +## Outcome and boundaries + +The existing download orb in the dashboard footer exposes desktop update state +and opens the update panel described by the coordinator. For browser/package +installations, the existing dashboard update flow remains available. The native +update page retains sole native update-command authority +(`desktop/src-tauri/src/lib.rs:267`, `desktop/src-tauri/src/window.rs:115`). +The footer's displayed version must fit ordinary stable versions; long versions +remain fully readable without overlapping action buttons, at normal and narrow +widths and in supported zoom modes. + +## Proposed file map and contract changes + +| Operation | Path | Before → after | +| --- | --- | --- | +| MODIFY | `desktop/src-tauri/src/updater.rs` | Six-field snapshot (`:159`) → versioned, bounded projection of the upstream engine's authoritative phase and progress; preserve session identity, heartbeat and stale-state semantics. The precise shape must be agreed with the engine unit. | +| MODIFY | `src/update/desktop-badge.ts` | Exact six-field parser and availability-only projection (`:31`, `:74`) → explicitly versioned decoder supporting old shell snapshots and the new projection; validate all phase/progress combinations and preserve unknown on missing or expired evidence. | +| MODIFY | `src/server/management/sidebar-routes.ts` | Keep authenticated/capability-bound snapshot publication, its body limit and existing read route (`:105`); only change if the agreed projection requires it. Never add an installation action to this endpoint. | +| MODIFY | `desktop/src-tauri/src/proxy.rs`, `src/update/badge.ts`, `gui/src/lib/desktop-shell.ts` | Negotiate snapshot schema from the bound publication response and use a distinct desktop badge v2 DTO; leave package badge and legacy DTO shapes unchanged. | +| MODIFY | `gui/src/components/sidebar-github-row.tsx` | Availability-only accent (`:133`) → localized and accessible current, available, downloading percentage, ready and failed indications. Unknown/checking is distinct from current. Continue using the existing download button. | +| MODIFY | `gui/src/App.tsx`, `gui/src/design/bridge.css` | Preserve desktop page navigation (`App.tsx:591`); fix footer version sizing and wrapping (`bridge.css:428`) without covering star, update or terminal buttons. Keep full version accessible on mobile. | +| MODIFY | `desktop/ui/update.html`, `desktop/src-tauri/src/lib.rs` | Existing check/install page → native panel consuming the engine's typed status and controls: channel, download and install preferences, release notes, restart and Later. New commands, if required, use the existing local update-page guard; no raw HTML insertion for release notes. | +| MODIFY | `gui/src/i18n/{en,ko,ja,zh,zh-TW,fr,de,ru,pt,tr,vi}.ts` and applicable desktop localization owner | Add every new visible label in all supported locales, with real translations; verify the desktop page's existing localization mechanism before selecting its implementation. | +| MODIFY | `tests/update/update-desktop-badge.test.ts`, `tests/server/sidebar-routes.test.ts`, `tests/clients/desktop-update-surface.test.ts`, `gui/tests/sidebar-version-layout.test.ts`, `gui/tests/desktop-shell.test.ts` | Add meaningful behavior cases for old/new snapshots, state projection, page authority, panel controls and version accessibility. Source-read tests must run explicitly because `test:changed` cannot follow file reads. Add a focused GUI behavior test if no current harness covers the footer. | +| MODIFY | Relevant `structure/` owners from `structure/INDEX.md`, `docs-site/src/content/docs/getting-started/installation.md` and corresponding translated pages | Record current behavior only after implementation; update each affected owner and avoid contradictory localized instructions. | + +New repository test files belong in their `tests//` directory and +require layout and expected-shard registration. Keep ratcheted files within their current line caps; move code to +appropriately owned siblings rather than increasing baselines. The complete +file map must be revalidated after the engine unit lands. + +For package-owned browser installations, extend the existing dialog rather +than creating a second installer UI: `gui/src/pages/dashboard-dialogs.tsx`, +`gui/src/pages/use-dashboard-data.ts` and `gui/src/pages/dashboard-shared.ts` +read the versioned package policy/status, expose latest/preview/nightly and +check/download/install controls, and send revision-bound policy changes. Add +the separately versioned check/apply routes and owner-provenance consumers named +in `010`/`040`; the current two-channel routes and old dialog keep their exact +wire contract. An old client against a nightly installation gets an actionable +unsupported state, not an inferred preview update. Add focused GUI and +management tests for three-channel selection, changed revision, unavailable +provenance, old/new clients and explicit manual update. Update all eleven GUI +locale catalogs and the affected docs-site translations. + +## Proposed desktop snapshot v2 + +The native publisher adds `schema: 2`, a monotonically increasing per-session +`sequence`, `phase`, `installedChannel`, `policyChannel`, `candidateChannel` +and a bounded integer `progressPercent` (0–100 or null) to the existing +session/current/latest/availability/check-time fields. Allowed +phases are `idle`, `checking`, `current`, `available`, `downloading`, `ready`, +`installing` and `failed`; failed has a closed, non-sensitive `errorCode` or +null, never raw errors or release notes. Enforce an exact key set and +phase-specific constraints under the existing 1 KiB request cap +(`src/server/management/sidebar-routes.ts:113`; native proxy cap must also be +kept). Sequence ordering is per session: a late lower sequence cannot overwrite +newer state; a heartbeat at the same sequence may extend expiry only for the +same payload. Unknown versions and stale/missing session evidence remain +unknown. Reject malformed v2 without changing a prior good state. + +Each channel field is `latest`, `preview`, `nightly` or null. The native owner +populates `installedChannel` only from verified provenance bound to the current +installation and actual artifact, `policyChannel` from its valid selected +policy, and `candidateChannel` only from the verified candidate. These fields +can differ after an explicit channel switch. `candidateChannel` must be null +when `latestVersion` is null; it may be null for a retained target whose +provenance is unavailable. Null remains unknown and never implies preview from +the version spelling. The session-authenticated publisher sends the values in +the same bounded v2 body; the server parses and projects them only as display +observations, without granting install authority. A new runtime/session clears +the projection and renegotiates. Legacy v1 snapshots remain decodable but +their absent installed and candidate channel evidence projects unknown; their +availability-only behavior remains intact. + +Upgrade the server decoder and projection before publishing v2. It accepts both +v1 and v2; a v1 shell keeps its existing availability-only behavior. Proposed +negotiation: a new shell first publishes a valid v1 snapshot. A new server's +successful response adds a bounded `snapshotSchemas: [1, 2]`; the old server's +existing `{ok:true}` means v1 only. The native publisher upgrades to v2 only +after a successful response from the currently attested runtime; when the +runtime identity changes it resets to v1 and negotiates again. Authentication, +transport and parsing failures do not count as negotiation or current status. +`desktop/src-tauri/src/proxy.rs:218` currently discards the success body and +must return the validated schema selection without weakening its body-bound +publication capability. Add old-shell/new-server, new-shell/old-server, +runtime-replacement, malformed-response and auth-failure tests. Add a separate +desktop projection DTO without changing package badges. + +### Desktop badge response compatibility + +The existing `GET /api/update/badge?surface=desktop&session=` and its +`UpdateBadge` DTO retain their legacy field names and non-null two-channel type +(`src/update/badge.ts:6`). If the current snapshot has verified installed +provenance for `latest` or `preview`, the old endpoint returns the old shape +with that channel. If the snapshot is missing, expired, v1 without proven +provenance, has null installed provenance, or is `nightly`, it returns HTTP 409 +with bounded code `desktop_channel_unavailable`; it never fabricates a channel +or returns a third enum to an old client. The old sidebar already treats a +non-success fetch as unknown and the download button remains available. The +package endpoint without `surface=desktop` remains unchanged. + +Add separately registered `GET /api/update/desktop-badge-v2?session=` +with the same dashboard-session read authorization as the existing GET. Its +closed `ocx.desktop.badge/2` object has exactly `schema`, `sessionId`, +`currentVersion`, `latestVersion`, `updateAvailable`, `unknown`, `phase`, +`progressPercent`, `errorCode`, `installedChannel`, `policyChannel`, and +`candidateChannel`. `schema` is the literal `ocx.desktop.badge/2`; `sessionId` +is the requested validated UUID or null when no session is supplied; +`currentVersion`, `latestVersion`, `phase`, `progressPercent`, `errorCode` and +the three channels are null when no current trusted snapshot supplies them. +`updateAvailable` is false and `unknown` true without a current snapshot. +With one, phase/progress/error and nullable channels obey snapshot v2 rules; +a v1 snapshot can retain available/current display state but supplies null +channels: v1 `error` and `install-failed` map to v2 `failed` with errorCode +`unknown`, while other v1 phases retain their names and progress is null. +No field is installation authority. Reject duplicate or unexpected +query keys and invalid UUIDs with a bounded 400 result; absent session returns +the unknown DTO. No cache may carry a projection between sessions. + +The updated desktop sidebar constructs the v2 URL and strictly parses this +DTO in `gui/src/lib/desktop-shell.ts` and +`gui/src/components/sidebar-github-row.tsx`; a 404 from an old server, malformed +response, or unavailable session produces unknown while leaving the update +control clickable. It must not use the old inferred channel as a fallback. +The GUI must also use `lastAttemptOk` or an equivalent explicit freshness flag: +after a rejected request, malformed JSON or timeout, retained warm-cache data +is labelled stale/unknown and cannot be presented as a current successful +observation. An HTTP 409/404 or session change clears or isolates prior data; +an independently verified staged install remains controlled by its native +owner, not by the badge cache. Test a warm `current` and `ready` observation +followed by rejection, malformed JSON, timeout, 409 and runtime replacement. +Add explicit serialized-response, versioned GUI parser and route tests in +`tests/update/update-desktop-badge.test.ts`, +`tests/server/sidebar-routes.test.ts`, `gui/tests/desktop-shell.test.ts` and a +new `gui/tests/sidebar-desktop-badge-v2.test.tsx`. Cover old/new shells and +servers, missing/expired/v1/v2 snapshots, same version spelling with preview +versus nightly provenance, policy/candidate changes and runtime replacement; +assert the package and representable legacy responses retain their exact DTO. + +The v2 decoder uses the existing UUID, version and checked-time bounds. The +new `sequence` is a nonnegative JSON safe integer, and `progressPercent` is null +or an integer from 0 through 100. `errorCode` is null or one of `network`, +`feed-unavailable`, `verification`, `ownership`, `busy`, `installation`, +`recovery` or `unknown`; the UI localizes codes and never renders raw errors. +All keys are required even when their value is null. `available` is exactly +whether `latestVersion` is non-null; any target requires `checkedAtMs`. + +| Phase | Target and time | Progress | Error | +| --- | --- | --- | --- | +| `idle` | no target; no check time | null | null | +| `checking` | prior target/time may be retained; absent target may retain a prior check time | null | null | +| `current` | no target; check time required | null | null | +| `available` | target and check time required | null | null | +| `downloading` | target and check time required | integer or null while total is unknown | null | +| `ready` | target and check time required | null | null | +| `installing` | target and check time required | integer or null while total is unknown | null | +| `failed` | target and check time may be retained together; with no target, check time may be null | null | required code | + +Reject a phase/field combination outside this table, a nonidentical payload at +the same sequence, and a lower sequence without replacing the last good +snapshot. A new session never inherits a prior session's sequence or state. +The exact size cap applies after serialization, including multibyte text. +Test equal `-preview.*` version strings with distinct authenticated preview and +nightly provenance; policy loss and channel switching; candidate invalidation; +session/runtime replacement; old v1 snapshots; malformed/oversized v2; and +stale ordering. Assert each projected channel separately and refuse any inferred +preview when provenance is absent. + +The v1 encoder uses only the existing exact six-field shape. `idle`, +`checking`, `current`, `available` and `installing` preserve their old +meanings; `downloading` and `ready` project as `available` with the target +and its successful check timestamp. `failed` projects as `install-failed` +when a target is retained, or `error` when none is known. `current` carries +no target and a successful check timestamp; `idle` carries neither. A failed +check with no known target stays unknown, never current. Validate these cases +against the existing v1 parser (`src/update/desktop-badge.ts:31`) and the +oldest supported shell/server combinations before locking the contract. + +The desktop footer refreshes the session-scoped badge every five seconds and +every second during `downloading` or `installing`; package/browser polling stays +at its current ten-minute cadence. Apply resource deduplication and stop polling +when the component unmounts. Release notes are fetched from the trusted panel +status, not placed in the 1 KiB heartbeat. These schema and timing values are +proposals subject to audit, and must be tested against both shell/server orders. + +## Proposed native panel commands + +All commands require the existing exact local update-page guard. Add +`update_panel_status()` returning `ocx.desktop.update/2` with current version, +candidate version/channel, phase, bounded progress/error code, policy and +revision, sanitized release-note text, and deferred state. Add +`update_panel_policy({expectedRevision, channel, check, download, install})` +with compare-and-swap semantics; a mismatch returns the current status without +changing it. The install control exposes manual, on-quit and when-idle policy +with the consent and Later semantics in `030`. Add `update_prepare({candidateId})`, +`update_defer({candidateId})`, and `update_activate({candidateId})` returning +the same status plus a bounded accepted/refused result. The native owner +validates IDs and rechecks candidate, policy and ownership; the caller cannot +supply a filesystem path or trust decision. Keep existing `update_status`, +`update_check`, `update_install` and `return_to_dashboard` compatibility and +route them to the same claim and verified installer owner. Exact result field +names and legacy compatibility tests must be frozen with the engine unit. + +Proposed `ocx.desktop.update/2` is a closed result with `schema`, +`currentVersion`, `candidate`, `checkedAtMs`, `phase`, `progressPercent`, `errorCode`, +`policy`, `releaseNotes`, `omittedReleaseCount` and `deferred`. `candidate` is null or +`{id, version, channel}` where `id` is the lowercase SHA-256 identity of the +verified candidate; `policy` is `{revision, channel, check, download, install}` +with the values defined by `030`; `releaseNotes` is an array of at most six +`{version, items}` groups, each with at most eight plain-text items of at most +220 Unicode characters, and `omittedReleaseCount` is a nonnegative safe integer +or null when the total cannot be established. The whole encoded result is +bounded to 32 KiB; `deferred` is boolean and may be true only for a candidate. +Phase, progress and error follow the table above; a target-requiring phase must +have a candidate. Construct release links from an allowlisted release origin +and the validated exact version; do not navigate to a feed-supplied arbitrary +URL. A malformed or unavailable status is displayed as unknown. + +The signed release owner supplies same-channel notes for releases newer than +the installed version through the selected candidate. It verifies every +release record used to create a group, orders groups newest first, and reports +omitted groups when a complete bounded history is known; a missing or +unverifiable history gives a null omission count rather than inventing one. +`010` binds each record's notes to its exact version/channel. Render every +item as text. Preserve the staged candidate's previously verified notes when a +later check fails, reports no update or returns the same candidate without +notes (`030`). Test multi-version grouping, channel isolation, omissions, +truncation, malformed/unavailable history and retained ready state. GOAT's +reference groups and limits are `apps/desktop/src/updates/releaseNotes.ts:19`, +`:177`, `:208` at the pinned GOAT revision. + +`update_panel_status` accepts no arguments and returns that object. +`update_panel_policy` accepts exactly `{expectedRevision, channel, check, +download, install}`; the revision is a nonnegative safe integer and the +values are closed enums. `update_prepare`, `update_defer` and +`update_activate` accept exactly `{candidateId}`. Mutation commands return +`{schema: "ocx.desktop.update-command/1", outcome, reason, status}` where +`outcome` is `accepted` or `refused`, `reason` is a closed non-sensitive code +or null, and `status` is the freshly observed object above. The native owner +serializes and validates all arguments and uses its existing shared install +claim; an accepted request means accepted work, not installed/healthy. +Unparseable arguments or an origin rejected by the guard are command errors +without state mutation. Client timeout remains unknown until status is read; +the page does not resubmit activation automatically. + +Keep the legacy commands' existing five-field `PageUpdateStatus` +(`desktop/src-tauri/src/updater.rs:263`) and legacy failure behavior for older +bundled pages, with one engine/claim behind both versions. The new page must +detect an unavailable v2 command, display an actionable compatibility state, +and never issue a second install after an uncertain old-command result. Test +legacy/new pages with old/new shell APIs and concurrent old/new command calls. + +## Locale handoff + +The dashboard owns its selected locale (`gui/src/App.tsx:152`) and persists it +on the dashboard origin (`gui/src/i18n/provider.tsx:13`). The trusted bundled +update page is a different origin (`gui/src/lib/desktop-shell.ts:36`), so it +cannot rely on that local storage. Proposed navigation passes only the selected +closed-set locale as an encoded query value to the existing `/update.html` +path. The bundled page validates it against the eleven supported locale IDs +(`gui/src/i18n/shared.ts:6`), falls back to `en` for missing/invalid input, and +sets the matching HTML language. Locale is display data and grants no native +authority; `require_update_page` must continue to check the exact bundled +origin and path (`desktop/src-tauri/src/window.rs:115`). + +The existing Back command uses a stricter settings-page guard that rejects all +queries (`desktop/src-tauri/src/lib.rs:301`, `desktop/src-tauri/src/window.rs:134`). +Change its update-page branch to accept either no query or exactly one `locale` +query whose decoded value is one of the eleven supported IDs. Continue to +require the main window, exact app origin/path, no userinfo or fragment, and +reject duplicate or unknown query keys. The CLI settings page keeps its +existing no-query rule. Add Rust URL-predicate tests and desktop-page tests for +`/update.html?locale=ko` returning to the dashboard, invalid/duplicate values, +other origins and CLI-page queries. The current guard is not assumed to accept +the new navigation without this change. + +Produce `desktop/ui/update-locales.json` deterministically from a React-free +typed table `gui/src/i18n/desktop-update-copy.ts` using +`scripts/generate-desktop-update-locales.ts`; include a `--check` mode in the +desktop build to detect drift. Bundle all eleven translations and keep the +source table as the single owner of panel copy. Render only text, never +HTML from release notes or locale input. Add a test that every locale has each +key and that invalid locale inputs cannot change origin or inject markup. +Test the generator, build check and bundled Tauri asset loading. Do not add a +runtime network fetch for translations. + +## Activation scenarios and evidence + +- Old desktop snapshot is accepted by the newer server and preserves its prior + available/unknown meaning; unknown phases and malformed fields are rejected. +- Missing, expired or another session's snapshot shows unknown; a check failure + never displays up-to-date. A current result, available version, progress, + staged result and failure each produce distinguishable labels and states. +- A browser dashboard click reaches its existing package dialog; a desktop click + reaches the bundled panel. Requests from a non-update page cannot invoke + privileged native update commands. +- Preferences survive reopening; Later defers activation and does not erase the + verified staged update. Release notes render as safe text with an appropriate + release link. A failed download or install gives a retryable, accurate state. +- At normal and narrow desktop widths, mobile drawer width, 90% and 100% zoom, + the footer text and all controls remain visible and usable; test long version + identifiers, keyboard focus and screen-reader labels. Capture before/after + UI screenshots through the authorized `pr-assets` path, never in the PR branch. + +## Candidate validation + +Baseline discovery has run the two badge test files (17 pass) and, from `gui/`, +the sidebar version and row tests (12 pass); see `001_inventory.md`. During +implementation run failing-first focused tests, the explicit desktop surface +and sidebar-route files, `bun run typecheck`, `bun run privacy:scan`, +`bun run structure:check`, and from `gui/` `bun run lint:i18n`, `bun run lint`, +`bun test tests` and `bun run build`, plus rendered browser/native proof. These +commands are candidate gates; establish their exact change coverage and record +fresh results before the roadmap is locked or the PR is review-ready. No full +root suite. PR CI must be evaluated at the exact head; request the separate +security review if any authority, updater or installation surface changes. + +Baseline on 2026-11-07: `bun test tests/server/sidebar-routes.test.ts +tests/server/link-management-relay.test.ts` passed 31 tests (exit 0) with +isolated test homes and ephemeral listeners. The sidebar file exercises the +existing six-field snapshot's route, session separation, input limits and +authorization. The relay file exercises the existing passive link boundary. +Neither test proves the proposed v2 snapshot or native panel; add those cases +and demonstrate their initial failure before implementation. diff --git a/devlog/_plan/261107_auto_update_parity/060_linked_updates.md b/devlog/_plan/261107_auto_update_parity/060_linked_updates.md new file mode 100644 index 00000000000..b5a853b7a13 --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/060_linked_updates.md @@ -0,0 +1,449 @@ +# Linked-machine updates — draft unit + +**Status:** depends on the signed supply and local update contracts; architecture, +transport authority and independent security audit are unresolved. Do not +implement from this draft yet. + +## Outcome + +An operator can see and control eligible Home and Child updates, including +per-machine state, deferral and failure. Automatic work is permitted only when +the destination's own setting allows it, the exact artifact is signed and +verified, the destination identity and installer ownership are established, +compatibility is known, and the guarded stop/drain and idle admission succeed. +The Home must not report an offline, stale, unverified or unsupported Child as +updated. All tests use isolated homes, fake links and local mock supply. + +## Proposed transport and durable state + +Use the existing host-key-pinned, non-interactive SSH exec transport for +Home-initiated links (`src/link/ssh-argv.ts:1`, `:70`) and select the Child +executable once, as the pinned sync path does (`:244`). Client-initiated links +without an authorized Home-to-Child exec route are explicitly unsupported until +a separately audited transport exists. Keep the management relay read-only +(`src/link/management-routes.ts:1`); peer reports are compatibility +observations, not authorization (`src/link/peer-report.ts:1`). + +Proposed new CLI operation is `ocx link-update` with `prepare`, `status`, +`commit` and `cancel` subcommands and a versioned bounded JSON request/result +schema: `ocx.link-update.envelope/1`, `ocx.link-update.request/1` and +`ocx.link-update.result/1`. Inputs include an operation UUID, exact link id, candidate identity, +destination policy revision, plan identity and expiry. A `status` read is +idempotent; `prepare` and `commit` record their operation ID before work; +replaying the same request returns the recorded state, while a conflicting +request with the same ID is refused. `cancel` cancels only an uncommitted +operation; after a handoff the caller observes it rather than starting another. +Transport request data is passed as bounded structured input, not interpolated +into shell commands. The Home stores an atomic fleet journal before activation +with target identities and per-Child outcomes, then resumes observations after +its own restart. A healthy Home already at the selected version satisfies the +Home-first prerequisite. A stale or unverified Home does not. + +The proposed exact envelope is `{schema, keyId, payload, signature}` with +`schema: "ocx.link-update.envelope/1"`; `payload` is base64url of the exact +UTF-8 request bytes and the signature covers those bytes and a protocol-domain +separator. The closed request has `schema`, `action`, `requestId`, `nonce`, +`issuedAt`, `notAfter`, `fleetId`, `homeId`, `childId`, `configurationId`, +`installationId`, `linkId`, `linkBindingEpoch`, `grantId`, `grantEpoch`, +`operation` and action-specific `args`. `prepare` names the destination policy +revision and exact signed candidate digests; `commit` names the prepared handle, +plan digest, expected operation revision and Home health barrier; `cancel` +names the operation and expected revision; `status` is a read-only discovery or +one-operation query. Each action is separately signed and cannot carry an +arbitrary executable path, command or download URL. Bound the encoded envelope +and result to 64 KiB, decoded request to 32 KiB, input to five seconds, and +request validity to five minutes; these are proposed testable limits. + +The response `ocx.link-update.result/1` binds `requestId`, request digest and +nonce, destination and grant/binding identities, operation identity/revision, +durable phase, bounded reason, candidate and policy revision, and separate +`commitAccepted`, `mutationStarted`, `installationVerified`, `runtimeHealthy` +and `rollbackVerified` observations. It is signed by the enrolled destination +response key under a separate domain. Unknown schema, malformed encoding, +duplicate keys, mismatched request binding or unavailable identity is a refusal +or unknown result, never success. These schemas require independent security +review and an exact implementation-level field chain before the plan is locked. + +The Child independently checks its durable link connection under the lifecycle +and configuration locks used by its existing expectation check +(`src/client/sync-expectation.ts:108`), its own opt-in policy/revision, selected +executable and install owner, capability, exact signed candidate and fenced +idle admission. SSH authentication alone and the unkeyed plan-consistency hash +(`src/update/orchestrated-token.mjs:3`) are not a replacement for destination +consent or operation authorization. The request proof, replay journal and +lock ordering need a concrete protocol and independent security review before +the roadmap is locked; this paragraph does not claim those controls exist. + +The independent `auto-update-linked-authority-research-01` lane recommends a +separate Home update signing key and a destination-local grant bound to the +Home, Child, installation and link generation. Creating or approving that grant +is an explicit action by the destination owner; an agent must not auto-answer +it, and old links get no implicit update authority. Separate local policy +controls preparation and activation. A Home request cannot enable a disabled +destination policy or clear its deferral. Key provisioning, response proof, +rotation and revocation are proposed design work, not existing features or a +security PASS; tests use isolated keys and homes only. + +Proposed owner-facing local commands are `ocx link-update grant list --json`, +`ocx link-update grant approve --request `, and +`ocx link-update grant revoke --grant `. Approval and revocation act only +on the destination's local grant store and require the repository's existing +person-consent boundary; a Home request may present a public-key enrollment +request but cannot approve it. The CLI registry, capabilities and generated +skill surface advertise the new contract only once dispatch and grant +operations exist. A lost approval response is reconciled by grant ID, not +automatically approved again. No agent or test may approve a real user's grant; +tests use isolated fake destinations. + +The proposed grant store is `/link/update-grants.json`, owned by +the destination account and written atomically with the existing private-file +policy. Each strict `ocx.link-update.grant/1` entry contains `grantId`, +`grantEpoch`, `homeId`, `homeUpdatePublicKey`, `childId`, `configurationId`, +`installationId`, `linkId`, `linkBindingEpoch`, `apiKeyId`, `scopes`, +`expiresAt`, `revoked` and `childResponsePublicKey`. The destination response +public key is enrolled with the grant; private key material belongs in the existing secure +credential owner, never in a status projection or source control. Grant +approval, revocation, connection change and local policy changes serialize +with the durable destination binding. The precise key-storage adapter and +person-consent API must be verified against existing platform implementations. + +The proposed key owner is a new `src/link/update-key-store.ts`, independent of +provider API-key accounts. Store the Home update signing key and each Child +response private key under the respective owner's private link directory using +the existing no-follow, owner-only file and required Windows ACL patterns +(`src/codex/installation-id.ts:19`, `:40`); verify a newly written public key +against the private key before publishing a grant. Never print, transmit or +copy private keys into journals, status or config. An OS keyring may be used +only through an explicitly tested adapter; locked/unavailable storage refuses +the operation rather than generating a replacement identity or falling back +silently. File ownership and ACLs protect the account boundary, not against an +arbitrary process already acting as that account. Tests use temporary homes +and generated fixture keys only. + +The explicit local grant approval must validate the presented Home public key, +link identity, scopes and expiry and require the destination owner's action; +an incoming Home request cannot approve itself. For CLI-driven approval use the +existing agent-driven and interactive-consent controls +(`src/cli/agent-driven.ts:60`, `src/cli/interactive-confirm.ts:1`), with a +separately reviewed dashboard equivalent if one is added. Refuse absent or +unreadable local consent and persist the approved binding before returning +success. Revocation is an owner action and never waits for Home reachability. + +Binding migration must cover the actual writers, not just the connection type: +`commitClientConnection` and `clearClientConnection` in +`src/client/state.ts:202`, `:230`; connect/rotation and disconnect in +`src/client/connect.ts:577`, `:1193`; Child-initiated link sidecar publication +and removal in `src/client/link-join.ts:159` and `src/client/link-state.ts:129`, +`:149`; Home link creation, enrollment, compensation and revocation through +`src/server/management/link-routes.ts:99`, `:233`, +`src/server/management/link-enrollment.ts:165` and +`src/server/management/link-route-state.ts:153`. The current Child sidecar +parser has an exact field set (`src/client/link-state.ts:46`): define and test +an explicit old-record migration before adding any field, and preserve its +fail-closed marker behavior. Search all config and key writers again when the +unit begins; this list is a reviewed starting point, not proof of exhaustiveness. + +On relink, ownership change or key rotation, first persist the invalidation of +the old binding under the relevant locks, then publish the new connection; a +crash between them leaves update access disabled and requires a new local +grant. On revoke, mark the grant revoked and advance its epoch durably before +acknowledging, then stop future prepare/commit dispatch. An already accepted +operation is reconciled by its destination owner to a safe outcome; revocation +does not authorize a second installer or erase its recovery record. Status +under an invalidated binding is available only to the local owner; a stale +remote grant receives a refusal. Add focused tests for each writer, +interrupted invalidation, concurrent commit/revoke and old-record migration. + +For each operation, persist request identity and a monotonically increasing +destination operation revision before starting work. Identical retries return +the recorded outcome; conflicting reuse is refused. Cancellation and commit +compete in a single durable transition; cancellation after accepted commit is +too late, and recovery continues under the destination owner. An expired or +lost request is observed through a new status request, never blindly replayed +as a fresh install. Windows SSH currently ties the selected command to the +channel lifetime (`src/link/remote-windows.ts:37`), so a destination-owned +worker handoff must be proven on that platform before accepted work is claimed +to survive disconnect. + +The proposed lock order is `U → O → A → N → L → C → J`: existing home +sync/update mutex (`U`), installation ownership lease (`O`), link apply +exclusion (`A`), native integration (`N`), client lifecycle (`L`), config +mutation (`C`), then a short journal transaction (`J`). Existing client code +documents `N → L → C` (`src/client/lifecycle-lock.ts:1`); the combined order +is a proposed extension and must be proven against every caller. No inner lock +is held over SSH, installer execution or readiness waits. Preparation holds +only a stage lease while waiting; activation reacquires and revalidates the +relevant owners. A durable binding epoch must change before a relink, key +rotation or installation-owner change can become effective. + +Compatibility for the future Home/Child pair must be established from signed +release capability metadata for each candidate, rather than extrapolated from +current peer reports. Unknown or invalid future compatibility defers. A Child +that cannot update through its actual installer reports a specific unsupported +or owner-action state. The full installer/platform matrix and target metadata +format remain open deliverables, not a diagnostic-only completion condition. + +The signed compatibility descriptor must bind each exact release artifact and +its provided/required link protocols, update actions, recovery protocol, +installer adapter and fleet-journal reader versions. Before Home-first +activation, check the current pair, the new Home with each old Child, the new +Home with each new Child, Child recovery under the new Home, and Home recovery +after a Child has moved. Unknown pairs defer. After Home restart, obtain fresh +identity and health evidence before resuming Child commits; a healthy Home +already on the selected signed artifact can satisfy the prerequisite without a +new update. Initial rollout activates one Child at a time, and post-update +catalog sync is reported separately. + +`003_contracts.md` defines the closed descriptor and exact-pair comparison. +Add `src/link/update-compatibility.ts` and +`tests/clients/link-update-compatibility.test.ts`: consume only descriptors +validated by the shared supply parser and compare each required Home/Child and +recovery pair. Validate the Home fleet journal reader and destination adapter +for the actual operation, not merely one matching link protocol. The release +unit owns generation and parser vectors; this unit owns the comparator and +fleet gating. Older artifacts without authenticated descriptors stay unknown +until the publisher provides a descriptor bound to their exact bytes or the +owner performs an explicit manual bootstrap. This proposal does not assert +that historical descriptors already exist. + +The Home-first barrier applies to a coordinated fleet operation, not to every +independent server update. An owner may request an individual Child update +while Home remains on its current release if the authenticated descriptor +proves that current Home and both the target and recovery Child are compatible. +The Child may also follow its own enabled signed channel and idle policy while +the Home is offline. Such work retains destination consent, signed supply, +durable operation identity and guarded activation. This preserves the +independence documented by GOAT (`docs/internals/remote-updates.md:21`, GOAT +reference revision); lack of a live Home is not permission to weaken those +local checks. Fleet Home-first resumption and individual Child operation need +separate tests and status. + +Independent automatic updates may race, so a comparison of only today's peer +versions is insufficient. For an offline or uncoordinated move, require both +the currently installed artifact and its target/recovery artifacts to carry the +same publisher-authenticated `compatibilityEpoch` and +`compatibilityVectorSha256` described in `003`; each endpoint retains the +last verified peer epoch/vector and installation binding. This is a +publisher-certified invariant over every artifact in that epoch, not a claim +that a peer observation is fresh. A target that changes either value cannot +activate independently: it must use the coordinated fleet transition, which +holds the fleet generation lease and checks all transitional/recovery pairs. +An unknown, revoked or unavailable epoch also defers. A current peer reading +is still required before a coordinated commit; an old authenticated reading is +not treated as current. An operator may perform a separately authorized manual +recovery if coordination is unavailable, without weakening signature or owner +checks. + +The release build must derive the compatibility vector from the owning feature +and protocol declarations and prove the epoch invariant in release tests; a +publisher must not reuse an epoch after a compatibility change. Add +`tests/clients/link-update-compatibility.test.ts` cases where Home and Child +simultaneously validate their old peer and select individually compatible but +mutually incompatible targets: changed epochs must refuse independent +activation. Also test matching epoch/vector with an offline Home, stale or +revoked descriptors, rollback targets and a coordinated breaking transition. +Before a coordinated epoch change, the Home durably records the transition and +obtains an authenticated generation-bound update fence from every participating +Child. Each Child closes new independent admission, reports and reconciles any +already accepted operation, and retains that fence until the Home commits or +cancels the same fleet generation. An offline or uninspectable participant +blocks that breaking transition; the coordinator must not infer an ack from a +stale report. Lost acknowledgements are read back against the same generation, +and a restarted coordinator reconciles the durable fences before dispatching. +Test an independent update accepted just before the fence, one racing it, a +lost acknowledgement and offline participants. Existing same-epoch automatic +updates can resume only after their local fence is released or reconciled. +This permits independent updates only where the signed compatibility horizon +proves the resulting cross-product, and remains a design pending security and +release review. + +The proposed Home journal is `/link/fleet-updates.sqlite`; the +Child journal is `/update/link-operations.sqlite`. Both use private +permissions and durable transactions. The Home stores fleet ID, generation, +frozen member/link identities, exact artifact digests, Home health barrier, +per-Child operation IDs, request digests, latest authenticated result and +separate sync outcome. The Child stores grant/binding epochs, operation sequence, +request digest, local policy revision, prepared-stage identity, durable phase, +installer/stop receipts and outcome. Request or result secrets are not logged. +Home startup takes one fleet lease, reconciles unresolved intents before +dispatch, re-proves its own target/health and establishes a fresh barrier; +Child startup reconciles its own unfinished operation before accepting another. +The initial implementation must prove SQLite durability and platform file +ownership using isolated crash/restart tests, not just schema serialization. + +## Existing owners and candidate change map + +| Operation | Path | Before → proposed after | +| --- | --- | --- | +| MODIFY | `src/link/compatibility.ts`, `src/remote/features.ts`, `src/link/peer-report.ts` as needed | Reuse authenticated relay and peer-feature compatibility (`compatibility.ts:71`); advertise a versioned update capability only when it is actually implemented. Unknown and older peers stay readable but are not admitted to unattended replacement. | +| NEW / MODIFY | `src/cli/link-update-command.ts`, `src/cli/dispatch.ts`, `src/cli/registry.ts`, `src/cli/capability-contracts.ts`, `src/cli/capabilities-base.ts`, `skills/ocx/` | Add separate local grant and remote operation entry points, advertise `link-update/1` only when implemented, and regenerate the CLI skill surface. Preserve existing command output and use the established person-consent controls for grant changes. | +| MODIFY | `src/client/connect.ts`, `src/client/state.ts`, `src/types/config.ts` and all connection-state readers identified by search | Create and persist a binding epoch, parse older records safely, invalidate grants before connect/disconnect/rotation or installation ownership changes, and recheck the same binding under existing locks. The full writer/consumer list and migration tests must be enumerated before implementation. | +| NEW / MODIFY | `src/link/` update orchestration sibling, `src/cli/sync-fanout.ts`, `src/cli/sync-command.ts` | Existing fan-out selects known linked Children and bounds work (`sync-fanout.ts:99`, `sync-command.ts:207`). Reuse identity, deadline and per-child verdict patterns while keeping update and catalog sync separate contracts. Establish whether a shared runner is appropriate before editing. | +| MODIFY | `src/link/ssh-argv.ts`, `src/link/remote-windows.ts` only after design approval | For Home-initiated SSH, select the existing pinned executable, frame its output and carry an exact validated update request; never interpolate untrusted shell text. Preserve existing `sync --expect-link` behavior. | +| MODIFY | `src/update/orchestrated-plan.ts`, `src/update/orchestrated-entry.ts`, `src/update/orchestrated-admission.mjs` only where required | Existing plan rejects ambiguous ownership, source/desktop/mise installs and downgrades (`orchestrated-plan.ts:21`); reuse plan token, deadline, installer and observed-result contracts, adding exact verified artifact and destination-bound authorization without weakening them. | +| NEW | Destination-owned policy, operation journal and admission modules under the established owners | Persist explicit local enable/defer policy and bounded status. Recheck link identity, consent, signed target, compatibility and idle immediately before mutation. The owner and wire schema need architect and security review. | +| NEW / MODIFY | `desktop/src-tauri/src/link_update_bridge.rs`, native update owner in `desktop/src-tauri/src/updater.rs`, `src/link/` destination worker | A destination-owned Desktop app accepts only a locally granted, operation-bound request and applies it through its existing native updater, consent policy and Stop/Quit-aware recovery. A package worker never replaces a Desktop bundle. An offline app, absent local grant or unverifiable app identity returns owner-action/unknown; completing this unit requires supported remote Desktop activation, not a permanent refusal. | +| NEW / MODIFY | `src/server/management/link-update-routes.ts`, `src/server/management-api.ts`, `src/server/management/route-registry.ts`, `gui/src/remote-link-update-api.ts`, `gui/src/pages/RemoteLink.tsx`, `gui/src/components/remote-link-update-panel.tsx`, all GUI locales and relevant docs-site locales | Register the separate versioned status/action endpoints below, parse their DTOs in the GUI and render destination status, retry and Later. Preserve `parseRemoteLinkStatus` and the old `/api/link/status` response. Never claim completion until destination evidence proves version and health. | +| MODIFY | `tests/cli/sync-fanout.test.ts`, `tests/clients/link-peer-compatibility.test.ts`, focused `tests/update/` and `tests/clients/` | Cover authenticated identity, mixed old/new peers, Home/Child ordering, duplicate requests, deadlines, signed payload mismatch, busy/idle races, recovery and sync interaction using isolated fixtures. Register new domain test files in both layout maps. | +| MODIFY | `structure/remote-link.md`, `structure/remote-messaging.md`, `structure/ops/service-and-sidecars.md`, other source owners from the index | Review both `src/link/` owners (`structure/INDEX.md:362`); record actual post-change ownership, wire schema, compatibility, outcomes and invariant tests in affected docs. | + +### Dashboard management boundary + +`src/server/management/link-update-routes.ts` owns separately registered +`GET /api/link/updates/v1/status`, `POST /api/link/updates/v1/action` and +`GET /api/link/updates/v1/action-result?requestId=`; +`src/server/management-api.ts` dispatches the sibling through its existing +on-demand management composition and `route-registry.ts` records both methods +and the mutation. Both require the existing operator-paired dashboard session +(`link-route-state.ts:67`); reject admin-token-only, unpaired, Tailscale +identity, passive relay and snapshot-capability callers. Keep existing CSRF, +origin, body and mutation controls, and prove the new handler is never exposed +through the read-only link management relay. Neither endpoint can approve, +create, widen or revoke a destination grant or alter destination policy. + +Status returns a closed `ocx.link-update.dashboard-status/1` object with +`schema`, `fleetId`, `fleetRevision`, `destinations` and `nextCursor`. A page +contains at most 100 destinations; `nextCursor` is null at the end or an opaque, +bounded server-issued cursor bound to fleet ID/revision and this paired session. +The only optional query is `cursor`; stale or invalid cursors refuse rather than +mixing revisions, and the GUI restarts the read on a changed fleet revision. +Each item has +`linkId`, `bindingEpoch`, `operationId`, `operationRevision`, `candidateId`, +`destinationPolicyRevision`, `lastActionRequestId`, `phase`, `reason`, `commitAccepted`, +`mutationStarted`, `installationVerified`, `runtimeHealthy`, and `deferred`. +Nullable identities and outcomes mean unknown, never success. `phase` is one +of `unknown`, `unavailable`, `eligible`, `preparing`, `ready`, `deferred`, +`committing`, `installed`, `healthy`, `failed`; `reason` is a bounded closed +code, not raw remote errors. Values come from the local durable Home journal +and authenticated Child result; the DTO is display evidence only. A stale or +offline Child remains unknown/unavailable and cannot be called healthy. +`lastActionRequestId` is null or the newest journaled dashboard request for the +link, including an unresolved request. It lets a newly opened GUI recover the +request identity after a tab or Home restart; it is not an action capability. + +The closed action request `ocx.link-update.dashboard-action/1` contains +`schema`, fresh UUID `requestId`, `action` (`retry` or `later`), `linkId`, +`bindingEpoch`, `operationId`, `expectedOperationRevision`, `candidateId` and +`destinationPolicyRevision`. Require exact keys, bounded bodies and matching +journal/binding/policy revisions; null operation/candidate is rejected for an +action. `later` durably suppresses this candidate for that destination until an +explicit retry or a different verified candidate; it never cancels a committed +handoff or changes the Child's policy. `retry` clears that local deferral only +after rechecking destination grant, local policy, compatibility, candidate, +identity and admission; a new operation is allowed only after reconciliation of +the old one. The response contains `schema`, `requestId`, `operationId`, +`operationRevision`, `disposition` (`pending`, `accepted`, `deferred`, `refused` +or `uncertain`) and `reason` (a bounded code or null), with literal schema +`ocx.link-update.dashboard-action-result/1`. It is an acknowledgement, not proof of +installation. Before external effects, atomically persist `requestId`, SHA-256 +of the exact accepted request bytes, original operation ID A, destination/link +and binding identity, and a pending receipt. The journal then records resulting +operation ID B (or null), resulting revision and disposition. On repeated POST, +look up request ID and compare the exact-body digest before stale-revision +checks: identical bytes return the existing pending or recorded receipt only; +a different digest refuses. Neither replay nor a readback may issue an effect. +First execution still validates current grant, policy, binding, candidate, +operation revision and owner before dispatch. A crash between journal and +dispatch is reconciled by the durable Home owner and destination protocol; +pending does not mean the effect did or did not occur. + +The separate `action-result` GET requires a newly authenticated paired session, +accepts exactly one UUID `requestId` and returns a closed bounded +`ocx.link-update.dashboard-action-readback/1` object: `schema`, `requestId`, +`requestDigest`, `linkId`, `bindingEpoch`, `originalOperationId`, +`resultingOperationId`, `operationRevision`, `state` (`pending`, `recorded`, +`unknown`) and `disposition`/`reason` (nullable until recorded). For `unknown`, +all evidence fields except `schema` and requested `requestId` are null. A known +request is looked up from the durable Home journal, not from the currently +observed peer; after relink or grant revocation it is historical evidence only. +Unknown, expired or pruned records return null evidence and `unknown`, never +evidence that an effect did not occur. Retain unresolved requests and their +operation bindings until reconciliation; a bounded terminal-retention policy +may prune only settled receipts. After a lost response, GUI reload, Home restart +or session replacement, the GUI recovers `requestId` from its pending request or +the status projection, reads that exact request, then observes resulting B if +known. An unresolved or unknown result disables further effectful retry until +owner reconciliation; no mere possession of the request ID grants authority. + +`gui/src/remote-link-update-api.ts` strictly parses these separately versioned +objects; `RemoteLink.tsx` renders a sibling +`gui/src/components/remote-link-update-panel.tsx` keyed by link and operation, +without appending fields to `parseRemoteLinkStatus`. On a 404 or unsupported +schema from an older server, show an unavailable state and disable actions; +never infer success. Unit `080` uses this same Home-side DTO after its own +Child-pull authority and durable operation contract are implemented. Add +`tests/server/link-update-dashboard-routes.test.ts`, +`tests/clients/link-update-dashboard.test.ts` and +`gui/tests/remote-link-update-panel.test.tsx` as future tests, with the two +root-test layout registrations where applicable. Cover paired versus unpaired, +admin and relay rejection, malformed and stale revisions, old servers, mixed +links, offline status, Later persistence, revocation/policy change, duplicate +requests, A→B Retry with a lost acknowledgement, identical replay before stale +revision rejection, conflicting request bytes, pending/unknown retention, +repaired sessions, Home restart, pagination and both SSH and Child-pull +transports, and translated accessible +states. A reachable implementation and these tests require separate security +review; these DTOs themselves are not authorization. + +The Desktop bridge is a separate local owner IPC, not a call to privileged +WebView commands. The native app creates an owner-private endpoint under its +validated update-operation directory: a Unix-domain socket on macOS/Linux or a +current-user-ACL named pipe on Windows. Its private identity record binds app +PID/process instance, install ID, endpoint and a fresh secret; the destination +worker validates file ownership, challenges the live app and binds the reply to +the same connection and process instance before sending the already signed, +bounded request. The app verifies the destination-local grant, link binding, +policy, candidate and operation revision again, then invokes its existing +native update owner; neither the IPC caller nor the dashboard gets an install +path or verification bypass. + +Each IPC request carries operation ID/generation and a nonce plus a body-bound +capability derived from the private app secret; the reply binds that request +digest, nonce and native owner generation. Record `accepted` durably before a +success reply. Repeated identical requests read the same operation; changed or +stale requests refuse. The app and its separately signed guardian preserve the +journal and reconcile after application exit; a lost IPC reply is observed via +the destination journal, not retried as a second install. If the app is not +running or its identity/endpoint is unknown, return owner-action/unknown; do +not start or replace it as a package. Add isolated POSIX and Windows IPC tests +for forged or stale app identity, unauthorized callers, changed grant/policy, +lost replies, process exit, concurrent native-page/remote actions and Stop/Quit +intent. The IPC boundary is separate from the bundled update-page guard +(`desktop/src-tauri/src/lib.rs:267`) and requires independent security review. + +## Required activation scenarios + +1. For a fleet operation, Home is updated and proven healthy before Child + commits; for an independently requested Child operation, the current Home and + target/recovery compatibility can authorize the Child without updating Home. + Each eligible Child uses its own exact target and independently verifies the + signature. Catalog synchronization remains separately reported. +2. A disabled or deferred Child, changed link identity, disconnected Child, + unknown capability, incompatible protocol, source/mise-owned install, + missing signature or target downgrade produces a specific non-success state + without touching the installation. Device-side consent is not inferred from + Home control alone. +3. An active request or unknown idleness defers. If idleness, identity, policy, + target, owner or plan token changes after planning, a fresh admission refuses + before any mutation; the existing stop/drain path never interrupts a request. +4. A timeout or disconnected client cannot be called success. A Child that + continues after a lost reply is observed rather than blindly retried; a + failed or rolled-back target is not automatically retried in a loop. Result + readback verifies version and health, with explicit uncertain outcomes. +5. Old peers and malformed/unknown capabilities cannot acquire update authority; + standard sync remains functional. Exercise POSIX and Windows command framing, + duplicate and partial outputs, concurrent operations and isolated fake feeds. +6. A linked Desktop owner applies an authorized request only through its native + updater; missing local consent, a stopped/offline app, changed native owner or + busy activity is reported without a package installer taking over. Test both + successful native delegation and refusal, including Stop/Quit intent. + +## Candidate verification + +Run red-to-green focused fan-out, compatibility, orchestrated-update and new +integration tests, including subprocess/source-read files explicitly. Run +`bun run typecheck`, `bun run privacy:scan` and `bun run structure:check`; +validate relevant GUI locales/build if visible UI changes, and obtain a separate +independent security PASS. Exact commands and evidence that they reach the +changed paths must be established before locking the plan. No full root suite; +required exact-head PR CI and any authorized platform proof remain mandatory. diff --git a/devlog/_plan/261107_auto_update_parity/070_standalone_updates.md b/devlog/_plan/261107_auto_update_parity/070_standalone_updates.md new file mode 100644 index 00000000000..1226aa68c35 --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/070_standalone_updates.md @@ -0,0 +1,66 @@ +# Signed standalone updates — draft unit + +**Status:** depends on signed supply, update-stop admission, package/guardian +recovery and linked update contracts. The current orchestrated plan maps a +non-Desktop standalone installation to unknown (`src/update/orchestrated-entry.ts:128`); +this unit must not change that refusal until the new owner is proven. + +## Outcome and proposed file map + +Support an explicitly owned standalone executable on the existing release +targets (`scripts/standalone-targets.ts:7`). The owner downloads a signed exact +platform artifact, verifies it and a signed previous recovery artifact, stages +both outside the live executable and uses the same policy, idle reservation, +receipt-backed stop and durable recovery contracts as the package unit. +Unknown, foreign, source and externally managed paths remain refused. + +| Operation | Proposed path | Required change | +| --- | --- | --- | +| NEW | `src/update/standalone-owner.ts`, `src/update/standalone-stage.ts` | Resolve and bind the selected real executable and install owner; verify the signed exact target and recovery material; expose an owner-held stage without executing downloaded bytes. | +| NEW | `src/update/standalone-replace.ts` and a signed recovery helper | Perform a same-owner replacement and rollback under the existing mutation and update-stop authority. On Windows, use a verified external helper that waits for the executing image to exit; no uncontained replacement or unverified helper. | +| MODIFY | `src/update/orchestrated-plan.ts`, `src/update/orchestrated-entry.ts`, `src/cli/capability-contracts.ts` | Advertise a separate versioned automatic capability only after its owned standalone path is implemented; preserve existing `ocx.update.plan/1` and result behavior. | +| MODIFY | `scripts/build-standalone.ts`, `desktop/scripts/verify-release-assets.ts`, release workflow within its existing permissions | Produce and verify signed target/recovery artifacts and the exact compatibility metadata. No release is published by this task. | +| NEW | `tests/update/update-standalone-automatic.test.ts`, `tests/cli/cli-standalone-update-owner.test.ts` | Domain-registered, isolated fixtures for signed staging, owner changes, idle admission, process termination, crash at each swap, rollback and health. | +| MODIFY | `structure/runtime.md`, `structure/ops/service-and-sidecars.md`, relevant release and user docs plus translations | Describe actual supported owners, platforms and recovery. | + +The standalone build is a multi-file installation: it includes the compiled +executable, a target-specific native keyring addon and `gui/dist` +(`scripts/build-standalone.ts:84`, `:95`). Replacing only the executable does +not establish a matching signed release. The selected adapter owns an explicit +managed installation directory containing versioned complete signed generations +and a stable launcher/selection record; it verifies the complete inventory, +including the addon and GUI, before a cutover. A legacy loose executable or +foreign directory first needs an explicit owner-guided bootstrap into that +layout; do not infer ownership or delete neighboring files. The bootstrap and +its failure/recovery tests are part of this unit, not a deferred exclusion. + +Use the signed guardian and operation journal from `030`: stage an exact target +generation and separately authenticated prior generation, acquire the `020` +installation fence, prove runtime/process exit, and publish one durable +generation selection under the owner. On POSIX, prove same-filesystem atomic +publication and recovery of the selection; on Windows, the verified guardian +waits for the executing image and observes its own replacement operation before +readback. If the platform cannot establish selection atomicity or durable +recovery, refuse that owner's automatic update and keep its parity row open. +Validate the real launcher, selected generation, native addon, GUI and serving +version together after restart; a matching executable version alone is not +health. Tests cover loose-layout bootstrap, unrelated neighboring files, +cross-volume refusal, interrupted selection, guardian death and signed prior +generation restoration on every supported release target. + +## Activation and evidence + +- Valid signed exact-platform bytes stage in a temporary owner-controlled home; + missing/wrong signatures, wrong architecture, altered stage, ambiguous owner + and absent signed recovery material refuse before runtime stop. +- Busy or unknown activity defers. A successful owner-bound stop precedes any + replacement, and the previous executable remains recoverable until target + health and the probation period complete. +- Simulate interruption before/after each durable journal, rename or helper + boundary, lost response and surviving process. Verify either the previous + signed executable is restored or an honest uncertain state is retained; + never run a second installer on an unconfirmed outcome. +- Exercise each supported OS/architecture through isolated tests and relevant + native CI. Require the separate security PASS, typecheck, privacy/structure, + Lab boundary, test-layout/file-size guards and exact-head CI. Commands and + platform-specific helper implementation remain to be concretized and audited. diff --git a/devlog/_plan/261107_auto_update_parity/080_child_initiated_updates.md b/devlog/_plan/261107_auto_update_parity/080_child_initiated_updates.md new file mode 100644 index 00000000000..ab86a60fcd9 --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/080_child_initiated_updates.md @@ -0,0 +1,108 @@ +# Child-initiated linked updates — draft unit + +**Status:** depends on the signed supply, destination grant and durable update +operation in `060`. Home-initiated SSH alone does not cover this link direction. +Do not treat the current `transport-unsupported` state as final parity. + +## Outcome and proposed transport + +For a Child-initiated link with no Home-to-Child SSH exec route, the Child +polls its authenticated Home connection for a request addressed to its +locally approved update grant. The existing passive management relay remains +read-only. A separate versioned update exchange carries bounded signed +requests/results; the Child checks its own grant, policy, signed candidate, +installer ownership and idle admission before any effect. Home can request but +cannot approve or widen the destination grant. Existing link sync remains a +separate operation and status. + +The existing Home listener combines its route allowlists in +`src/server/index/optional-listeners.ts:90` and admits the configured link key +before dispatch (`src/server/index/serve-options.ts:387`). The Child's +`fetchBoundLinkRelay` authenticates the Home and sends on the same socket +(`src/client/link-relay-transport.ts:240`); the existing parity reporter is a +bounded Child-to-Home POST example (`src/client/link-home.ts:344`). These are +transport precedents, not update authorization. In particular, the Home +management relay remains a separate read-only allowlist. + +Proposed exchange uses two exact Home link-listener routes, both POST with no +query, upgrade or redirects: `/v1/link-update/poll` and +`/v1/link-update/result`. Add an update-specific route predicate and dispatch +sibling; do not add either route to `link-management` or the Child's local data +ingress. Before the handler, retain the current link-key admission and require +its configured key ID to match the current link record. The handler then +verifies the separately enrolled destination response key and grant/binding +epochs from `060`; link-key possession alone cannot select or acknowledge an +operation. Unknown route, old peer, missing grant, revoked binding, stale key or +unreadable state returns unavailable and causes no update effect. + +`ocx.link-update.poll/1` contains `requestId`, random `nonce`, `issuedAt`, +`notAfter`, `childId`, `installationId`, `linkId`, `linkBindingEpoch`, +`grantId`, `grantEpoch` and the latest observed operation ID/revision or null. +The destination signs the exact bytes with its enrolled response key using a +separate poll domain; the bounded envelope follows `060`. A valid response is +`ocx.link-update.poll-result/1` with the poll request digest and nonce, +destination/grant bindings, server time and either null or one already journaled +Home-signed `ocx.link-update.envelope/1`. The Home signs the exact response +bytes with its enrolled update key. The Child verifies the response, then the +contained request's independent Home signature, action, expiry, local grant, +policy, exact candidate and current binding before recording or performing it. +The Home may not use the poll response to widen the destination grant. + +`/result` carries a destination-signed `ocx.link-update.result/1` from `060`, +including the originating request digest, nonce, operation and revision; the +Home stores it only after signature, admitted key, current binding and journal +intent all match. Repeated identical results are idempotent; a conflicting +revision is refused. Return only a bounded acknowledgement bound to that result +digest. Limit each envelope and response to 64 KiB, decoded payload to 32 KiB, +input/read time to five seconds, and signed request validity to five minutes. +No endpoint returns local paths, credentials or arbitrary execution commands. + +The destination poller starts only for an active Child-initiated connection +with a locally enabled grant. Use one in-flight poll, a 30-second normal +interval and bounded 5/15/30/60-second retry backoff; stop on disconnect, runtime +shutdown or revoked grant. Reconnect first reconciles its durable operation and +binding before polling again. A lost poll response is retried with a fresh poll +nonce; a delivered operation is deduplicated by its journal identity, not +re-executed. Accepted installation work is handed to the same destination-owned +worker and recovery contract as `060`, independent of the tunnel lifetime. +No status changes to healthy until the destination observes the exact installed +target and owned serving runtime. Exact worker startup and platform survival +remain a proof requirement, especially for Windows channel containment. + +| Operation | Proposed path | Required change | +| --- | --- | --- | +| NEW | `src/link/update-exchange.ts`, `src/client/link-update-poller.ts` | Dedicated authenticated POST poll/result exchange and Child-owned bounded poller. The poll reads only a previously journaled request; result publication uses its own authorized operation, not management relay writes. | +| MODIFY | `src/server/index/optional-listeners.ts`, `src/server/index/serve-options.ts` (extract an owned sibling if ratcheted), `src/remote/features.ts` | Admit the two exact exchange paths only on the authenticated Home link listener, dispatch with the configured key identity and advertise the capability only when implemented. Preserve existing connection-bound relay authentication and passive-read routes. Unknown peers and absent grants remain unavailable. | +| MODIFY | Destination and fleet journals from `060` | Persist request intent and outcome across Home/Child restart; reconcile the same operation after response loss, expiry or reconnect. Recheck binding epochs, local policy and owner before commit. | +| MODIFY | `src/server/management/link-update-routes.ts`, `gui/src/remote-link-update-api.ts`, `gui/src/components/remote-link-update-panel.tsx` | Project Child-pull operations through the same `060` versioned dashboard status/action/readback DTOs; add old-peer, disconnect, reconnect, Retry A→B with lost reply and uncertain-result cases without granting the passive relay write authority. | +| NEW | `tests/clients/link-update-child-initiated.test.ts`, `tests/server/link-update-exchange.test.ts` | Isolated linked homes, fake transports and signed test artifacts: no grant, stale link, duplicate delivery, lost responses, busy/unknown runtime, cancellation, crash recovery and separate sync results. Register both domain files in the two test-layout maps. | +| MODIFY | `structure/remote-link.md`, `structure/remote-messaging.md`, relevant user docs and all affected translations | Record implemented transport, policy, prerequisites and actionable unsupported cases. | + +## Activation and evidence + +Prove that a Child with no locally approved grant receives no installation +authority, that Home cannot change Child policy, and that duplicate or late +requests cannot start a second install. A signed exact candidate and future +compatibility proof are necessary but not sufficient: the Child independently +rechecks its own owner, current policy and idle reservation. A reconnect or +credential change invalidates stale operation bindings. Network loss leaves +accepted work under its destination-owned recovery; status is not reported +healthy until exact target and runtime health are observed. + +Use fake links, isolated homes, test keys and a local mock feed. Run failing- +first focused protocol, grant, replay and recovery tests; then typecheck, +privacy/structure, Lab boundary, layout and exact-head CI. Obtain a separate +independent security PASS. The exchange uses the `060` `U → O → A → N → L → C +→ J` order: poll/result network I/O holds none of those locks; the destination +checks and commits journal/binding state in short transactions and reacquires +activation authority before mutation. This proposed order and destination +worker survival still require call-graph, crash and platform proof before audit. + +Baseline on 2026-11-07: `bun test tests/server/sidebar-routes.test.ts +tests/server/link-management-relay.test.ts` passed 31 tests (exit 0). The relay +suite starts isolated loopback listeners and verifies that existing management +reads remain passive and reject writes. It does not exercise the proposed +update exchange. The two new test files in the file map do not exist yet; run +them with `bun test tests/clients/link-update-child-initiated.test.ts +tests/server/link-update-exchange.test.ts` only after creating and registering +them, and record initial red and final green separately. diff --git a/devlog/_plan/261107_auto_update_parity/090_pnpm_updates.md b/devlog/_plan/261107_auto_update_parity/090_pnpm_updates.md new file mode 100644 index 00000000000..81c1f9f3720 --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/090_pnpm_updates.md @@ -0,0 +1,111 @@ +# Signed pnpm-owned updates — draft unit + +**Status:** follows the common signed supply, idle admission and npm-owned +stage/recovery work. The existing pnpm updater mutates its selected global +owner through pnpm and uses pnpm again for rollback +(`src/update/pnpm-global-install.mjs:464`, `:513`, `:564`). A signed npm-shaped +tree cannot be renamed into pnpm's virtual store and treated as pnpm ownership. + +## Proposed implementation slice + +1. Add `src/update/pnpm-prepared-install.mjs` and declaration sibling. Resolve + the existing `PnpmGlobalOwner`, its global root, bin root, virtual-store and + lock inputs through the existing owner helpers; refuse ambiguous or changed + ownership. Bind those facts and the exact signed candidate to an owner-held + operation record. +2. Build a disposable pnpm global layout from the verified local signed + dependency closure with lifecycle scripts disabled and network unavailable. + Compare all resulting package/store entries and generated bin links against + the signed inventory and the selected owner. Never write to the live global + group during preparation. The exact pnpm invocation and relocatable layout + are an explicit experiment and audit blocker, not a presumed supported flag. +3. Before activation, reacquire the existing sync/update and installation + ownership leases, revalidate policy, stage and selected pnpm owner, then use + the `020` update-stop reservation. Use a manager-mediated selected-owner + transition, journaled before each operation; do not describe it as an atomic + group/bin swap. Bind and verify the generated shims, selected final store, + complete publisher inventory and process exit before declaring installation. + Keep signed previous archives, store identity and metadata for recovery until + target health and probation complete. +4. Extend `src/update/orchestrated-pnpm.mjs` and the automatic coordinator with + a separately versioned prepared operation; preserve the existing explicit + pnpm command and strict output schemas while requiring verified supply. + Unsupported versions/layouts refuse + with an actionable state rather than falling back to an online install. + +Modify `tests/update/update-pnpm.test.ts` and add domain-registered +`tests/update/update-pnpm-prepared.test.ts` plus any required platform fixture. +Use temporary global roots, a local test key, fake or isolated manager process +and network-denial assertions. Exercise missing/altered artifacts, lifecycle +script refusal, symlinks/shims, changed global owner, uncertain process exit, +concurrent sync, crash before/after group transition, verified rollback and +health. No test touches the real global installation. + +Update `structure/ops/service-and-sidecars.md`, other mapped owners and user +docs/translations. Run red-to-green focused tests, typecheck, privacy/structure, +test-layout/file-size and Lab boundary checks, relevant native/CI coverage, +and a separate independent security PASS. Actual supported pnpm versions, +offline preparation command, platform layout, writer exclusion and durable +manager-mediated transition must be proved before automatic activation. + +## Isolated feasibility observation + +On 2026-11-07, the host's pnpm reported `12.18.0`. A macOS `sandbox-exec` +fixture denied network and writes outside its private temporary root; separate +probes confirmed those denials. Adding a local inert fixture with +`--global --ignore-scripts --ignore-pnpmfile` and a fixture-owned store did not +run its postinstall. The first attempt refused because its isolated bin path +was not on `PATH`; after correcting that path, pnpm exited 1 with +`ERR_PNPM_STORE_DIR_OPEN_OPERATION_LOCK` / `Operation not permitted`, including +when the fixture state directory was supplied. No real global install was +touched. This shows only that this first sandbox configuration did not complete +the operation; it does **not** establish a pnpm defect or prove pnpm cannot +stage offline. A later run with fixture-owned `XDG_RUNTIME_DIR`, store and state +paths exited 0 without running the postinstall. The decisive configuration +change and original lock location were not established. + +A separate probe used the already-installed pnpm `11.10.0` directly, with a +fresh fixture-owned global home/store, `--global --offline --ignore-scripts +--ignore-pnpmfile`, and the same network/outside-write sandbox. It exited 0, +and the inert fixture's postinstall sentinel remained absent. The resulting +global group contained a package symlink into the separate fixture store and +generated bin files. This is positive evidence for one local no-dependency +fixture only: it does not establish relocatability, signed dependency closure, +atomic live-group activation or recovery. A further pnpm 11 fixture changed +versions 1.0.0 → 1.1.0 → 1.0.0 offline with the sentinel absent. Copying its +global home without the separate store broke the package link; its generated +bin script still pointed into the original fixture. These observations do not +prove a safe relocation or a crash-safe live update. + +Pre-audit research investigated a manager-supported transition and recovery +with a locally signed dependency fixture. Exact commands, publisher-signed +versus manager-generated bytes, store/bin ownership, interruption and cleanup +evidence are retained under `.tmp/`; no real install was touched. + +The follow-up isolated investigation on macOS arm64 with pnpm 11.10.0 used a +signed local two-package fixture, a private store kept at its final path and a +selected-owner offline manager re-add. Preparation, activation and restoration +completed in that fixture; three controlled process interruptions exposed +intermediate group/bin states and the previous signed fixture was subsequently +restored. This selects manager-mediated re-add plus a durable owner-held journal +as the implementation direction, **not** an atomic switch or proof of safe +production activation. Bind exact signed prior/candidate archives and store, +global and bin identities, recheck policy/owner/idle, prove process-tree exit, +verify the complete installed graph and generated wrappers before any candidate +execution, and reconcile every interrupted transition before another installer. +Require installation-scoped exclusion from `020`, safe owned cleanup, verified +recovery, real OpenCodex executable closure and platform/version tests. No +unproven layout is automatically eligible; the detailed negative evidence +remains in the private research packet. + +For the observed pnpm 11.10.0 fixture, classify the global manifest, lock, +`.modules.yaml`, manager index and global/internal bin wrappers as generated +state, separate from signed package files. The adapter permits only the +version-specific schema and exact wrapper templates it has tested, with each +resolved command and symlink bound to the selected final store and signed +payload. Other pnpm versions, store formats, wrapper forms or platforms remain +unavailable until their own fixtures prove the same contract. Persist the +validated generated-state digest for drift/recovery readback; do not accept +unknown files merely because they are under the store. Test changed metadata, +unexpected executable/link, owner path changes and manager-specific recovery +without executing candidate code until the full output verifies. diff --git a/devlog/_plan/261107_auto_update_parity/100_bun_updates.md b/devlog/_plan/261107_auto_update_parity/100_bun_updates.md new file mode 100644 index 00000000000..0a0f26ba4fb --- /dev/null +++ b/devlog/_plan/261107_auto_update_parity/100_bun_updates.md @@ -0,0 +1,92 @@ +# Signed Bun-owned updates — draft unit + +**Status:** follows the common signed supply, idle admission and npm-owned +stage/recovery work. The current Bun-owned update runs a global add +(`src/update/index.ts:354`); that is not evidence of independently staged, +publisher-verified activation or rollback. + +## Proposed implementation slice + +1. Add `src/update/bun-prepared-install.ts` and an owner record for the selected + Bun global package root, bin links, global manifest/lock state and exact + signed candidate. Use `detectInstallOwnership` and fail closed on unknown, + foreign or changed ownership (`src/update/orchestrated-plan.ts:21`). +2. Materialize the verified signed executable closure into a disposable Bun + global layout with scripts disabled and network denied. Bun's installed + help exposes `--offline` and `--ignore-scripts`, but the exact invocation, + global metadata behavior and relocation semantics must be proven in isolated + fixtures before they are claimed as supported. Validate every installed file + and link against signed inventory; preparation must not write to the live + global tree or execute a downloaded helper. +3. At activation reacquire the existing home sync/update and installation + ownership leases, revalidate stage, policy and owner, then obtain the `020` + idle update-stop reservation. Journal a manager-mediated selected-root + transition and verify its package, metadata and bin links before execution; + do not claim that the manager changes those files atomically. Retain the + signed previous installation until health and probation complete. +4. Extend `src/update/orchestrated-entry.ts` and the automatic coordinator with + a separately versioned prepared operation. Preserve current explicit update + output and existing ownership/supervisor refusals while requiring verified + supply for installation. Never fall back to an + unverified global add when offline preparation or rollback cannot be proven. + +Add domain-registered `tests/update/update-bun-prepared.test.ts` and use +isolated homes, a signed test closure, fake manager workers and network denial. +Cover changed owner, global lock/bin drift, script and unsigned dependency +refusals, expired stage, interrupted worker, rollback after each mutation, +health readback and concurrent sync. Update `structure/runtime.md`, +`structure/ops/service-and-sidecars.md` and affected user docs/translations. + +Run failing-first focused tests, typecheck, privacy/structure, test-layout and +file-size gates, the Lab boundary test, relevant platform CI and a separate +independent security PASS. Actual Bun global layout, cache isolation, +manager-compatible durable transition and signed rollback remain proof blockers +before this unit can be enabled. + +## Isolated feasibility observation + +On 2026-11-07, Bun `1.4.4` installed an inert local fixture into an isolated +`BUN_INSTALL` root with `--global --offline --ignore-scripts --no-env-file`; +the command exited 0 and the fixture's postinstall sentinel was absent. A +macOS `sandbox-exec` profile denied network and writes outside the temporary +root, and separate probes confirmed those denials. The observed output included +a global manifest/lock, a nested package directory and a relative bin symlink. +This proves only that one local package can be prepared without its lifecycle +script in that fixture. A separate offline fixture round trip changed versions +1.0.0 → 1.1.0 → 1.0.0 with the sentinel absent. Copying the global root +retained an absolute `file:` source in its manifest, so naïve relocation was +not established. These experiments do not prove signed dependency closure, +atomic activation, verified recovery or runtime health. + +Pre-audit research investigated a manager-supported transition and recovery +with a locally signed dependency fixture. Exact commands, publisher-signed +versus manager-generated bytes, root/bin ownership, interruption and cleanup +evidence are retained under `.tmp/`; no real install was touched. + +The follow-up isolated macOS arm64 investigation with Bun 1.4.4 used a signed +local two-package fixture and showed offline selected-owner install and +restoration, plus `--lockfile-only` preparation followed by frozen +materialization. A separate Bun 1.4.3 fixture did not satisfy the selected-root +contract; it does not establish a general supported-version floor. Interrupted +and competing manager operations showed that package, metadata and bin changes +cannot be treated as one atomic transition. The selected direction is a +journaled manager-mediated operation under the installation-scoped exclusion in +`020`, with exact signed prior/candidate inputs, bound root/bin/cache identities, +complete output/link verification before execution and verified recovery. +Resolve custom global roots explicitly, preserve unrelated global packages and +retain operation-owned recovery material through probation. Prove process +termination, every relevant interruption boundary, cross-platform behavior and +cleanup before enabling the owner. A lockfile, successful manager exit or this +fixture is not authentication or crash-safety proof; detailed negative +evidence remains in the private research packet. + +For the observed Bun 1.4.4 fixture, classify global manifest/lock, `.bun-tag`, +cache metadata and bin links as manager-generated state, separate from signed +package files. The adapter accepts only version-specific parsed schemas and +expected link targets bound to the selected root/bin/cache and verified +payload; no unrecognized generated executable, metadata form or escaping link +is accepted. A recorded digest detects later drift but does not turn local +metadata into a publisher signature. Bun 1.4.3 and all untested layouts remain +unavailable until separately proven. Test foreign entries, custom roots, +changed bins, unrelated global packages and interrupted recovery before any +candidate executable is launched. From 9c6f2d3f8e1a05e864128e6156c34dc9f8d03808 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:08:49 +0900 Subject: [PATCH 02/42] Extract offline minisign verification primitives --- desktop/scripts/verify-release-assets.ts | 62 +++---------------- scripts/test-layout/layout.json | 2 +- src/update/minisign.d.mts | 17 ++++++ src/update/minisign.mjs | 78 ++++++++++++++++++++++++ structure/desktop-shell.md | 5 +- structure/runtime.md | 2 +- tests/fixtures/test-layout-expected.json | 2 +- tests/update/update-minisign.test.ts | 39 ++++++++++++ 8 files changed, 149 insertions(+), 58 deletions(-) create mode 100644 src/update/minisign.d.mts create mode 100644 src/update/minisign.mjs create mode 100644 tests/update/update-minisign.test.ts diff --git a/desktop/scripts/verify-release-assets.ts b/desktop/scripts/verify-release-assets.ts index 0c3175791bb..d6845a470b8 100644 --- a/desktop/scripts/verify-release-assets.ts +++ b/desktop/scripts/verify-release-assets.ts @@ -11,9 +11,10 @@ * version and commit before it uploads anything, so publication can only ever * consume the verified bundle. */ -import { createHash, createPublicKey, verify as ed25519Verify, type KeyObject } from "node:crypto"; +import { createHash, type KeyObject } from "node:crypto"; import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs"; import { dirname, join, resolve } from "node:path"; +import { decodePublicKey, verifyLegacyMinisignBytes } from "../../src/update/minisign.mjs"; import { standaloneArchiveName, standaloneTargets as sharedStandaloneTargets, @@ -122,8 +123,6 @@ export function verifyChecksums(dir: string): number { return checksumFiles.length; } -const ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex"); - export interface MinisignPublicKey { keyId: string; publicKey: KeyObject; @@ -146,31 +145,10 @@ function decodeBox(text: string, what: string): string { return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(payload); } -function boxLines(text: string): string[] { - // Accept minisign text with LF or CRLF and an optional terminal newline; - // signatures authenticate decoded bytes/comments, not transport line endings. - return text.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n"); -} - /** minisign public key: base64 of algorithm ("Ed") || key id (8) || raw key (32). */ export function parseMinisignPublicKey(text: string): MinisignPublicKey { - const lines = boxLines(text); - if (lines.length !== 2 || !lines[0]!.startsWith("untrusted comment: ")) { - throw new Error("Malformed minisign public key box"); - } - const payload = decodeBase64(lines[1]!, "minisign public key", 42); - const algorithm = payload.subarray(0, 2).toString("utf8"); - if (algorithm !== "Ed") { - throw new Error(`Unsupported minisign public key algorithm: ${JSON.stringify(algorithm)}`); - } - return { - keyId: payload.subarray(2, 10).toString("hex"), - publicKey: createPublicKey({ - key: Buffer.concat([ED25519_SPKI_PREFIX, payload.subarray(10, 42)]), - format: "der", - type: "spki", - }), - }; + const { keyId, publicKey } = decodePublicKey(text); + return { keyId, publicKey }; } /** The updater public key pinned in the Tauri configuration. */ @@ -187,34 +165,10 @@ export function loadUpdaterPublicKey(tauriConfPath: string): MinisignPublicKey { export function verifyUpdaterSignature(filePath: string, key: MinisignPublicKey): void { const signaturePath = `${filePath}.sig`; if (!existsSync(signaturePath)) throw new Error(`Missing signature: ${signaturePath}`); - const lines = boxLines(decodeBox(readFileSync(signaturePath, "utf8"), "Tauri signature")); - const trustedPrefix = "trusted comment: "; - if (lines.length !== 4 || !lines[0]!.startsWith("untrusted comment: ") - || !lines[2]!.startsWith(trustedPrefix)) { - throw new Error(`Malformed signature box in ${signaturePath}`); - } - const payload = decodeBase64(lines[1]!, "signature packet", 74); - const globalSignature = decodeBase64(lines[3]!, "comment signature", 64); - const algorithm = payload.subarray(0, 2).toString("utf8"); - if (algorithm !== "ED") { - throw new Error(`Unsupported signature algorithm in ${signaturePath}: ${JSON.stringify(algorithm)}`); - } - const keyId = payload.subarray(2, 10).toString("hex"); - if (keyId !== key.keyId) { - throw new Error(`Signature ${signaturePath} was made by key ${keyId}, not the pinned updater key ${key.keyId}`); - } - const signature = payload.subarray(10, 74); - // ED is ordinary Ed25519 over the BLAKE2b-512 digest, not Ed25519ph. - const digest = createHash("blake2b512").update(readFileSync(filePath)).digest(); - if (!ed25519Verify(null, digest, key.publicKey, signature)) { - throw new Error(`Signature verification failed for ${filePath}`); - } - // minisign signs the raw signature + trimmed trusted comment, without its - // prefix or line terminator. The original filename may differ after collection. - const trustedComment = lines[2]!.slice(trustedPrefix.length).trim(); - const message = Buffer.concat([signature, Buffer.from(trustedComment, "utf8")]); - if (!ed25519Verify(null, message, key.publicKey, globalSignature)) { - throw new Error(`Comment signature verification failed for ${filePath}`); + try { + verifyLegacyMinisignBytes(readFileSync(filePath), readFileSync(signaturePath, "utf8"), key); + } catch (error) { + throw new Error(`${error instanceof Error ? error.message : String(error)}: ${filePath}`); } } diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json index 3340ce9167d..b9e5458fd04 100644 --- a/scripts/test-layout/layout.json +++ b/scripts/test-layout/layout.json @@ -1837,7 +1837,7 @@ "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", "update-async-routes.test.ts": "server", - "update-badge.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", + "update-badge.test.ts": "update", "update-minisign.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", "update-standalone.test.ts": "update", "update-worker-launch.test.ts": "update", "update-notify.test.ts": "update", "update-npm-cache-preflight.test.ts": "update", diff --git a/src/update/minisign.d.mts b/src/update/minisign.d.mts new file mode 100644 index 00000000000..1b21015d483 --- /dev/null +++ b/src/update/minisign.d.mts @@ -0,0 +1,17 @@ +import type { KeyObject } from "node:crypto"; + +export interface MinisignKey { + keyId: string; + publicKey: KeyObject; + fingerprint: string; +} + +export interface MinisignVerification { + keyId: string; + fingerprint: string; + trustedComment: string; +} + +export function decodePublicKey(text: string): MinisignKey; +export function verifyMinisignBytes(bytes: Uint8Array, signatureBox: string, key: MinisignKey): MinisignVerification; +export function verifyLegacyMinisignBytes(bytes: Uint8Array, signatureBox: string, key: Pick): Omit; diff --git a/src/update/minisign.mjs b/src/update/minisign.mjs new file mode 100644 index 00000000000..256e07084f4 --- /dev/null +++ b/src/update/minisign.mjs @@ -0,0 +1,78 @@ +// Offline minisign primitives. These results prove only cryptographic validity; +// update authority is assigned separately by the signed-supply policy. +import { createHash, createPublicKey, verify } from "node:crypto"; + +const ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex"); +const TRUSTED_PREFIX = "trusted comment: "; + +function decodeBase64(text, what, expectedBytes) { + const payload = Buffer.from(text, "base64"); + if (!text || payload.toString("base64") !== text + || (expectedBytes !== undefined && payload.length !== expectedBytes)) { + throw new Error(`Malformed ${what}: invalid base64 or decoded length`); + } + return payload; +} + +function boxLines(text) { + return text.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n"); +} + +/** Decode the text form of a minisign public key; this does not establish trust. */ +export function decodePublicKey(text) { + const lines = boxLines(text); + if (lines.length !== 2 || !lines[0].startsWith("untrusted comment: ")) { + throw new Error("Malformed minisign public key box"); + } + const packet = decodeBase64(lines[1], "minisign public key", 42); + const algorithm = packet.subarray(0, 2).toString("utf8"); + if (algorithm !== "Ed") { + throw new Error(`Unsupported minisign public key algorithm: ${JSON.stringify(algorithm)}`); + } + const raw = packet.subarray(10); + return Object.freeze({ + keyId: packet.subarray(2, 10).toString("hex"), + publicKey: createPublicKey({ key: Buffer.concat([ED25519_SPKI_PREFIX, raw]), format: "der", type: "spki" }), + fingerprint: createHash("sha256").update(raw).digest("hex"), + }); +} + +function verifyBox(bytes, signatureBox, key, legacy) { + // The historical release adapter accepts surrounding transport whitespace. + const outer = legacy ? signatureBox.trim() : signatureBox; + if (!legacy && outer.length > 5464) throw new Error("Malformed Tauri signature: box exceeds limit"); + const encoded = decodeBase64(outer, "Tauri signature"); + if (!legacy && encoded.length > 4096) throw new Error("Malformed Tauri signature: box exceeds limit"); + const text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(encoded); + const lines = boxLines(text); + if (lines.length !== 4 || !lines[0].startsWith("untrusted comment: ") + || !lines[2].startsWith(TRUSTED_PREFIX)) { + throw new Error("Malformed signature box"); + } + const packet = decodeBase64(lines[1], "signature packet", 74); + const commentSignature = decodeBase64(lines[3], "comment signature", 64); + const algorithm = packet.subarray(0, 2).toString("utf8"); + if (algorithm !== "ED") throw new Error(`Unsupported signature algorithm: ${JSON.stringify(algorithm)}`); + const keyId = packet.subarray(2, 10).toString("hex"); + if (keyId !== key.keyId) throw new Error(`Signature was made by key ${keyId}, not the pinned updater key ${key.keyId}`); + const signature = packet.subarray(10); + const digest = createHash("blake2b512").update(bytes).digest(); + if (!verify(null, digest, key.publicKey, signature)) throw new Error("Signature verification failed"); + const exactComment = lines[2].slice(TRUSTED_PREFIX.length); + const trustedComment = legacy ? exactComment.trim() : exactComment; + const message = Buffer.concat([signature, Buffer.from(trustedComment, "utf8")]); + if (!verify(null, message, key.publicKey, commentSignature)) throw new Error("Comment signature verification failed"); + const publicKeyDer = key.publicKey.export({ format: "der", type: "spki" }); + const fingerprint = createHash("sha256").update(publicKeyDer.subarray(-32)).digest("hex"); + return { keyId, fingerprint, trustedComment }; +} + +/** Verify both signatures using the exact trusted-comment bytes. */ +export function verifyMinisignBytes(bytes, signatureBox, key) { + return verifyBox(bytes, signatureBox, key, false); +} + +/** Compatibility-only adapter for the existing release verifier's trimmed comment. */ +export function verifyLegacyMinisignBytes(bytes, signatureBox, key) { + return verifyBox(bytes, signatureBox, key, true); +} diff --git a/structure/desktop-shell.md b/structure/desktop-shell.md index 38810c5ed0f..ed34984bbbf 100644 --- a/structure/desktop-shell.md +++ b/structure/desktop-shell.md @@ -420,7 +420,10 @@ packaging matrices, verifies every checksum and every updater signature, and wri platforms to have updater signatures. Publication waits for that verification, and the attachment job uploads the verified bundle only after the verification receipt names the same version and commit. -Updater signature verification decodes Tauri’s outer-base64 minisign box, checks the +Updater signature verification uses the shared offline minisign primitive in +`src/update/minisign.mjs`. Its release adapter preserves the existing trimmed +trusted-comment convention; the strict primitive verifies exact comment bytes +and grants no update or installation authority by itself. It decodes Tauri’s outer-base64 minisign box, checks the `ED` signature over the BLAKE2b-512 digest against the pinned key, and verifies the trusted-comment signature. Missing or malformed fields fail before publication. On macOS, in-app updates download `OpenCodex--macos.app.tar.gz`; the DMG is for diff --git a/structure/runtime.md b/structure/runtime.md index 49502bec379..d78c36d7030 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` verifies offline signature bytes without granting update authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json index 6c4a07b0bf2..4f19b83189d 100644 --- a/tests/fixtures/test-layout-expected.json +++ b/tests/fixtures/test-layout-expected.json @@ -1442,7 +1442,7 @@ "types-barrel-identity.test.ts": "config", "ultrafast-tier-honesty.test.ts": "codex-integration", "configured-ultrafast-picker.test.ts": "codex-integration", "ultrafast-live-catalog.test.ts": "codex-integration", "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", - "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", + "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-minisign.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", diff --git a/tests/update/update-minisign.test.ts b/tests/update/update-minisign.test.ts new file mode 100644 index 00000000000..801b3489281 --- /dev/null +++ b/tests/update/update-minisign.test.ts @@ -0,0 +1,39 @@ +import { describe, expect, test } from "bun:test"; +import { createHash, generateKeyPairSync, sign } from "node:crypto"; +import { readFileSync } from "node:fs"; +import { repoPath } from "../helpers/repo-root"; +import { decodePublicKey, verifyMinisignBytes, verifyLegacyMinisignBytes } from "../../src/update/minisign.mjs"; + +describe("offline minisign verification", () => { + test("accepts the independent upstream prehashed vector and rejects changed bytes", () => { + const fixture = JSON.parse(readFileSync(repoPath("tests/fixtures/minisign/prehashed-vector.json"), "utf8")); + const key = decodePublicKey(`untrusted comment: upstream key\n${fixture.publicKeyBase64}\n`); + const box = Buffer.from(fixture.signatureBox).toString("base64"); + expect(verifyMinisignBytes(Buffer.from(fixture.payload), box, key).keyId).toBe(key.keyId); + expect(() => verifyMinisignBytes(Buffer.from("altered"), box, key)).toThrow(/Signature verification failed/); + }); + + test("strict comment bytes and legacy normalization are separate", () => { + const { publicKey, privateKey } = generateKeyPairSync("ed25519"); + const raw = Buffer.from(publicKey.export({ format: "der", type: "spki" })).subarray(-32); + const id = Buffer.from("0123456789abcdef", "hex"); + const key = decodePublicKey(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), id, raw]).toString("base64")}\n`); + const bytes = Buffer.from("fixture payload"); + const signature = sign(null, createHash("blake2b512").update(bytes).digest(), privateKey); + const packet = Buffer.concat([Buffer.from("ED"), id, signature]).toString("base64"); + const comment = " version:1.2.3\t"; + const makeBox = (signedComment: string, newline: string) => { + const global = sign(null, Buffer.concat([signature, Buffer.from(signedComment)]), privateKey).toString("base64"); + return Buffer.from(["untrusted comment: fixture", packet, `trusted comment: ${comment}`, global, ""].join(newline)).toString("base64"); + }; + const exact = makeBox(comment, "\r\n"); + const normalized = makeBox(comment.trim(), "\n"); + expect(verifyMinisignBytes(bytes, exact, key).trustedComment).toBe(comment); + expect(() => verifyLegacyMinisignBytes(bytes, exact, key)).toThrow(/Comment signature verification failed/); + expect(() => verifyMinisignBytes(bytes, normalized, key)).toThrow(/Comment signature verification failed/); + expect(verifyLegacyMinisignBytes(bytes, normalized, key).trustedComment).toBe(comment.trim()); + expect(() => verifyMinisignBytes(bytes, `${exact}!`, key)).toThrow(/base64/); + expect(verifyMinisignBytes(bytes, exact, { ...key, fingerprint: "0".repeat(64) }).fingerprint).toBe(key.fingerprint); + expect(() => verifyMinisignBytes(bytes, "A".repeat(5468), key)).toThrow(/exceeds limit/); + }); +}); From d7a6d1f8184d122cbce61a786326ff7c3df7ccd1 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:10:49 +0900 Subject: [PATCH 03/42] Generate proposed update trust root from pinned key --- desktop/src-tauri/update-trust-root.json | 38 ++++++++++++++++ scripts/generate-update-trust-root.ts | 56 ++++++++++++++++++++++++ scripts/test-layout/layout.json | 2 +- src/update/trust-root.json | 38 ++++++++++++++++ structure/desktop-shell.md | 4 ++ tests/fixtures/test-layout-expected.json | 2 +- tests/update/update-trust-root.test.ts | 29 ++++++++++++ 7 files changed, 167 insertions(+), 2 deletions(-) create mode 100644 desktop/src-tauri/update-trust-root.json create mode 100644 scripts/generate-update-trust-root.ts create mode 100644 src/update/trust-root.json create mode 100644 tests/update/update-trust-root.test.ts diff --git a/desktop/src-tauri/update-trust-root.json b/desktop/src-tauri/update-trust-root.json new file mode 100644 index 00000000000..94bcccfa837 --- /dev/null +++ b/desktop/src-tauri/update-trust-root.json @@ -0,0 +1,38 @@ +{ + "schema": "ocx.update.root/1", + "revision": 1, + "expiresAt": "2028-11-07T00:00:00Z", + "rootKeys": [ + { + "keyId": "eae4c0180e8ca39a844b3c0e1ec28842261e85628d6dee77ceff5dd081853799", + "algorithm": "minisign-ed25519-blake2b512/1", + "publicKey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEFDNzZCMDg0NkVCRUJGODEKUldTQnY3NXVoTEIyckhRUXJMOXJRUDR0aHQ2L3pLVHVweXFSc1lzS24vWDNiSUJ5MXJIZmpyb2sK" + } + ], + "rootThreshold": 1, + "releaseKeys": [ + { + "keyId": "eae4c0180e8ca39a844b3c0e1ec28842261e85628d6dee77ceff5dd081853799", + "algorithm": "minisign-ed25519-blake2b512/1", + "publicKey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEFDNzZCMDg0NkVCRUJGODEKUldTQnY3NXVoTEIyckhRUXJMOXJRUDR0aHQ2L3pLVHVweXFSc1lzS24vWDNiSUJ5MXJIZmpyb2sK", + "channels": [ + "latest", + "preview", + "nightly" + ], + "roles": [ + "release", + "tree", + "desktop-artifact", + "standalone-artifact", + "guardian-artifact" + ] + } + ], + "releaseThreshold": 1, + "channels": [ + "latest", + "preview", + "nightly" + ] +} diff --git a/scripts/generate-update-trust-root.ts b/scripts/generate-update-trust-root.ts new file mode 100644 index 00000000000..d210f57dcc1 --- /dev/null +++ b/scripts/generate-update-trust-root.ts @@ -0,0 +1,56 @@ +/** Generate the offline update root from the already-pinned Tauri public key. */ +import { readFileSync, renameSync, writeFileSync } from "node:fs"; +import { dirname, resolve } from "node:path"; +import { fileURLToPath } from "node:url"; +import { decodePublicKey } from "../src/update/minisign.mjs"; + +const repo = resolve(dirname(fileURLToPath(import.meta.url)), ".."); +const configPath = resolve(repo, "desktop/src-tauri/tauri.conf.json"); +const outputs = [ + resolve(repo, "src/update/trust-root.json"), + resolve(repo, "desktop/src-tauri/update-trust-root.json"), +]; +const channels = ["latest", "preview", "nightly"]; +const roles = ["release", "tree", "desktop-artifact", "standalone-artifact", "guardian-artifact"]; + +export function generateUpdateTrustRoot(config: unknown): string { + const box = (config as { plugins?: { updater?: { pubkey?: unknown } } })?.plugins?.updater?.pubkey; + if (typeof box !== "string" || !box || box.length > 4096) throw new Error("Invalid pinned updater public key"); + const encoded = Buffer.from(box, "base64"); + if (encoded.toString("base64") !== box) throw new Error("Updater public key must be canonical base64"); + const text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(encoded); + const key = decodePublicKey(text); + const entry = { keyId: key.fingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey: box }; + return `${JSON.stringify({ + schema: "ocx.update.root/1", + revision: 1, + expiresAt: "2028-11-07T00:00:00Z", + rootKeys: [entry], + rootThreshold: 1, + releaseKeys: [{ ...entry, channels, roles }], + releaseThreshold: 1, + channels, + }, null, 2)}\n`; +} + +function main(): void { + const expected = generateUpdateTrustRoot(JSON.parse(readFileSync(configPath, "utf8"))); + if (process.argv.slice(2).some((arg) => arg !== "--check") || process.argv.slice(2).length > 1) { + throw new Error("Usage: generate-update-trust-root.ts [--check]"); + } + if (process.argv[2] === "--check") { + for (const output of outputs) { + if (readFileSync(output, "utf8") !== expected) throw new Error("Generated update trust root is out of date"); + } + process.stdout.write("Generated update trust roots match the pinned public key\n"); + return; + } + for (const output of outputs) { + const temporary = `${output}.${process.pid}.tmp`; + writeFileSync(temporary, expected, { flag: "wx" }); + renameSync(temporary, output); + } + process.stdout.write("Generated update trust roots\n"); +} + +if (import.meta.main) main(); diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json index b9e5458fd04..fdabea8b5d1 100644 --- a/scripts/test-layout/layout.json +++ b/scripts/test-layout/layout.json @@ -1837,7 +1837,7 @@ "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", "update-async-routes.test.ts": "server", - "update-badge.test.ts": "update", "update-minisign.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", + "update-badge.test.ts": "update", "update-minisign.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", "update-standalone.test.ts": "update", "update-worker-launch.test.ts": "update", "update-notify.test.ts": "update", "update-npm-cache-preflight.test.ts": "update", diff --git a/src/update/trust-root.json b/src/update/trust-root.json new file mode 100644 index 00000000000..94bcccfa837 --- /dev/null +++ b/src/update/trust-root.json @@ -0,0 +1,38 @@ +{ + "schema": "ocx.update.root/1", + "revision": 1, + "expiresAt": "2028-11-07T00:00:00Z", + "rootKeys": [ + { + "keyId": "eae4c0180e8ca39a844b3c0e1ec28842261e85628d6dee77ceff5dd081853799", + "algorithm": "minisign-ed25519-blake2b512/1", + "publicKey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEFDNzZCMDg0NkVCRUJGODEKUldTQnY3NXVoTEIyckhRUXJMOXJRUDR0aHQ2L3pLVHVweXFSc1lzS24vWDNiSUJ5MXJIZmpyb2sK" + } + ], + "rootThreshold": 1, + "releaseKeys": [ + { + "keyId": "eae4c0180e8ca39a844b3c0e1ec28842261e85628d6dee77ceff5dd081853799", + "algorithm": "minisign-ed25519-blake2b512/1", + "publicKey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEFDNzZCMDg0NkVCRUJGODEKUldTQnY3NXVoTEIyckhRUXJMOXJRUDR0aHQ2L3pLVHVweXFSc1lzS24vWDNiSUJ5MXJIZmpyb2sK", + "channels": [ + "latest", + "preview", + "nightly" + ], + "roles": [ + "release", + "tree", + "desktop-artifact", + "standalone-artifact", + "guardian-artifact" + ] + } + ], + "releaseThreshold": 1, + "channels": [ + "latest", + "preview", + "nightly" + ] +} diff --git a/structure/desktop-shell.md b/structure/desktop-shell.md index ed34984bbbf..f80585f41ae 100644 --- a/structure/desktop-shell.md +++ b/structure/desktop-shell.md @@ -426,6 +426,10 @@ trusted-comment convention; the strict primitive verifies exact comment bytes and grants no update or installation authority by itself. It decodes Tauri’s outer-base64 minisign box, checks the `ED` signature over the BLAKE2b-512 digest against the pinned key, and verifies the trusted-comment signature. Missing or malformed fields fail before publication. +`scripts/generate-update-trust-root.ts` derives identical offline root files at +`src/update/trust-root.json` and `desktop/src-tauri/update-trust-root.json` from +the pinned public key; `--check` detects drift. These files do not yet authorize +updates or change the Tauri updater's existing trust configuration. On macOS, in-app updates download `OpenCodex--macos.app.tar.gz`; the DMG is for the first installation. diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json index 4f19b83189d..4a89f367ced 100644 --- a/tests/fixtures/test-layout-expected.json +++ b/tests/fixtures/test-layout-expected.json @@ -1442,7 +1442,7 @@ "types-barrel-identity.test.ts": "config", "ultrafast-tier-honesty.test.ts": "codex-integration", "configured-ultrafast-picker.test.ts": "codex-integration", "ultrafast-live-catalog.test.ts": "codex-integration", "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", - "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-minisign.test.ts": "update", + "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-minisign.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", diff --git a/tests/update/update-trust-root.test.ts b/tests/update/update-trust-root.test.ts new file mode 100644 index 00000000000..70b5396c36a --- /dev/null +++ b/tests/update/update-trust-root.test.ts @@ -0,0 +1,29 @@ +import { describe, expect, test } from "bun:test"; +import { readFileSync } from "node:fs"; +import { repoPath } from "../helpers/repo-root"; +import { generateUpdateTrustRoot } from "../../scripts/generate-update-trust-root"; +import { decodePublicKey } from "../../src/update/minisign.mjs"; + +describe("generated update trust root", () => { + test("uses the pinned updater public key and generates identical resource bytes", () => { + const config = JSON.parse(readFileSync(repoPath("desktop/src-tauri/tauri.conf.json"), "utf8")); + const generated = generateUpdateTrustRoot(config); + const root = JSON.parse(generated); + const publicBox: string = config.plugins.updater.pubkey; + const key = decodePublicKey(Buffer.from(publicBox, "base64").toString("utf8")); + expect(root.schema).toBe("ocx.update.root/1"); + expect(root.revision).toBe(1); + expect(root.rootKeys[0].keyId).toBe(key.fingerprint); + expect(root.rootKeys[0].publicKey).toBe(publicBox); + expect(root.releaseKeys[0].keyId).toBe(key.fingerprint); + expect(root.channels).toEqual(["latest", "preview", "nightly"]); + expect(readFileSync(repoPath("src/update/trust-root.json"), "utf8")).toBe(generated); + expect(readFileSync(repoPath("desktop/src-tauri/update-trust-root.json"), "utf8")).toBe(generated); + }); + + test("rejects absent, malformed and noncanonical public keys", () => { + expect(() => generateUpdateTrustRoot({})).toThrow(); + expect(() => generateUpdateTrustRoot({ plugins: { updater: { pubkey: "!" } } })).toThrow(); + expect(() => generateUpdateTrustRoot({ plugins: { updater: { pubkey: "YQ" } } })).toThrow(); + }); +}); From 312682ab451d1bbf3756b535dff77819fa2d8714 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:12:12 +0900 Subject: [PATCH 04/42] Define signed update candidate identities --- scripts/test-layout/layout.json | 2 +- src/update/update-candidate-id.d.mts | 2 ++ src/update/update-candidate-id.mjs | 23 +++++++++++++++++++++++ structure/runtime.md | 2 +- tests/fixtures/test-layout-expected.json | 2 +- tests/update/update-candidate-id.test.ts | 21 +++++++++++++++++++++ 6 files changed, 49 insertions(+), 3 deletions(-) create mode 100644 src/update/update-candidate-id.d.mts create mode 100644 src/update/update-candidate-id.mjs create mode 100644 tests/update/update-candidate-id.test.ts diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json index fdabea8b5d1..e92cf28ef7c 100644 --- a/scripts/test-layout/layout.json +++ b/scripts/test-layout/layout.json @@ -1837,7 +1837,7 @@ "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", "update-async-routes.test.ts": "server", - "update-badge.test.ts": "update", "update-minisign.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", + "update-badge.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", "update-standalone.test.ts": "update", "update-worker-launch.test.ts": "update", "update-notify.test.ts": "update", "update-npm-cache-preflight.test.ts": "update", diff --git a/src/update/update-candidate-id.d.mts b/src/update/update-candidate-id.d.mts new file mode 100644 index 00000000000..f9b70e1e446 --- /dev/null +++ b/src/update/update-candidate-id.d.mts @@ -0,0 +1,2 @@ +/** A lookup identity only; the value does not grant update authority. */ +export function deriveCandidateId(releaseDigest: string, targetId: string): string; diff --git a/src/update/update-candidate-id.mjs b/src/update/update-candidate-id.mjs new file mode 100644 index 00000000000..24f96bd282f --- /dev/null +++ b/src/update/update-candidate-id.mjs @@ -0,0 +1,23 @@ +import { createHash } from "node:crypto"; + +const DOMAIN = Buffer.from("ocx.update.candidate/1\0", "ascii"); + +/** Derive a lookup identifier; callers must separately verify release and target authority. */ +export function deriveCandidateId(releaseDigest, targetId) { + if (typeof releaseDigest !== "string" || !/^[0-9a-f]{64}$/.test(releaseDigest)) { + throw new Error("Invalid release digest"); + } + if (typeof targetId !== "string" || !/^[A-Za-z0-9._-]{1,128}$/.test(targetId) + || targetId === "." || targetId === "..") { + throw new Error("Invalid target ID"); + } + const target = Buffer.from(targetId, "utf8"); + const length = Buffer.alloc(4); + length.writeUInt32BE(target.length); + return createHash("sha256") + .update(DOMAIN) + .update(Buffer.from(releaseDigest, "hex")) + .update(length) + .update(target) + .digest("hex"); +} diff --git a/structure/runtime.md b/structure/runtime.md index d78c36d7030..212b8da46db 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` verifies offline signature bytes without granting update authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` verifies offline signatures, and `update-candidate-id.mjs` derives lookup identifiers, neither granting update authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json index 4a89f367ced..5fbd3ddf18d 100644 --- a/tests/fixtures/test-layout-expected.json +++ b/tests/fixtures/test-layout-expected.json @@ -1442,7 +1442,7 @@ "types-barrel-identity.test.ts": "config", "ultrafast-tier-honesty.test.ts": "codex-integration", "configured-ultrafast-picker.test.ts": "codex-integration", "ultrafast-live-catalog.test.ts": "codex-integration", "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", - "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-minisign.test.ts": "update", "update-trust-root.test.ts": "update", + "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", diff --git a/tests/update/update-candidate-id.test.ts b/tests/update/update-candidate-id.test.ts new file mode 100644 index 00000000000..541e88a395d --- /dev/null +++ b/tests/update/update-candidate-id.test.ts @@ -0,0 +1,21 @@ +import { describe, expect, test } from "bun:test"; +import { deriveCandidateId } from "../../src/update/update-candidate-id.mjs"; + +describe("signed update candidate identity", () => { + test("matches the specified byte-level golden vector", () => { + expect(deriveCandidateId("00".repeat(32), "linux-x64-npm")) + .toBe("496737c902f9e38cbd89b81b0ba6935e245a026f4d0a931904ddd4617eafc7c4"); + }); + + test("binds both release bytes and target and rejects malformed identities", () => { + const original = deriveCandidateId("00".repeat(32), "linux-x64-npm"); + expect(deriveCandidateId("01".repeat(32), "linux-x64-npm")).not.toBe(original); + expect(deriveCandidateId("00".repeat(32), "linux-x64-pnpm")).not.toBe(original); + for (const digest of ["0".repeat(63), "AA".repeat(32), "gg".repeat(32)]) { + expect(() => deriveCandidateId(digest, "linux-x64-npm")).toThrow(); + } + for (const id of ["", "../x", "linux/x64", "é", "x".repeat(129)]) { + expect(() => deriveCandidateId("00".repeat(32), id)).toThrow(); + } + }); +}); From bdf4f11a52bd058e7f4ea39ee7155870edd00d9f Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:18:26 +0900 Subject: [PATCH 05/42] Add bounded unverified update JSON parser --- scripts/test-layout/layout.json | 2 +- src/update/update-bounded-json.d.mts | 4 + src/update/update-bounded-json.mjs | 107 +++++++++++++++++++++++ structure/runtime.md | 2 +- tests/fixtures/test-layout-expected.json | 2 +- tests/update/update-bounded-json.test.ts | 37 ++++++++ 6 files changed, 151 insertions(+), 3 deletions(-) create mode 100644 src/update/update-bounded-json.d.mts create mode 100644 src/update/update-bounded-json.mjs create mode 100644 tests/update/update-bounded-json.test.ts diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json index e92cf28ef7c..274e2a72452 100644 --- a/scripts/test-layout/layout.json +++ b/scripts/test-layout/layout.json @@ -1837,7 +1837,7 @@ "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", "update-async-routes.test.ts": "server", - "update-badge.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", + "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", "update-standalone.test.ts": "update", "update-worker-launch.test.ts": "update", "update-notify.test.ts": "update", "update-npm-cache-preflight.test.ts": "update", diff --git a/src/update/update-bounded-json.d.mts b/src/update/update-bounded-json.d.mts new file mode 100644 index 00000000000..0efcb9a9fc5 --- /dev/null +++ b/src/update/update-bounded-json.d.mts @@ -0,0 +1,4 @@ +export type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue }; + +/** Parses data only: callers must separately validate schema and authority. */ +export function parseBoundedJson(bytes: Uint8Array, maxBytes: number): JsonValue; diff --git a/src/update/update-bounded-json.mjs b/src/update/update-bounded-json.mjs new file mode 100644 index 00000000000..59b2c8cfafc --- /dev/null +++ b/src/update/update-bounded-json.mjs @@ -0,0 +1,107 @@ +// Parsing produces data only. It does not establish schema validity or trust. +const MAX_DOCUMENT_BYTES = 16 * 1024 * 1024; +const MAX_DEPTH = 16; +const MAX_MEMBERS = 32; +const MAX_ITEMS = 4096; +const MAX_TEXT_BYTES = 16384; +const NUMBER = /-?(?:0|[1-9][0-9]*)/y; + +function invalid() { + throw new Error("Invalid bounded update JSON"); +} + +function validUnicode(text) { + for (let i = 0; i < text.length; i++) { + const code = text.charCodeAt(i); + if (code >= 0xd800 && code <= 0xdbff) { + const next = text.charCodeAt(++i); + if (!(next >= 0xdc00 && next <= 0xdfff)) return false; + } else if (code >= 0xdc00 && code <= 0xdfff) return false; + } + return true; +} + +/** Parse bounded UTF-8 JSON, refusing ambiguous names and unsafe numbers. */ +export function parseBoundedJson(bytes, maxBytes) { + if (!(bytes instanceof Uint8Array) || !Number.isSafeInteger(maxBytes) + || maxBytes < 1 || maxBytes > MAX_DOCUMENT_BYTES || bytes.byteLength > maxBytes) invalid(); + let source; + try { + source = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes); + } catch { + invalid(); + } + let offset = 0; + const whitespace = () => { + while (source[offset] === " " || source[offset] === "\n" + || source[offset] === "\r" || source[offset] === "\t") offset++; + }; + const readString = () => { + if (source[offset] !== '"') invalid(); + const start = offset++; + while (offset < source.length) { + const char = source[offset++]; + if (char === '"') { + let result; + try { result = JSON.parse(source.slice(start, offset)); } catch { invalid(); } + if (!validUnicode(result) || Buffer.byteLength(result, "utf8") > MAX_TEXT_BYTES) invalid(); + return result; + } + if (char === "\\") offset++; + else if (char.charCodeAt(0) < 0x20) invalid(); + } + invalid(); + }; + const readValue = (depth) => { + whitespace(); + const first = source[offset]; + if (first === '"') return readString(); + if (first === "{" || first === "[") { + if (depth >= MAX_DEPTH) invalid(); + offset++; + whitespace(); + if (first === "{") { + const result = Object.create(null); + const names = new Set(); + if (source[offset] === "}") { offset++; return result; } + while (true) { + whitespace(); + const key = readString(); + if (names.has(key) || names.size >= MAX_MEMBERS) invalid(); + names.add(key); + whitespace(); + if (source[offset++] !== ":") invalid(); + result[key] = readValue(depth + 1); + whitespace(); + const delimiter = source[offset++]; + if (delimiter === "}") return result; + if (delimiter !== ",") invalid(); + } + } + const result = []; + if (source[offset] === "]") { offset++; return result; } + while (true) { + if (result.length >= MAX_ITEMS) invalid(); + result.push(readValue(depth + 1)); + whitespace(); + const delimiter = source[offset++]; + if (delimiter === "]") return result; + if (delimiter !== ",") invalid(); + } + } + for (const [literal, value] of [["true", true], ["false", false], ["null", null]]) { + if (source.startsWith(literal, offset)) { offset += literal.length; return value; } + } + NUMBER.lastIndex = offset; + const match = NUMBER.exec(source); + if (!match || match[0] === "-0") invalid(); + const number = Number(match[0]); + if (!Number.isSafeInteger(number)) invalid(); + offset = NUMBER.lastIndex; + return number; + }; + const value = readValue(0); + whitespace(); + if (offset !== source.length) invalid(); + return value; +} diff --git a/structure/runtime.md b/structure/runtime.md index 212b8da46db..337c4bac084 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` verifies offline signatures, and `update-candidate-id.mjs` derives lookup identifiers, neither granting update authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` verifies offline signatures, `update-candidate-id.mjs` derives lookup identifiers, and `update-bounded-json.mjs` parses bounded unverified data; none grants update authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json index 5fbd3ddf18d..ecb1fbb2042 100644 --- a/tests/fixtures/test-layout-expected.json +++ b/tests/fixtures/test-layout-expected.json @@ -1442,7 +1442,7 @@ "types-barrel-identity.test.ts": "config", "ultrafast-tier-honesty.test.ts": "codex-integration", "configured-ultrafast-picker.test.ts": "codex-integration", "ultrafast-live-catalog.test.ts": "codex-integration", "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", - "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-trust-root.test.ts": "update", + "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", diff --git a/tests/update/update-bounded-json.test.ts b/tests/update/update-bounded-json.test.ts new file mode 100644 index 00000000000..94555b67fe5 --- /dev/null +++ b/tests/update/update-bounded-json.test.ts @@ -0,0 +1,37 @@ +import { describe, expect, test } from "bun:test"; +import { parseBoundedJson } from "../../src/update/update-bounded-json.mjs"; + +const parse = (text: string, maxBytes = 65536) => parseBoundedJson(Buffer.from(text), maxBytes); + +describe("bounded unverified update JSON", () => { + test("accepts valid values without giving special object keys prototype behavior", () => { + const value = parse('{"name":"value","items":[true,false,null,42],"__proto__":{"x":1}}') as { + name: string; items: unknown[]; __proto__: { x: number }; + }; + expect(value.name).toBe("value"); + expect(value.items).toEqual([true, false, null, 42]); + expect(Object.getPrototypeOf(value)).toBeNull(); + expect(value.__proto__.x).toBe(1); + expect(parse('"\\ud83d\\ude00"')).toBe("😀"); + expect(parse("9007199254740991")).toBe(Number.MAX_SAFE_INTEGER); + expect(parse("-9007199254740991")).toBe(Number.MIN_SAFE_INTEGER); + }); + + test("rejects duplicate decoded names, malformed Unicode, unsafe or noncanonical numbers", () => { + for (const text of [ + '{"a":1,"\\u0061":2}', '{"x":"\\ud800"}', '{"x":"\\udc00"}', + '{"x":9007199254740992}', '{"x":-0}', '{"x":1.0}', '{"x":1e1}', + '{"x":01}', '{"x":true} trailing', '\ufeff{"x":1}', + ]) expect(() => parse(text)).toThrow(); + expect(() => parseBoundedJson(Uint8Array.from([0x7b, 0x22, 0x80, 0x22, 0x7d]), 65536)).toThrow(); + }); + + test("enforces byte, depth, object, array and string limits", () => { + expect(() => parse('{"x":1}', 6)).toThrow(); + expect(() => parse("[".repeat(17) + "0" + "]".repeat(17))).toThrow(); + expect(() => parse(`{${Array.from({ length: 33 }, (_, i) => `"k${i}":0`).join(",")}}`)).toThrow(); + expect(() => parse(`[${Array(4097).fill("0").join(",")}]`)).toThrow(); + expect(() => parse(`"${"x".repeat(16385)}"`)).toThrow(); + expect(parse("[".repeat(16) + "0" + "]".repeat(16))).toBeDefined(); + }); +}); From d61963f91a10c9c88fa94733b66a55a36e06cecf Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:21:39 +0900 Subject: [PATCH 06/42] Bound aggregate update JSON allocations --- src/update/update-bounded-json.mjs | 4 ++++ tests/update/update-bounded-json.test.ts | 15 +++++++++++++++ 2 files changed, 19 insertions(+) diff --git a/src/update/update-bounded-json.mjs b/src/update/update-bounded-json.mjs index 59b2c8cfafc..0ecda3552ca 100644 --- a/src/update/update-bounded-json.mjs +++ b/src/update/update-bounded-json.mjs @@ -4,6 +4,8 @@ const MAX_DEPTH = 16; const MAX_MEMBERS = 32; const MAX_ITEMS = 4096; const MAX_TEXT_BYTES = 16384; +// The six maximal capability arrays require 73,735 values including containers. +const MAX_VALUES = 81920; const NUMBER = /-?(?:0|[1-9][0-9]*)/y; function invalid() { @@ -32,6 +34,7 @@ export function parseBoundedJson(bytes, maxBytes) { invalid(); } let offset = 0; + let values = 0; const whitespace = () => { while (source[offset] === " " || source[offset] === "\n" || source[offset] === "\r" || source[offset] === "\t") offset++; @@ -53,6 +56,7 @@ export function parseBoundedJson(bytes, maxBytes) { invalid(); }; const readValue = (depth) => { + if (++values > MAX_VALUES) invalid(); whitespace(); const first = source[offset]; if (first === '"') return readString(); diff --git a/tests/update/update-bounded-json.test.ts b/tests/update/update-bounded-json.test.ts index 94555b67fe5..6e89e54c17c 100644 --- a/tests/update/update-bounded-json.test.ts +++ b/tests/update/update-bounded-json.test.ts @@ -34,4 +34,19 @@ describe("bounded unverified update JSON", () => { expect(() => parse(`"${"x".repeat(16385)}"`)).toThrow(); expect(parse("[".repeat(16) + "0" + "]".repeat(16))).toBeDefined(); }); + + test("bounds aggregate values while retaining the largest planned capability-array shape", () => { + const entries = Array.from({ length: 4096 }, (_, index) => ({ id: `item-${index}`, version: 1 })); + const capabilityShape = Object.fromEntries( + ["homeProvides", "childRequires", "updateActions", "installerAdapters", "recoveryProtocols", "fleetJournalReaders"] + .map((name) => [name, entries]), + ); + expect(parse(JSON.stringify(capabilityShape), 16777216)).toBeDefined(); + const almostFull = `[${Array(4095).fill("{}").join(",")}]`; + const last = `[${Array(4094).fill("{}").join(",")}]`; + expect(parse(`[${[...Array(19).fill(almostFull), last].join(",")}]`, 16777216)).toBeDefined(); + expect(() => parse(`[${Array(20).fill(almostFull).join(",")}]`, 16777216)).toThrow(); + const group = `[${Array(4096).fill("{}").join(",")}]`; + expect(() => parse(`[${Array(20).fill(group).join(",")}]`, 16777216)).toThrow(); + }); }); From 70b61411ba59cca39d10a9f5adc8d328023cccd4 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:24:51 +0900 Subject: [PATCH 07/42] Compare signed update versions exactly --- scripts/test-layout/layout.json | 2 +- src/update/update-signed-version.d.mts | 2 ++ src/update/update-signed-version.mjs | 18 ++++++++++++++++++ structure/runtime.md | 2 +- tests/fixtures/test-layout-expected.json | 2 +- tests/update/update-signed-version.test.ts | 21 +++++++++++++++++++++ 6 files changed, 44 insertions(+), 3 deletions(-) create mode 100644 src/update/update-signed-version.d.mts create mode 100644 src/update/update-signed-version.mjs create mode 100644 tests/update/update-signed-version.test.ts diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json index 274e2a72452..8d41f68720f 100644 --- a/scripts/test-layout/layout.json +++ b/scripts/test-layout/layout.json @@ -1837,7 +1837,7 @@ "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", "update-async-routes.test.ts": "server", - "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", + "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", "update-standalone.test.ts": "update", "update-worker-launch.test.ts": "update", "update-notify.test.ts": "update", "update-npm-cache-preflight.test.ts": "update", diff --git a/src/update/update-signed-version.d.mts b/src/update/update-signed-version.d.mts new file mode 100644 index 00000000000..db34a2e00d6 --- /dev/null +++ b/src/update/update-signed-version.d.mts @@ -0,0 +1,2 @@ +/** Strict full version equality, including build metadata; this grants no authority. */ +export function sameSignedVersion(releaseVersion: string, signedVersion: string): boolean; diff --git a/src/update/update-signed-version.mjs b/src/update/update-signed-version.mjs new file mode 100644 index 00000000000..c0dc21f76c3 --- /dev/null +++ b/src/update/update-signed-version.mjs @@ -0,0 +1,18 @@ +const MAX_CORE = 18446744073709551615n; +const VERSION = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/; + +function validVersion(value) { + if (typeof value !== "string" || value.length > 64) return false; + const match = VERSION.exec(value); + if (!match || match[0] !== value) return false; + if ([match[1], match[2], match[3]].some((part) => BigInt(part) > MAX_CORE)) return false; + if (match[4]?.split(".").some((part) => /^[0-9]+$/.test(part) && part.length > 1 && part[0] === "0")) return false; + return true; +} + +/** Compare complete signed version identity; no update authority is implied. */ +export function sameSignedVersion(releaseVersion, signedVersion) { + if (!validVersion(releaseVersion) || typeof signedVersion !== "string") return false; + const normalized = signedVersion.startsWith("v") ? signedVersion.slice(1) : signedVersion; + return validVersion(normalized) && releaseVersion === normalized; +} diff --git a/structure/runtime.md b/structure/runtime.md index 337c4bac084..97d14984b1f 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` verifies offline signatures, `update-candidate-id.mjs` derives lookup identifiers, and `update-bounded-json.mjs` parses bounded unverified data; none grants update authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` verifies offline signatures, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded unverified data, and `update-signed-version.mjs` compares full version identity; none grants update authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json index ecb1fbb2042..8ae16408777 100644 --- a/tests/fixtures/test-layout-expected.json +++ b/tests/fixtures/test-layout-expected.json @@ -1442,7 +1442,7 @@ "types-barrel-identity.test.ts": "config", "ultrafast-tier-honesty.test.ts": "codex-integration", "configured-ultrafast-picker.test.ts": "codex-integration", "ultrafast-live-catalog.test.ts": "codex-integration", "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", - "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-trust-root.test.ts": "update", + "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", diff --git a/tests/update/update-signed-version.test.ts b/tests/update/update-signed-version.test.ts new file mode 100644 index 00000000000..4d10c29a244 --- /dev/null +++ b/tests/update/update-signed-version.test.ts @@ -0,0 +1,21 @@ +import { describe, expect, test } from "bun:test"; +import { sameSignedVersion } from "../../src/update/update-signed-version.mjs"; + +describe("signed update version equality", () => { + test("preserves full version identity and permits one signed v prefix", () => { + expect(sameSignedVersion("1.2.3-preview.1+build.7", "v1.2.3-preview.1+build.7")).toBe(true); + expect(sameSignedVersion("1.2.3+one", "1.2.3+two")).toBe(false); + expect(sameSignedVersion("1.2.3-preview.1", "1.2.3-preview.2")).toBe(false); + expect(sameSignedVersion("1.2.3", "vv1.2.3")).toBe(false); + expect(sameSignedVersion("v1.2.3", "1.2.3")).toBe(false); + }); + + test("uses the common lossless core domain and rejects malformed SemVer", () => { + const max = "18446744073709551615.0.0"; + expect(sameSignedVersion(max, `v${max}`)).toBe(true); + for (const bad of ["18446744073709551616.0.0", "01.0.0", "1.2.3-01", "1.2.3+", "1.2.3\n", "1.2.3-ä", "1.2.3-" + "x".repeat(64)]) { + expect(sameSignedVersion(bad, bad)).toBe(false); + expect(sameSignedVersion("1.2.3", bad)).toBe(false); + } + }); +}); From 7c1810107b2bd16c36e2d7782d185e3889674872 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:32:53 +0900 Subject: [PATCH 08/42] Verify offline update signature thresholds --- src/update/update-signature-threshold.d.mts | 12 ++++++ src/update/update-signature-threshold.mjs | 47 +++++++++++++++++++++ structure/runtime.md | 2 +- tests/update/update-minisign.test.ts | 28 ++++++++++++ 4 files changed, 88 insertions(+), 1 deletion(-) create mode 100644 src/update/update-signature-threshold.d.mts create mode 100644 src/update/update-signature-threshold.mjs diff --git a/src/update/update-signature-threshold.d.mts b/src/update/update-signature-threshold.d.mts new file mode 100644 index 00000000000..e320bae230b --- /dev/null +++ b/src/update/update-signature-threshold.d.mts @@ -0,0 +1,12 @@ +export interface SignatureThresholdKey { + keyId: string; + algorithm: string; + publicKey: string; +} + +export interface SignatureThresholdEnvelope { + signatures: { keyFingerprint: string; signatureBox: string }[]; +} + +/** Cryptographic checking only: the caller establishes key authority and policy. */ +export function verifySignatureThreshold(bytes: Uint8Array, envelope: SignatureThresholdEnvelope, keys: SignatureThresholdKey[], threshold: number): void; diff --git a/src/update/update-signature-threshold.mjs b/src/update/update-signature-threshold.mjs new file mode 100644 index 00000000000..1979183547b --- /dev/null +++ b/src/update/update-signature-threshold.mjs @@ -0,0 +1,47 @@ +import { decodePublicKey, verifyMinisignBytes } from "./minisign.mjs"; + +const FINGERPRINT = /^[0-9a-f]{64}$/; + +/** Verify a supplied signer set; callers must separately establish its authority. */ +export function verifySignatureThreshold(bytes, envelope, keys, threshold) { + if (!(bytes instanceof Uint8Array) || !Array.isArray(keys) || keys.length < 1 || keys.length > 16 + || !Number.isSafeInteger(threshold) || threshold < 1 || threshold > keys.length + || !Array.isArray(envelope?.signatures) || envelope.signatures.length < 1 || envelope.signatures.length > 16) { + throw new Error("Invalid signature threshold input"); + } + const authorized = new Map(); + for (const entry of keys) { + if (!entry || typeof entry.keyId !== "string" || !FINGERPRINT.test(entry.keyId) + || entry.algorithm !== "minisign-ed25519-blake2b512/1" || typeof entry.publicKey !== "string" + || !entry.publicKey || entry.publicKey.length > 5464 || authorized.has(entry.keyId)) { + throw new Error("Invalid signature threshold key"); + } + const encoded = Buffer.from(entry.publicKey, "base64"); + if (encoded.length > 4096 || encoded.toString("base64") !== entry.publicKey) { + throw new Error("Invalid signature threshold key encoding"); + } + const text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(encoded); + const key = decodePublicKey(text); + if (key.fingerprint !== entry.keyId) throw new Error("Signature threshold key fingerprint mismatch"); + authorized.set(entry.keyId, key); + } + const seen = new Set(); + let verified = 0; + for (const signature of envelope.signatures) { + if (!signature || typeof signature.keyFingerprint !== "string" || !FINGERPRINT.test(signature.keyFingerprint) + || typeof signature.signatureBox !== "string" || !signature.signatureBox + || signature.signatureBox.length > 5464 || seen.has(signature.keyFingerprint)) { + throw new Error("Invalid signature threshold envelope"); + } + seen.add(signature.keyFingerprint); + const raw = Buffer.from(signature.signatureBox, "base64"); + if (raw.length > 4096 || raw.toString("base64") !== signature.signatureBox) { + throw new Error("Invalid signature threshold envelope encoding"); + } + const key = authorized.get(signature.keyFingerprint); + if (!key) continue; // Root rotation may carry signatures from both key sets. + verifyMinisignBytes(bytes, signature.signatureBox, key); + verified++; + } + if (verified < threshold) throw new Error("Signature threshold not met"); +} diff --git a/structure/runtime.md b/structure/runtime.md index 97d14984b1f..10ad396e3cb 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` verifies offline signatures, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded unverified data, and `update-signed-version.mjs` compares full version identity; none grants update authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded unverified data, and `update-signed-version.mjs` compares full version identity; none grants update authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/update/update-minisign.test.ts b/tests/update/update-minisign.test.ts index 801b3489281..77e0b4f9109 100644 --- a/tests/update/update-minisign.test.ts +++ b/tests/update/update-minisign.test.ts @@ -3,6 +3,7 @@ import { createHash, generateKeyPairSync, sign } from "node:crypto"; import { readFileSync } from "node:fs"; import { repoPath } from "../helpers/repo-root"; import { decodePublicKey, verifyMinisignBytes, verifyLegacyMinisignBytes } from "../../src/update/minisign.mjs"; +import { verifySignatureThreshold } from "../../src/update/update-signature-threshold.mjs"; describe("offline minisign verification", () => { test("accepts the independent upstream prehashed vector and rejects changed bytes", () => { @@ -36,4 +37,31 @@ describe("offline minisign verification", () => { expect(verifyMinisignBytes(bytes, exact, { ...key, fingerprint: "0".repeat(64) }).fingerprint).toBe(key.fingerprint); expect(() => verifyMinisignBytes(bytes, "A".repeat(5468), key)).toThrow(/exceeds limit/); }); + + test("counts distinct authorized signers and permits unrelated transition signatures", () => { + const bytes = Buffer.from("signed metadata"); + const makeSigner = (idByte: number) => { + const { publicKey, privateKey } = generateKeyPairSync("ed25519"); + const raw = Buffer.from(publicKey.export({ format: "der", type: "spki" })).subarray(-32); + const id = Buffer.alloc(8, idByte); + const text = `untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), id, raw]).toString("base64")}\n`; + const fingerprint = createHash("sha256").update(raw).digest("hex"); + const signature = sign(null, createHash("blake2b512").update(bytes).digest(), privateKey); + const global = sign(null, Buffer.concat([signature, Buffer.from("timestamp:1")]), privateKey); + const packet = Buffer.concat([Buffer.from("ED"), id, signature]).toString("base64"); + const signatureBox = Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: timestamp:1\n${global.toString("base64")}\n`).toString("base64"); + return { key: { keyId: fingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey: Buffer.from(text).toString("base64") }, signature: { keyFingerprint: fingerprint, signatureBox } }; + }; + const a = makeSigner(1), b = makeSigner(2), unrelated = makeSigner(3); + const envelope = { signatures: [a.signature, b.signature, unrelated.signature] }; + expect(() => verifySignatureThreshold(bytes, envelope, [a.key, b.key], 2)).not.toThrow(); + expect(() => verifySignatureThreshold(bytes, envelope, [a.key], 1)).not.toThrow(); + expect(() => verifySignatureThreshold(bytes, { signatures: [a.signature] }, [a.key, b.key], 2)).toThrow(); + expect(() => verifySignatureThreshold(bytes, { signatures: [a.signature, a.signature] }, [a.key, b.key], 2)).toThrow(); + expect(() => verifySignatureThreshold(bytes, { signatures: [{ ...a.signature, signatureBox: b.signature.signatureBox }] }, [a.key], 1)).toThrow(); + expect(() => verifySignatureThreshold(bytes, envelope, [a.key, a.key], 2)).toThrow(); + expect(() => verifySignatureThreshold(bytes, envelope, [a.key, b.key], 0)).toThrow(); + expect(() => verifySignatureThreshold(Buffer.from("changed"), envelope, [a.key, b.key], 2)).toThrow(); + expect(() => verifySignatureThreshold(bytes, envelope, [{ ...a.key, keyId: "0".repeat(64) }], 1)).toThrow(); + }); }); From 640e3421aba86fc8d8e9c3a61f6d974da3b704dc Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:34:48 +0900 Subject: [PATCH 09/42] Validate closed signed update document schemas --- scripts/test-layout/layout.json | 2 +- src/update/update-contracts.d.mts | 22 +++ src/update/update-contracts.mjs | 203 +++++++++++++++++++++++ structure/runtime.md | 2 +- tests/fixtures/test-layout-expected.json | 2 +- tests/update/update-contracts.test.ts | 154 +++++++++++++++++ 6 files changed, 382 insertions(+), 3 deletions(-) create mode 100644 src/update/update-contracts.d.mts create mode 100644 src/update/update-contracts.mjs create mode 100644 tests/update/update-contracts.test.ts diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json index 8d41f68720f..614e5bd69e0 100644 --- a/scripts/test-layout/layout.json +++ b/scripts/test-layout/layout.json @@ -1837,7 +1837,7 @@ "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", "update-async-routes.test.ts": "server", - "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", + "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", "update-standalone.test.ts": "update", "update-worker-launch.test.ts": "update", "update-notify.test.ts": "update", "update-npm-cache-preflight.test.ts": "update", diff --git a/src/update/update-contracts.d.mts b/src/update/update-contracts.d.mts new file mode 100644 index 00000000000..28e0bc0eb65 --- /dev/null +++ b/src/update/update-contracts.d.mts @@ -0,0 +1,22 @@ +/** Closed wire records are unverified data and convey no update authority. */ +export type Channel = "latest" | "preview" | "nightly"; +export type UpdateRole = "release" | "tree" | "desktop-artifact" | "standalone-artifact" | "guardian-artifact"; +export interface DigestSize { sha256: string; size: number } +export interface RootKey { keyId: string; algorithm: "minisign-ed25519-blake2b512/1"; publicKey: string } +export interface ReleaseKey extends RootKey { channels: Channel[]; roles: UpdateRole[] } +export interface UpdateRoot { schema: "ocx.update.root/1"; revision: number; expiresAt: string; rootKeys: RootKey[]; rootThreshold: number; releaseKeys: ReleaseKey[]; releaseThreshold: number; channels: Channel[] } +export interface SignatureEnvelope { schema: "ocx.update.signatures/1"; signatures: { keyFingerprint: string; signatureBox: string }[] } +export interface UpdateTarget { id: string; platform: "macos" | "linux" | "windows"; arch: "x64" | "arm64"; owner: "desktop" | "npm" | "pnpm" | "bun" | "standalone"; artifactKind: "tauri" | "tree" | "standalone" | "guardian"; bundleKind: "app-tar-gz" | "msi" | "appimage" | "deb" | "zip" | "tar-gz" | "binary"; assetName: string; artifact: DigestSize & { signatureBox: string; signerFingerprint: string }; tree: DigestSize | null; capabilities: DigestSize } +export interface UpdateRelease { schema: "ocx.update.release/1"; version: string; channel: Channel; sequence: number; sourceCommit: string; rolloutNotBefore: string; receipt: DigestSize; releaseNotes: {title: string; body: string}[]; targets: UpdateTarget[] } +export interface UpdateReceipt { schema: "ocx.update.verification/1"; sourceCommit: string; version: string; channel: Channel; workflowRunId: number; workflowAttempt: number; versionSources: {path: string; sha256: string}[]; assets: {name: string; sha256: string; size: number}[]; universalProofs: {assetName: string; artifactSha256: string; architectures: ["arm64", "x64"]; inspectionSha256: string}[]; architectureProofs: {targetId: string; assetName: string; artifactSha256: string; arch: "arm64" | "x64"; inspectionSha256: string}[] } +export type TreeEntry = {path: string; type: "file"; mode: number; size: number; sha256: string} | {path: string; type: "directory"; mode: number} | {path: string; type: "symlink"; target: string}; +export interface UpdateTree {schema: "ocx.update.tree/1"; version: string; target: string; entries: TreeEntry[]} +export interface Capability {id: string; version: number} +export interface UpdateCapabilities {schema: "ocx.link-capabilities/1"; version: string; channel: Channel; target: string; artifactSha256: string; homeProvides: Capability[]; childRequires: Capability[]; updateActions: Capability[]; installerAdapters: Capability[]; recoveryProtocols: Capability[]; fleetJournalReaders: Capability[]; compatibilityEpoch: number; compatibilityVectorSha256: string} +export interface UpdatePolicy {schema: "ocx.update.policy/1"; revision: number; channel: Channel; check: "automatic" | "manual"; download: "automatic" | "manual"; install: "manual" | "on-quit" | "when-idle"} +export type OwnerKind = "desktop" | "service" | "unmanaged"; +export interface UpdatePrepared {schema: "ocx.update.prepared/1"; operationId: string; candidateDigest: string; stageIdentity: string; stageDigest: string; installationId: string; ownerKind: OwnerKind; policyRevision: number} +export type UpdateActivation = {schema: "ocx.update.activation/1"; operationId: string; generation: number; runtimeInstance: string; pid: number; port: number; installationId: string; ownerKind: OwnerKind; candidateDigest: string; stageDigest: string; policyRevision: number; deadlineMs: number} & ({action: "reserve" | "inspect"} | {action: "commit" | "cancel"; permit: string}); +export interface UpdateDocumentSchemas {"ocx.update.root/1": UpdateRoot; "ocx.update.signatures/1": SignatureEnvelope; "ocx.update.release/1": UpdateRelease; "ocx.update.verification/1": UpdateReceipt; "ocx.update.tree/1": UpdateTree; "ocx.link-capabilities/1": UpdateCapabilities; "ocx.update.policy/1": UpdatePolicy; "ocx.update.prepared/1": UpdatePrepared; "ocx.update.activation/1": UpdateActivation} +export function parseUpdateDocument(bytes: Uint8Array, expectedSchema: S): UpdateDocumentSchemas[S]; +export function parseSignatureEnvelope(bytes: Uint8Array): SignatureEnvelope; diff --git a/src/update/update-contracts.mjs b/src/update/update-contracts.mjs new file mode 100644 index 00000000000..3c4e7f5a832 --- /dev/null +++ b/src/update/update-contracts.mjs @@ -0,0 +1,203 @@ +// These parsers validate wire shape only. Their results are not authenticated. +import { parseBoundedJson } from "./update-bounded-json.mjs"; +import { decodePublicKey } from "./minisign.mjs"; +import { sameSignedVersion } from "./update-signed-version.mjs"; + +const CAPS = Object.freeze({ + "ocx.update.root/1": 65536, "ocx.update.signatures/1": 65536, + "ocx.update.release/1": 1048576, "ocx.update.verification/1": 1048576, + "ocx.update.tree/1": 16777216, "ocx.link-capabilities/1": 1048576, + "ocx.update.policy/1": 4096, "ocx.update.prepared/1": 8192, + "ocx.update.activation/1": 8192, +}); +const CHANNELS = ["latest", "preview", "nightly"]; +const ROLES = ["release", "tree", "desktop-artifact", "standalone-artifact", "guardian-artifact"]; +const OWNERS = ["desktop", "service", "unmanaged"]; +const HASH = /^[a-f0-9]{64}$/; +const ASCII_ID = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/; +const UUID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/; +const VERSION_PATHS = ["package.json", "desktop/src-tauri/tauri.conf.json", "desktop/src-tauri/Cargo.toml", "desktop/src-tauri/Cargo.lock"]; +const FAIL = () => { throw new Error("Invalid update document"); }; +const text = (v, max = 4096) => typeof v === "string" && Buffer.byteLength(v, "utf8") <= max; +const id = (v) => text(v, 128) && ASCII_ID.test(v); +const hash = (v) => typeof v === "string" && HASH.test(v); +const integer = (v, min, max = Number.MAX_SAFE_INTEGER) => Number.isSafeInteger(v) && v >= min && v <= max; +const oneOf = (v, values) => values.includes(v); +const version = (v) => typeof v === "string" && sameSignedVersion(v, v); +const obj = (v, keys) => v !== null && typeof v === "object" && !Array.isArray(v) + && Object.keys(v).length === keys.length && keys.every((k) => Object.hasOwn(v, k)); +const array = (v, min, max) => Array.isArray(v) && v.length >= min && v.length <= max; +const unique = (values) => new Set(values).size === values.length; +const enumSet = (v, options) => array(v, 1, options.length) && unique(v) && v.every((x) => oneOf(x, options)); +const exact = (condition) => { if (!condition) FAIL(); }; +const validDate = (v) => { + if (typeof v !== "string" || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ$/.test(v)) return false; + const time = Date.parse(v); + return Number.isFinite(time) && new Date(time).toISOString() === v.replace("Z", ".000Z"); +}; +function base64(v, max) { + if (typeof v !== "string" || !v || v.length > Math.ceil(max / 3) * 4) FAIL(); + const b = Buffer.from(v, "base64"); + exact(b.length <= max && b.toString("base64") === v); + return b; +} +function utf8(b) { + try { return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(b); } catch { return FAIL(); } +} +function signature(v) { + const s = utf8(base64(v, 4096)); + const lines = s.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n"); + exact(lines.length === 4 && lines[0].startsWith("untrusted comment: ") + && lines[2].startsWith("trusted comment: ") && !s.replace(/\r\n/g, "").includes("\r")); + const packet = base64(lines[1], 74); + exact(packet.length === 74 && packet.subarray(0, 2).toString() === "ED" && base64(lines[3], 64).length === 64); +} +function key(v, release) { + exact(obj(v, release ? ["keyId", "algorithm", "publicKey", "channels", "roles"] : ["keyId", "algorithm", "publicKey"])); + exact(hash(v.keyId) && v.algorithm === "minisign-ed25519-blake2b512/1"); + const box = utf8(base64(v.publicKey, 4096)); + let decoded; + try { decoded = decodePublicKey(box); } catch { FAIL(); } + exact(decoded.fingerprint === v.keyId); + if (release) exact(enumSet(v.channels, CHANNELS) && enumSet(v.roles, ROLES)); +} +function root(v) { + exact(obj(v, ["schema", "revision", "expiresAt", "rootKeys", "rootThreshold", "releaseKeys", "releaseThreshold", "channels"])); + exact(integer(v.revision, 1) && validDate(v.expiresAt) && enumSet(v.channels, CHANNELS)); + exact(array(v.rootKeys, 1, 16) && array(v.releaseKeys, 1, 16)); + v.rootKeys.forEach((x) => key(x, false)); v.releaseKeys.forEach((x) => key(x, true)); + exact(unique(v.rootKeys.map((x) => x.keyId)) && unique(v.releaseKeys.map((x) => x.keyId))); + exact(integer(v.rootThreshold, 1, v.rootKeys.length) && integer(v.releaseThreshold, 1, 16)); + for (const channel of v.channels) { + for (const role of ROLES) { + const count = v.releaseKeys.filter((k) => k.channels.includes(channel) && k.roles.includes(role)).length; + if (count || role === "release") exact(count >= v.releaseThreshold); + } + } +} +function envelope(v) { + exact(obj(v, ["schema", "signatures"]) && array(v.signatures, 1, 16)); + for (const entry of v.signatures) { + exact(obj(entry, ["keyFingerprint", "signatureBox"]) && hash(entry.keyFingerprint)); signature(entry.signatureBox); + } + exact(unique(v.signatures.map((x) => x.keyFingerprint))); +} +function digestSize(v, max) { + exact(obj(v, ["sha256", "size"]) && hash(v.sha256) && integer(v.size, 1, max)); +} +const platforms = [["macos", "x64"], ["macos", "arm64"], ["windows", "x64"], ["linux", "x64"], ["linux", "arm64"]]; +function targetTuple(t) { + const { platform: p, arch: a, owner: o, artifactKind: k, bundleKind: b } = t; + if (!platforms.some(([x, y]) => x === p && y === a)) return null; + const prefix = `${p}-${a}`; + if (o === "desktop" && k === "tauri") { + if (p === "macos" && b === "app-tar-gz") return `${prefix}-desktop-tauri`; + if (p === "windows" && b === "msi") return `${prefix}-desktop-tauri`; + if (p === "linux" && a === "x64" && (b === "appimage" || b === "deb")) return `${prefix}-desktop-${b}`; + } + if (o === "standalone" && k === "standalone" && b === (p === "windows" ? "zip" : "tar-gz")) return `${prefix}-standalone`; + if (["npm", "pnpm", "bun"].includes(o) && k === "tree" && b === "tar-gz") return `${prefix}-${o}`; + if (k === "guardian" && b === "binary" && (o === "standalone" || (o === "desktop" && !(p === "linux" && a === "arm64")))) return `${prefix}-${o}-guardian`; + return null; +} +function expectedAsset(t, ver, channel) { + if (t.artifactKind === "guardian" || t.artifactKind === "tree") return `ocx-update-${ver}-${channel}-${t.id}${t.artifactKind === "tree" ? ".tar.gz" : ""}`; + if (t.artifactKind === "standalone") return `ocx-${ver}-bun-${t.platform === "macos" ? "darwin" : t.platform}-${t.arch}.${t.platform === "windows" ? "zip" : "tar.gz"}`; + const suffix = t.platform === "macos" ? "macos.app.tar.gz" : t.platform === "windows" ? "windows-x64.msi" : t.bundleKind === "deb" ? "linux-amd64.deb" : "linux-x86_64.AppImage"; + return `OpenCodex-${ver}-${suffix}`; +} +function target(t, ver, channel) { + exact(obj(t, ["id", "platform", "arch", "owner", "artifactKind", "bundleKind", "assetName", "artifact", "tree", "capabilities"])); + exact(id(t.id) && t.id === targetTuple(t) && id(t.assetName) && t.assetName === expectedAsset(t, ver, channel)); + exact(obj(t.artifact, ["sha256", "size", "signatureBox", "signerFingerprint"]) && hash(t.artifact.sha256) && hash(t.artifact.signerFingerprint) && integer(t.artifact.size, 1, 1073741824)); + signature(t.artifact.signatureBox); + if (t.artifactKind === "tauri" || t.artifactKind === "guardian") exact(t.tree === null); else digestSize(t.tree, 16777216); + digestSize(t.capabilities, 1048576); +} +function release(v) { + exact(obj(v, ["schema", "version", "channel", "sequence", "sourceCommit", "rolloutNotBefore", "receipt", "releaseNotes", "targets"])); + exact(version(v.version) && oneOf(v.channel, CHANNELS) && integer(v.sequence, 1) && typeof v.sourceCommit === "string" && /^[a-f0-9]{40}$/.test(v.sourceCommit) && validDate(v.rolloutNotBefore)); + digestSize(v.receipt, 1048576); + exact(array(v.releaseNotes, 0, 256)); + for (const n of v.releaseNotes) exact(obj(n, ["title", "body"]) && text(n.title, 16384) && text(n.body, 16384)); + exact(array(v.targets, 1, 64)); v.targets.forEach((t) => target(t, v.version, v.channel)); + exact(unique(v.targets.map((t) => t.id))); +} +function receipt(v) { + exact(obj(v, ["schema", "sourceCommit", "version", "channel", "workflowRunId", "workflowAttempt", "versionSources", "assets", "universalProofs", "architectureProofs"])); + exact(version(v.version) && oneOf(v.channel, CHANNELS) && typeof v.sourceCommit === "string" && /^[a-f0-9]{40}$/.test(v.sourceCommit) && integer(v.workflowRunId, 1) && integer(v.workflowAttempt, 1)); + exact(array(v.versionSources, 4, 4)); + for (const x of v.versionSources) exact(obj(x, ["path", "sha256"]) && VERSION_PATHS.includes(x.path) && hash(x.sha256)); + exact(unique(v.versionSources.map((x) => x.path)) && array(v.assets, 1, 4096)); + for (const x of v.assets) exact(obj(x, ["name", "sha256", "size"]) && id(x.name) && hash(x.sha256) && integer(x.size, 1)); + exact(v.assets.every((x, i) => i === 0 || v.assets[i - 1].name < x.name)); + exact(array(v.universalProofs, 0, 4096) && array(v.architectureProofs, 0, 4096)); + for (const x of v.universalProofs) exact(obj(x, ["assetName", "artifactSha256", "architectures", "inspectionSha256"]) && id(x.assetName) && hash(x.artifactSha256) && hash(x.inspectionSha256) && array(x.architectures, 2, 2) && x.architectures[0] === "arm64" && x.architectures[1] === "x64"); + for (const x of v.architectureProofs) exact(obj(x, ["targetId", "assetName", "artifactSha256", "arch", "inspectionSha256"]) && id(x.targetId) && id(x.assetName) && hash(x.artifactSha256) && hash(x.inspectionSha256) && oneOf(x.arch, ["x64", "arm64"])); + exact(unique(v.universalProofs.map((x) => JSON.stringify([x.assetName, x.artifactSha256, x.architectures, x.inspectionSha256]))) + && unique(v.architectureProofs.map((x) => JSON.stringify([x.targetId, x.assetName, x.artifactSha256, x.arch, x.inspectionSha256])))); +} +function path(v) { + return text(v, 1024) && v.length > 0 && !v.includes("\\") && !v.includes("\0") && !v.startsWith("/") && !/^[A-Za-z]:/.test(v) && v.split("/").every((x) => x && x !== "." && x !== ".."); +} +function linkTarget(v) { + return text(v, 1024) && v.length > 0 && !v.includes("\\") && !v.includes("\0") && !v.startsWith("/") && !/^[A-Za-z]:/.test(v); +} +function tree(v) { + exact(obj(v, ["schema", "version", "target", "entries"]) && version(v.version) && id(v.target) && array(v.entries, 0, 4096)); + const paths = new Map(); + for (const e of v.entries) { + exact(e && typeof e === "object" && path(e.path) && !paths.has(e.path)); + if (e.type === "file") exact(obj(e, ["path", "type", "mode", "size", "sha256"]) && integer(e.mode, 0, 511) && integer(e.size, 0, 1073741824) && hash(e.sha256)); + else if (e.type === "directory") exact(obj(e, ["path", "type", "mode"]) && integer(e.mode, 0, 511)); + else if (e.type === "symlink") exact(obj(e, ["path", "type", "target"]) && linkTarget(e.target)); + else FAIL(); + paths.set(e.path, e.type); + } + for (const name of paths.keys()) { + const separator = name.lastIndexOf("/"); + if (separator !== -1) exact(paths.get(name.slice(0, separator)) === "directory"); + } +} +function capability(v) { + const fields = ["homeProvides", "childRequires", "updateActions", "installerAdapters", "recoveryProtocols", "fleetJournalReaders"]; + exact(obj(v, ["schema", "version", "channel", "target", "artifactSha256", ...fields, "compatibilityEpoch", "compatibilityVectorSha256"])); + exact(version(v.version) && oneOf(v.channel, CHANNELS) && id(v.target) && hash(v.artifactSha256) && hash(v.compatibilityVectorSha256) && integer(v.compatibilityEpoch, 1)); + for (const field of fields) { + const a = v[field]; exact(array(a, 0, 4096)); + for (const x of a) exact(obj(x, ["id", "version"]) && id(x.id) && integer(x.version, 1)); + exact(unique(a.map((x) => `${x.id}\0${x.version}`))); + } +} +function policy(v) { + exact(obj(v, ["schema", "revision", "channel", "check", "download", "install"]) && integer(v.revision, 0) && oneOf(v.channel, CHANNELS) && oneOf(v.check, ["automatic", "manual"]) && oneOf(v.download, ["automatic", "manual"]) && oneOf(v.install, ["manual", "on-quit", "when-idle"])); +} +function token(v) { + if (typeof v !== "string" || !/^[A-Za-z0-9_-]{43}$/.test(v)) return false; + const b = Buffer.from(v, "base64url"); return b.length === 32 && b.toString("base64url") === v; +} +function identity(v) { return typeof v === "string" && UUID.test(v); } +function prepared(v) { + exact(obj(v, ["schema", "operationId", "candidateDigest", "stageIdentity", "stageDigest", "installationId", "ownerKind", "policyRevision"]) && identity(v.operationId) && hash(v.candidateDigest) && token(v.stageIdentity) && hash(v.stageDigest) && id(v.installationId) && oneOf(v.ownerKind, OWNERS) && integer(v.policyRevision, 0)); +} +function activation(v) { + const fields = ["schema", "action", "operationId", "generation", "runtimeInstance", "pid", "port", "installationId", "ownerKind", "candidateDigest", "stageDigest", "policyRevision", "deadlineMs"]; + const permit = v && (v.action === "commit" || v.action === "cancel"); + exact(obj(v, permit ? [...fields, "permit"] : fields) && oneOf(v.action, ["reserve", "inspect", "commit", "cancel"]) && identity(v.operationId) && integer(v.generation, 1) && id(v.runtimeInstance) && integer(v.pid, 1, 2147483647) && integer(v.port, 1, 65535) && id(v.installationId) && oneOf(v.ownerKind, OWNERS) && hash(v.candidateDigest) && hash(v.stageDigest) && integer(v.policyRevision, 0) && integer(v.deadlineMs, 0) && (!permit || token(v.permit))); +} +const VALIDATORS = Object.freeze({ + "ocx.update.root/1": root, "ocx.update.signatures/1": envelope, + "ocx.update.release/1": release, "ocx.update.verification/1": receipt, + "ocx.update.tree/1": tree, "ocx.link-capabilities/1": capability, + "ocx.update.policy/1": policy, "ocx.update.prepared/1": prepared, + "ocx.update.activation/1": activation, +}); +/** Parse a closed schema as unverified data; this does not authenticate it. */ +export function parseUpdateDocument(bytes, expectedSchema) { + if (typeof expectedSchema !== "string" || !Object.hasOwn(CAPS, expectedSchema)) FAIL(); + const value = parseBoundedJson(bytes, CAPS[expectedSchema]); + exact(value !== null && typeof value === "object" && !Array.isArray(value) && value.schema === expectedSchema); + VALIDATORS[expectedSchema](value); + return value; +} +export function parseSignatureEnvelope(bytes) { return parseUpdateDocument(bytes, "ocx.update.signatures/1"); } diff --git a/structure/runtime.md b/structure/runtime.md index 10ad396e3cb..8c938105e37 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded unverified data, and `update-signed-version.mjs` compares full version identity; none grants update authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity; none grants update authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json index 8ae16408777..48cb4790d23 100644 --- a/tests/fixtures/test-layout-expected.json +++ b/tests/fixtures/test-layout-expected.json @@ -1442,7 +1442,7 @@ "types-barrel-identity.test.ts": "config", "ultrafast-tier-honesty.test.ts": "codex-integration", "configured-ultrafast-picker.test.ts": "codex-integration", "ultrafast-live-catalog.test.ts": "codex-integration", "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", - "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", + "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", diff --git a/tests/update/update-contracts.test.ts b/tests/update/update-contracts.test.ts new file mode 100644 index 00000000000..e5f08cc9905 --- /dev/null +++ b/tests/update/update-contracts.test.ts @@ -0,0 +1,154 @@ +import { describe, expect, test } from "bun:test"; +import { createHash } from "node:crypto"; +import { readFileSync } from "node:fs"; +import { parseSignatureEnvelope, parseUpdateDocument } from "../../src/update/update-contracts.mjs"; +import type { UpdateDocumentSchemas } from "../../src/update/update-contracts.mjs"; +import { repoPath } from "../helpers/repo-root"; + +type Schema = keyof UpdateDocumentSchemas; +const h = "a".repeat(64); +const packet = Buffer.concat([Buffer.from("Ed"), Buffer.alloc(8, 4), Buffer.alloc(32, 7)]); +const fingerprint = createHash("sha256").update(packet.subarray(10)).digest("hex"); +const publicKey = Buffer.from(`untrusted comment: fixture\n${packet.toString("base64")}\n`).toString("base64"); +const vector = JSON.parse(readFileSync(repoPath("tests/fixtures/minisign/prehashed-vector.json"), "utf8")); +const box = Buffer.from(vector.signatureBox).toString("base64"); +const digest = { sha256: h, size: 1 }; +const key = { keyId: fingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey }; +const token = Buffer.alloc(32, 9).toString("base64url"); +const op = "12345678-1234-1234-1234-123456789abc"; +const pairs = [["macos", "x64"], ["macos", "arm64"], ["windows", "x64"], ["linux", "x64"], ["linux", "arm64"]]; +function makeTarget(platform: string, arch: string, owner: string, artifactKind: string, bundleKind: string, targetId: string) { + const name = artifactKind === "tree" || artifactKind === "guardian" ? `ocx-update-1.2.3-latest-${targetId}${artifactKind === "tree" ? ".tar.gz" : ""}` : artifactKind === "standalone" ? `ocx-1.2.3-bun-${platform === "macos" ? "darwin" : platform}-${arch}.${platform === "windows" ? "zip" : "tar.gz"}` : `OpenCodex-1.2.3-${platform === "macos" ? "macos.app.tar.gz" : platform === "windows" ? "windows-x64.msi" : bundleKind === "deb" ? "linux-amd64.deb" : "linux-x86_64.AppImage"}`; + return { id: targetId, platform, arch, owner, artifactKind, bundleKind, assetName: name, artifact: { ...digest, signatureBox: box, signerFingerprint: fingerprint }, tree: ["tree", "standalone"].includes(artifactKind) ? { ...digest } : null, capabilities: { ...digest } }; +} +function targets() { + const out = []; + for (const [p, a] of pairs) { + if (p === "macos") out.push(makeTarget(p, a, "desktop", "tauri", "app-tar-gz", `${p}-${a}-desktop-tauri`)); + if (p === "windows") out.push(makeTarget(p, a, "desktop", "tauri", "msi", `${p}-${a}-desktop-tauri`)); + if (p === "linux" && a === "x64") for (const b of ["appimage", "deb"]) out.push(makeTarget(p, a, "desktop", "tauri", b, `${p}-${a}-desktop-${b}`)); + out.push(makeTarget(p, a, "standalone", "standalone", p === "windows" ? "zip" : "tar-gz", `${p}-${a}-standalone`)); + for (const owner of ["npm", "pnpm", "bun"]) out.push(makeTarget(p, a, owner, "tree", "tar-gz", `${p}-${a}-${owner}`)); + if (!(p === "linux" && a === "arm64")) out.push(makeTarget(p, a, "desktop", "guardian", "binary", `${p}-${a}-desktop-guardian`)); + out.push(makeTarget(p, a, "standalone", "guardian", "binary", `${p}-${a}-standalone-guardian`)); + } + return out; +} +function fixtures(): Record { + return { + "ocx.update.root/1": {schema: "ocx.update.root/1", revision: 1, expiresAt: "2000-02-29T12:00:00Z", rootKeys: [key], rootThreshold: 1, releaseKeys: [{...key, channels: ["latest"], roles: ["release", "tree", "desktop-artifact", "standalone-artifact", "guardian-artifact"]}], releaseThreshold: 1, channels: ["latest"]}, + "ocx.update.signatures/1": {schema: "ocx.update.signatures/1", signatures: [{keyFingerprint: fingerprint, signatureBox: box}]}, + "ocx.update.release/1": {schema: "ocx.update.release/1", version: "1.2.3", channel: "latest", sequence: 1, sourceCommit: "b".repeat(40), rolloutNotBefore: "2028-02-29T00:00:00Z", receipt: {...digest}, releaseNotes: [{title: "title", body: "body"}], targets: targets()}, + "ocx.update.verification/1": {schema: "ocx.update.verification/1", sourceCommit: "b".repeat(40), version: "1.2.3", channel: "latest", workflowRunId: 1, workflowAttempt: 1, versionSources: ["package.json", "desktop/src-tauri/tauri.conf.json", "desktop/src-tauri/Cargo.toml", "desktop/src-tauri/Cargo.lock"].map(path => ({path, sha256: h})), assets: [{name: "a", ...digest}, {name: "b", ...digest}], universalProofs: [{assetName: "a", artifactSha256: h, architectures: ["arm64", "x64"], inspectionSha256: h}], architectureProofs: [{targetId: "linux-x64-npm", assetName: "b", artifactSha256: h, arch: "x64", inspectionSha256: h}]}, + "ocx.update.tree/1": {schema: "ocx.update.tree/1", version: "1.2.3", target: "linux-x64-npm", entries: [{path: "bin", type: "directory", mode: 493}, {path: "bin/a", type: "file", mode: 420, size: 0, sha256: h}, {path: "bin/link", type: "symlink", target: "../bin/a"}]}, + "ocx.link-capabilities/1": {schema: "ocx.link-capabilities/1", version: "1.2.3", channel: "latest", target: "linux-x64-npm", artifactSha256: h, homeProvides: [{id: "proto", version: 1}], childRequires: [], updateActions: [], installerAdapters: [], recoveryProtocols: [], fleetJournalReaders: [], compatibilityEpoch: 1, compatibilityVectorSha256: h}, + "ocx.update.policy/1": {schema: "ocx.update.policy/1", revision: 0, channel: "latest", check: "manual", download: "manual", install: "manual"}, + "ocx.update.prepared/1": {schema: "ocx.update.prepared/1", operationId: op, candidateDigest: h, stageIdentity: token, stageDigest: h, installationId: "install-1", ownerKind: "desktop", policyRevision: 0}, + "ocx.update.activation/1": {schema: "ocx.update.activation/1", action: "reserve", operationId: op, generation: 1, runtimeInstance: "runtime-1", pid: 1, port: 1, installationId: "install-1", ownerKind: "service", candidateDigest: h, stageDigest: h, policyRevision: 0, deadlineMs: 0}, + }; +} +const bytes = (value: unknown) => Buffer.from(JSON.stringify(value)); +const parse = (value: any) => parseUpdateDocument(bytes(value), value.schema as Schema); +const reject = (value: any) => expect(() => parse(value)).toThrow(); + +describe("closed unverified update contracts", () => { + test("all schemas parse including the complete 34-target table and expired root", () => { + const all = fixtures(); + expect(all["ocx.update.release/1"].targets).toHaveLength(34); + for (const value of Object.values(all)) { + expect(parse(value).schema).toBe(value.schema); + reject({...value, unexpected: true}); + const { schema: _schema, ...missing } = value; + expect(() => parseUpdateDocument(bytes(missing), value.schema)).toThrow(); + } + expect(parseSignatureEnvelope(bytes(all["ocx.update.signatures/1"])).signatures).toHaveLength(1); + }); + test("expected schema determines the immutable raw byte cap", () => { + const caps: Record = {"ocx.update.root/1":65536, "ocx.update.signatures/1":65536, "ocx.update.release/1":1048576, "ocx.update.verification/1":1048576, "ocx.update.tree/1":16777216, "ocx.link-capabilities/1":1048576, "ocx.update.policy/1":4096, "ocx.update.prepared/1":8192, "ocx.update.activation/1":8192}; + for (const [schema, value] of Object.entries(fixtures()) as [Schema, any][]) { + const raw = bytes(value); const exact = Buffer.concat([raw, Buffer.alloc(caps[schema] - raw.length, 32)]); + expect(parseUpdateDocument(exact, schema).schema).toBe(schema); + expect(() => Reflect.apply(parseUpdateDocument, null, [Buffer.concat([exact, Buffer.from(" ")]), schema, 999999999])).toThrow(); + } + expect(() => parseUpdateDocument(bytes(fixtures()["ocx.update.policy/1"]), "ocx.update.tree/1")).toThrow(); + expect(() => Reflect.apply(parseUpdateDocument, null, [Buffer.from("{}"), "__proto__"])).toThrow(); + const release = fixtures()["ocx.update.release/1"]; + release.releaseNotes = [{title: "é", body: "é"}]; + const raw = bytes(release); + const exact = Buffer.concat([raw, Buffer.alloc(1048576 - raw.length, 32)]); + expect(parseUpdateDocument(exact, release.schema).schema).toBe(release.schema); + expect(() => parseUpdateDocument(Buffer.concat([exact, Buffer.from(" ")]), release.schema)).toThrow(); + release.releaseNotes = [{title: "é".repeat(8192), body: "x".repeat(16384)}]; expect(parse(release)).toBeDefined(); + release.releaseNotes[0].title += "x"; reject(release); + }); + test("invalid JSON, UTF-8, decoded duplicate names, numbers and unknown fields refuse", () => { + const p = fixtures()["ocx.update.policy/1"]; const raw = JSON.stringify(p); + for (const broken of [raw.replace('"revision":0', '"revision":0,"revis\\u0069on":1'), raw.replace('"revision":0', '"revision":-0'), raw.replace('"revision":0', '"revision":9007199254740992'), raw.replace('"revision":0', '"revision":1.0'), raw.replace('"latest"', '"\\ud800"'), `${raw}x`, `\ufeff${raw}`]) expect(() => parseUpdateDocument(Buffer.from(broken), p.schema)).toThrow(); + expect(() => parseUpdateDocument(Buffer.from([0xc0, 0x80]), p.schema)).toThrow(); + reject({...p, extra: true}); reject({...p, revision: "0"}); reject({...p, channel: "unknown"}); + const release = fixtures()["ocx.update.release/1"]; + reject({...release, sourceCommit: `${release.sourceCommit}\n`}); + const prepared = fixtures()["ocx.update.prepared/1"]; + reject({...prepared, operationId: `${prepared.operationId}\n`}); + reject({...prepared, installationId: `${prepared.installationId}\n`}); + reject({...prepared, candidateDigest: `${prepared.candidateDigest}\n`}); + }); + test("root validates key identities, delegations, threshold and calendar", () => { + const r = fixtures()["ocx.update.root/1"]; + for (const date of ["2027-02-29T00:00:00Z", "2028-01-01T00:00:60Z", "2028-01-01T00:00:00+00:00"]) reject({...r, expiresAt: date}); + reject({...r, rootThreshold: 2}); reject({...r, releaseThreshold: 2}); reject({...r, rootKeys: [key, key]}); + reject({...r, rootKeys: [{...key, keyId: h}]}); reject({...r, channels: ["latest", "latest"]}); + reject({...r, releaseKeys: [{...r.releaseKeys[0], roles: ["tree"]}]}); + }); + test("signature envelope rejects noncanonical encodings and duplicate fingerprints", () => { + const e = fixtures()["ocx.update.signatures/1"]; + reject({...e, signatures: [e.signatures[0], e.signatures[0]]}); + reject({...e, signatures: [{...e.signatures[0], signatureBox: `${box}\n`}]}); + reject({...e, signatures: [{...e.signatures[0], signatureBox: Buffer.from("bad").toString("base64")}]}); + }); + test("release target tuple, names, numeric and size boundaries", () => { + const r = fixtures()["ocx.update.release/1"]; + reject({...r, targets: [...r.targets, r.targets[0]]}); reject({...r, targets: Array(65).fill(r.targets[0])}); + reject({...r, targets: [{...r.targets[0], assetName: "wrong"}]}); reject({...r, targets: [{...r.targets[0], bundleKind: "zip"}]}); + reject({...r, targets: [{...r.targets[0], tree: {...digest}}]}); reject({...r, sequence: 0}); + for (const v of ["v1.2.3", "01.2.3", "18446744073709551616.0.0", "1.2.3-01"]) reject({...r, version: v}); + const build = {...r, version: "1.2.3+build", targets: [{...r.targets[0], assetName: "OpenCodex-1.2.3+build-macos.app.tar.gz"}]}; expect(parse(build)).toBeDefined(); + const one = {...r, targets: [r.targets[0]], version: "18446744073709551615.0.0"}; + one.targets = [{...one.targets[0], assetName: "OpenCodex-18446744073709551615.0.0-macos.app.tar.gz"}]; expect(parse(one)).toBeDefined(); + }); + test("receipt shapes, version authority and ordered assets", () => { + const r = fixtures()["ocx.update.verification/1"]; + reject({...r, versionSources: [r.versionSources[0], r.versionSources[0], ...r.versionSources.slice(2)]}); + reject({...r, assets: [...r.assets].reverse()}); reject({...r, assets: [r.assets[0], r.assets[0]]}); + reject({...r, universalProofs: [{...r.universalProofs[0], architectures: ["x64", "arm64"]}]}); + reject({...r, architectureProofs: [{...r.architectureProofs[0], arch: "other"}]}); + }); + test("tree inventory is physical, requires real directory parents and accepts relative links", () => { + const t = fixtures()["ocx.update.tree/1"]; + for (const bad of ["../a", "/a", "C:a", "a\\b", "a//b", "a/./b"]) reject({...t, entries: [{path: bad, type: "directory", mode: 0}]}); + reject({...t, entries: [t.entries[1]]}); reject({...t, entries: [t.entries[0], t.entries[0]]}); + reject({...t, entries: [{path: "bin", type: "symlink", target: ".."}, t.entries[1]]}); + reject({...t, entries: [{path: "x", type: "symlink", target: "/escape"}]}); + reject({...t, entries: [{...t.entries[0], mode: 512}]}); + expect(parse({...t, entries: [{path: "Å", type: "directory", mode: 0}, {path: "a", type: "symlink", target: "../outside"}]})).toBeDefined(); + }); + test("capabilities and all activation actions enforce exact discriminants", () => { + const c = fixtures()["ocx.link-capabilities/1"]; + reject({...c, homeProvides: [c.homeProvides[0], c.homeProvides[0]]}); reject({...c, compatibilityEpoch: 0}); + const p = fixtures()["ocx.update.prepared/1"]; reject({...p, stageIdentity: "x".repeat(43)}); reject({...p, ownerKind: "npm"}); + const a = fixtures()["ocx.update.activation/1"]; + for (const action of ["reserve", "inspect"]) { expect(parse({...a, action})).toBeDefined(); reject({...a, action, permit: token}); } + for (const action of ["commit", "cancel"]) { reject({...a, action}); expect(parse({...a, action, permit: token})).toBeDefined(); } + reject({...a, generation: 0}); reject({...a, pid: 2147483648}); reject({...a, port: 65536}); reject({...a, candidateDigest: ""}); + }); + test("large legal inventory and capability arrays remain bounded", () => { + const t = fixtures()["ocx.update.tree/1"]; t.entries = Array.from({length: 4096}, (_, i) => ({path: `file-${i}`, type: "file", mode: 0, size: 0, sha256: h})); expect(parse(t)).toBeDefined(); + t.entries.push({path: "extra", type: "directory", mode: 0}); reject(t); + const c = fixtures()["ocx.link-capabilities/1"]; + for (const field of ["homeProvides", "childRequires", "updateActions", "installerAdapters", "recoveryProtocols", "fleetJournalReaders"]) c[field] = Array.from({length: 4096}, (_, i) => ({id: `p${i}`, version: 1})); + expect(parse(c)).toBeDefined(); c.homeProvides.push({id: "overflow", version: 1}); reject(c); + const r = fixtures()["ocx.update.verification/1"]; + r.assets = Array.from({length: 4096}, (_, i) => ({name: `asset-${String(i).padStart(4, "0")}`, sha256: h, size: 1})); + expect(parse(r)).toBeDefined(); r.assets.push({name: "overflow", sha256: h, size: 1}); reject(r); + }); +}); From 4f01dbef074661224f1c4c47847cd33976f31c50 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:36:35 +0900 Subject: [PATCH 10/42] Bind generated update root digest into runtime --- scripts/generate-update-trust-root.ts | 16 +++++++++++----- src/update/update-trust-anchor.d.mts | 2 ++ src/update/update-trust-anchor.mjs | 2 ++ structure/desktop-shell.md | 3 ++- tests/update/update-trust-root.test.ts | 3 +++ 5 files changed, 20 insertions(+), 6 deletions(-) create mode 100644 src/update/update-trust-anchor.d.mts create mode 100644 src/update/update-trust-anchor.mjs diff --git a/scripts/generate-update-trust-root.ts b/scripts/generate-update-trust-root.ts index d210f57dcc1..7a51051e5f9 100644 --- a/scripts/generate-update-trust-root.ts +++ b/scripts/generate-update-trust-root.ts @@ -1,12 +1,13 @@ /** Generate the offline update root from the already-pinned Tauri public key. */ import { readFileSync, renameSync, writeFileSync } from "node:fs"; +import { createHash } from "node:crypto"; import { dirname, resolve } from "node:path"; import { fileURLToPath } from "node:url"; import { decodePublicKey } from "../src/update/minisign.mjs"; const repo = resolve(dirname(fileURLToPath(import.meta.url)), ".."); const configPath = resolve(repo, "desktop/src-tauri/tauri.conf.json"); -const outputs = [ +const rootOutputs = [ resolve(repo, "src/update/trust-root.json"), resolve(repo, "desktop/src-tauri/update-trust-root.json"), ]; @@ -35,20 +36,25 @@ export function generateUpdateTrustRoot(config: unknown): string { function main(): void { const expected = generateUpdateTrustRoot(JSON.parse(readFileSync(configPath, "utf8"))); + const fingerprint = createHash("sha256").update(expected, "utf8").digest("hex"); + const outputs = [ + ...rootOutputs.map((path) => ({ path, contents: expected })), + { path: resolve(repo, "src/update/update-trust-anchor.mjs"), contents: `// Generated by scripts/generate-update-trust-root.ts.\nexport const EMBEDDED_ROOT_SHA256 = "${fingerprint}";\n` }, + ]; if (process.argv.slice(2).some((arg) => arg !== "--check") || process.argv.slice(2).length > 1) { throw new Error("Usage: generate-update-trust-root.ts [--check]"); } if (process.argv[2] === "--check") { for (const output of outputs) { - if (readFileSync(output, "utf8") !== expected) throw new Error("Generated update trust root is out of date"); + if (readFileSync(output.path, "utf8") !== output.contents) throw new Error("Generated update trust root is out of date"); } process.stdout.write("Generated update trust roots match the pinned public key\n"); return; } for (const output of outputs) { - const temporary = `${output}.${process.pid}.tmp`; - writeFileSync(temporary, expected, { flag: "wx" }); - renameSync(temporary, output); + const temporary = `${output.path}.${process.pid}.tmp`; + writeFileSync(temporary, output.contents, { flag: "wx" }); + renameSync(temporary, output.path); } process.stdout.write("Generated update trust roots\n"); } diff --git a/src/update/update-trust-anchor.d.mts b/src/update/update-trust-anchor.d.mts new file mode 100644 index 00000000000..faaa1d5d54d --- /dev/null +++ b/src/update/update-trust-anchor.d.mts @@ -0,0 +1,2 @@ +/** Digest of the root generated from the pinned updater public key. */ +export const EMBEDDED_ROOT_SHA256: string; diff --git a/src/update/update-trust-anchor.mjs b/src/update/update-trust-anchor.mjs new file mode 100644 index 00000000000..b186b9e86a4 --- /dev/null +++ b/src/update/update-trust-anchor.mjs @@ -0,0 +1,2 @@ +// Generated by scripts/generate-update-trust-root.ts. +export const EMBEDDED_ROOT_SHA256 = "1f43e68e98d910864d2e92a62bbe0ad6f9d3c0e0bf30ea6d3142c851bd4bc609"; diff --git a/structure/desktop-shell.md b/structure/desktop-shell.md index f80585f41ae..a6ccebd48fc 100644 --- a/structure/desktop-shell.md +++ b/structure/desktop-shell.md @@ -428,7 +428,8 @@ and grants no update or installation authority by itself. It decodes Tauri’s o trusted-comment signature. Missing or malformed fields fail before publication. `scripts/generate-update-trust-root.ts` derives identical offline root files at `src/update/trust-root.json` and `desktop/src-tauri/update-trust-root.json` from -the pinned public key; `--check` detects drift. These files do not yet authorize +the pinned public key and emits their digest in `src/update/update-trust-anchor.mjs`; +`--check` detects drift. These files do not yet authorize updates or change the Tauri updater's existing trust configuration. On macOS, in-app updates download `OpenCodex--macos.app.tar.gz`; the DMG is for the first installation. diff --git a/tests/update/update-trust-root.test.ts b/tests/update/update-trust-root.test.ts index 70b5396c36a..edbd142959f 100644 --- a/tests/update/update-trust-root.test.ts +++ b/tests/update/update-trust-root.test.ts @@ -1,8 +1,10 @@ import { describe, expect, test } from "bun:test"; import { readFileSync } from "node:fs"; +import { createHash } from "node:crypto"; import { repoPath } from "../helpers/repo-root"; import { generateUpdateTrustRoot } from "../../scripts/generate-update-trust-root"; import { decodePublicKey } from "../../src/update/minisign.mjs"; +import { EMBEDDED_ROOT_SHA256 } from "../../src/update/update-trust-anchor.mjs"; describe("generated update trust root", () => { test("uses the pinned updater public key and generates identical resource bytes", () => { @@ -19,6 +21,7 @@ describe("generated update trust root", () => { expect(root.channels).toEqual(["latest", "preview", "nightly"]); expect(readFileSync(repoPath("src/update/trust-root.json"), "utf8")).toBe(generated); expect(readFileSync(repoPath("desktop/src-tauri/update-trust-root.json"), "utf8")).toBe(generated); + expect(EMBEDDED_ROOT_SHA256).toBe(createHash("sha256").update(generated).digest("hex")); }); test("rejects absent, malformed and noncanonical public keys", () => { From 81827affefffa60525acd21cb84d63fc184f87a0 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:38:04 +0900 Subject: [PATCH 11/42] Authenticate the embedded update trust root --- scripts/test-layout/layout.json | 2 +- src/update/signed-supply.d.mts | 6 +++++ src/update/signed-supply.mjs | 19 ++++++++++++++++ structure/runtime.md | 2 +- tests/fixtures/test-layout-expected.json | 2 +- tests/update/update-signed-supply.test.ts | 27 +++++++++++++++++++++++ 6 files changed, 55 insertions(+), 3 deletions(-) create mode 100644 src/update/signed-supply.d.mts create mode 100644 src/update/signed-supply.mjs create mode 100644 tests/update/update-signed-supply.test.ts diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json index 614e5bd69e0..0212437fa4b 100644 --- a/scripts/test-layout/layout.json +++ b/scripts/test-layout/layout.json @@ -1837,7 +1837,7 @@ "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", "update-async-routes.test.ts": "server", - "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", + "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", "update-standalone.test.ts": "update", "update-worker-launch.test.ts": "update", "update-notify.test.ts": "update", "update-npm-cache-preflight.test.ts": "update", diff --git a/src/update/signed-supply.d.mts b/src/update/signed-supply.d.mts new file mode 100644 index 00000000000..1d863591a1a --- /dev/null +++ b/src/update/signed-supply.d.mts @@ -0,0 +1,6 @@ +declare const verifiedRoot: unique symbol; + +/** In-process module-owned root handle; parsing a document does not create one. */ +export interface VerifiedRoot { readonly [verifiedRoot]: never } + +export function bootstrapEmbeddedRoot(bytes: Uint8Array, nowMs: number): VerifiedRoot; diff --git a/src/update/signed-supply.mjs b/src/update/signed-supply.mjs new file mode 100644 index 00000000000..13f337c3e9f --- /dev/null +++ b/src/update/signed-supply.mjs @@ -0,0 +1,19 @@ +import { createHash } from "node:crypto"; +import { parseUpdateDocument } from "./update-contracts.mjs"; +import { EMBEDDED_ROOT_SHA256 } from "./update-trust-anchor.mjs"; + +// Handles are module-owned and contain no caller-mutable trust data. +const ROOTS = new WeakMap(); + +/** Authenticate the one root whose digest is compiled into this module closure. */ +export function bootstrapEmbeddedRoot(bytes, nowMs) { + if (!(bytes instanceof Uint8Array) || bytes.byteLength > 65536 + || !Number.isSafeInteger(nowMs) || nowMs < 0) throw new Error("Invalid embedded root input"); + const digest = createHash("sha256").update(bytes).digest("hex"); + if (digest !== EMBEDDED_ROOT_SHA256) throw new Error("Embedded root digest mismatch"); + const root = parseUpdateDocument(bytes, "ocx.update.root/1"); + if (Date.parse(root.expiresAt) <= nowMs) throw new Error("Embedded root expired"); + const handle = Object.freeze(Object.create(null)); + ROOTS.set(handle, { root, bytes: Uint8Array.from(bytes), digest }); + return handle; +} diff --git a/structure/runtime.md b/structure/runtime.md index 8c938105e37..c3aaab506b8 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity; none grants update authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity. `signed-supply.mjs` creates an opaque handle only for the embedded, unexpired root; none of these operations grants install or activation authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json index 48cb4790d23..507ff650e48 100644 --- a/tests/fixtures/test-layout-expected.json +++ b/tests/fixtures/test-layout-expected.json @@ -1442,7 +1442,7 @@ "types-barrel-identity.test.ts": "config", "ultrafast-tier-honesty.test.ts": "codex-integration", "configured-ultrafast-picker.test.ts": "codex-integration", "ultrafast-live-catalog.test.ts": "codex-integration", "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", - "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", + "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", diff --git a/tests/update/update-signed-supply.test.ts b/tests/update/update-signed-supply.test.ts new file mode 100644 index 00000000000..9ae01553413 --- /dev/null +++ b/tests/update/update-signed-supply.test.ts @@ -0,0 +1,27 @@ +import { describe, expect, test } from "bun:test"; +import { readFileSync } from "node:fs"; +import { repoPath } from "../helpers/repo-root"; +import { bootstrapEmbeddedRoot } from "../../src/update/signed-supply.mjs"; + +describe("embedded update trust root", () => { + const root = readFileSync(repoPath("src/update/trust-root.json")); + const expiry = Date.parse("2028-11-07T00:00:00Z"); + + test("accepts only the compiled root before expiry and returns an opaque handle", () => { + const trusted = bootstrapEmbeddedRoot(root, expiry - 1); + expect(Object.isFrozen(trusted)).toBe(true); + expect(Object.keys(trusted)).toEqual([]); + expect(() => bootstrapEmbeddedRoot(root, expiry)).toThrow(); + expect(() => bootstrapEmbeddedRoot(root, expiry + 1)).toThrow(); + }); + + test("rejects changed root bytes, invalid clocks and oversized input", () => { + const altered = Buffer.from(root); + altered[altered.length - 2] ^= 1; + expect(() => bootstrapEmbeddedRoot(altered, expiry - 1)).toThrow(); + expect(() => bootstrapEmbeddedRoot(Buffer.alloc(65537), expiry - 1)).toThrow(); + for (const time of [-1, NaN, Infinity, 1.5, Number.MAX_SAFE_INTEGER + 1]) { + expect(() => bootstrapEmbeddedRoot(root, time)).toThrow(); + } + }); +}); From ad1240503eebd286639986845efda6ac50b78839 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:41:12 +0900 Subject: [PATCH 12/42] Snapshot update root bytes before verification --- scripts/test-layout/layout.json | 2 +- src/update/signed-supply.mjs | 11 ++++--- src/update/update-bytes.d.mts | 2 ++ src/update/update-bytes.mjs | 23 +++++++++++++ structure/runtime.md | 2 +- tests/fixtures/test-layout-expected.json | 2 +- tests/update/update-root-snapshot.test.ts | 39 +++++++++++++++++++++++ 7 files changed, 73 insertions(+), 8 deletions(-) create mode 100644 src/update/update-bytes.d.mts create mode 100644 src/update/update-bytes.mjs create mode 100644 tests/update/update-root-snapshot.test.ts diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json index 0212437fa4b..aff413792ed 100644 --- a/scripts/test-layout/layout.json +++ b/scripts/test-layout/layout.json @@ -1837,7 +1837,7 @@ "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", "update-async-routes.test.ts": "server", - "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", + "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-root-snapshot.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", "update-standalone.test.ts": "update", "update-worker-launch.test.ts": "update", "update-notify.test.ts": "update", "update-npm-cache-preflight.test.ts": "update", diff --git a/src/update/signed-supply.mjs b/src/update/signed-supply.mjs index 13f337c3e9f..77a63ea3524 100644 --- a/src/update/signed-supply.mjs +++ b/src/update/signed-supply.mjs @@ -1,19 +1,20 @@ import { createHash } from "node:crypto"; import { parseUpdateDocument } from "./update-contracts.mjs"; import { EMBEDDED_ROOT_SHA256 } from "./update-trust-anchor.mjs"; +import { snapshotUpdateBytes } from "./update-bytes.mjs"; // Handles are module-owned and contain no caller-mutable trust data. const ROOTS = new WeakMap(); /** Authenticate the one root whose digest is compiled into this module closure. */ export function bootstrapEmbeddedRoot(bytes, nowMs) { - if (!(bytes instanceof Uint8Array) || bytes.byteLength > 65536 - || !Number.isSafeInteger(nowMs) || nowMs < 0) throw new Error("Invalid embedded root input"); - const digest = createHash("sha256").update(bytes).digest("hex"); + if (!Number.isSafeInteger(nowMs) || nowMs < 0) throw new Error("Invalid embedded root input"); + const snapshot = snapshotUpdateBytes(bytes, 65536); + const digest = createHash("sha256").update(snapshot).digest("hex"); if (digest !== EMBEDDED_ROOT_SHA256) throw new Error("Embedded root digest mismatch"); - const root = parseUpdateDocument(bytes, "ocx.update.root/1"); + const root = parseUpdateDocument(snapshot, "ocx.update.root/1"); if (Date.parse(root.expiresAt) <= nowMs) throw new Error("Embedded root expired"); const handle = Object.freeze(Object.create(null)); - ROOTS.set(handle, { root, bytes: Uint8Array.from(bytes), digest }); + ROOTS.set(handle, { root, bytes: snapshot, digest }); return handle; } diff --git a/src/update/update-bytes.d.mts b/src/update/update-bytes.d.mts new file mode 100644 index 00000000000..f9dd197f75b --- /dev/null +++ b/src/update/update-bytes.d.mts @@ -0,0 +1,2 @@ +/** Returns a private snapshot without invoking caller-defined byte-view properties. */ +export function snapshotUpdateBytes(bytes: Uint8Array, maxBytes: number): Uint8Array; diff --git a/src/update/update-bytes.mjs b/src/update/update-bytes.mjs new file mode 100644 index 00000000000..e7478fd4cc4 --- /dev/null +++ b/src/update/update-bytes.mjs @@ -0,0 +1,23 @@ +// Capture native typed-array accessors so caller-defined properties are never read. +const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype); +const getBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get; +const getByteOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get; +const getByteLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get; +const setBytes = Uint8Array.prototype.set; + +/** Copy a bounded byte view without invoking caller-defined getters or iterators. */ +export function snapshotUpdateBytes(bytes, maxBytes) { + if (!(bytes instanceof Uint8Array) || !Number.isSafeInteger(maxBytes) || maxBytes < 1) { + throw new Error("Invalid update bytes"); + } + try { + const length = getByteLength.call(bytes); + if (length > maxBytes) throw new Error("Update bytes exceed limit"); + const view = new Uint8Array(getBuffer.call(bytes), getByteOffset.call(bytes), length); + const snapshot = new Uint8Array(length); + setBytes.call(snapshot, view); + return snapshot; + } catch { + throw new Error("Invalid update bytes"); + } +} diff --git a/structure/runtime.md b/structure/runtime.md index c3aaab506b8..46ad80ee810 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity. `signed-supply.mjs` creates an opaque handle only for the embedded, unexpired root; none of these operations grants install or activation authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity. `signed-supply.mjs` snapshots input through `update-bytes.mjs` and creates an opaque handle only for the embedded, unexpired root; none of these operations grants install or activation authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json index 507ff650e48..e4a0f997104 100644 --- a/tests/fixtures/test-layout-expected.json +++ b/tests/fixtures/test-layout-expected.json @@ -1442,7 +1442,7 @@ "types-barrel-identity.test.ts": "config", "ultrafast-tier-honesty.test.ts": "codex-integration", "configured-ultrafast-picker.test.ts": "codex-integration", "ultrafast-live-catalog.test.ts": "codex-integration", "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", - "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", + "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-root-snapshot.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", diff --git a/tests/update/update-root-snapshot.test.ts b/tests/update/update-root-snapshot.test.ts new file mode 100644 index 00000000000..7fbc2abb9b6 --- /dev/null +++ b/tests/update/update-root-snapshot.test.ts @@ -0,0 +1,39 @@ +import { describe, expect, test } from "bun:test"; +import { readFileSync } from "node:fs"; +import { repoPath } from "../helpers/repo-root"; +import { bootstrapEmbeddedRoot } from "../../src/update/signed-supply.mjs"; + +describe("embedded root input snapshot", () => { + const original = readFileSync(repoPath("src/update/trust-root.json")); + const replacement = Buffer.from(original.toString().replace("2028-11-07T00:00:00Z", "2030-11-07T00:00:00Z")); + + test("cannot change authenticated bytes through a typed-array getter", () => { + class SwitchingBytes extends Uint8Array { + reads = 0; + get byteLength(): number { + if (++this.reads === 2) this.set(replacement); + return super.byteLength; + } + } + expect(() => bootstrapEmbeddedRoot(new SwitchingBytes(original), Date.parse("2029-01-01T00:00:00Z"))).toThrow(); + }); + + test("reads intrinsic typed-array slots without invoking caller getters or iterators", () => { + class TrappedBytes extends Uint8Array { + get byteLength(): number { throw new Error("caller getter"); } + get byteOffset(): number { throw new Error("caller getter"); } + get buffer(): ArrayBuffer { throw new Error("caller getter"); } + get length(): number { throw new Error("caller getter"); } + [Symbol.iterator](): IterableIterator { throw new Error("caller iterator"); } + } + expect(() => bootstrapEmbeddedRoot(new TrappedBytes(original), Date.parse("2027-01-01T00:00:00Z"))).not.toThrow(); + }); + + test("accepts a private snapshot of shared backing bytes", () => { + const shared = new Uint8Array(new SharedArrayBuffer(original.length)); + shared.set(original); + const handle = bootstrapEmbeddedRoot(shared, Date.parse("2027-01-01T00:00:00Z")); + shared.fill(0); + expect(Object.isFrozen(handle)).toBe(true); + }); +}); From 1cbc6c561bc7e12cc44e7be348eeae075b001354 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:43:13 +0900 Subject: [PATCH 13/42] Verify signed releases and select bound targets --- src/update/signed-supply.d.mts | 13 ++++ src/update/signed-supply.mjs | 46 ++++++++++++++- structure/runtime.md | 2 +- tests/update/update-signed-supply.test.ts | 72 ++++++++++++++++++++++- 4 files changed, 129 insertions(+), 4 deletions(-) diff --git a/src/update/signed-supply.d.mts b/src/update/signed-supply.d.mts index 1d863591a1a..e3b75977b9b 100644 --- a/src/update/signed-supply.d.mts +++ b/src/update/signed-supply.d.mts @@ -1,6 +1,19 @@ declare const verifiedRoot: unique symbol; +declare const verifiedRelease: unique symbol; +declare const verifiedCandidate: unique symbol; /** In-process module-owned root handle; parsing a document does not create one. */ export interface VerifiedRoot { readonly [verifiedRoot]: never } +export interface VerifiedRelease { readonly [verifiedRelease]: never } +export interface VerifiedCandidate { readonly [verifiedCandidate]: never; readonly candidateId: string } +export interface UpdateSelection { + platform: "macos" | "linux" | "windows"; + arch: "x64" | "arm64"; + owner: "desktop" | "npm" | "pnpm" | "bun" | "standalone"; + artifactKind: "tauri" | "tree" | "standalone" | "guardian"; + bundleKind: "app-tar-gz" | "msi" | "appimage" | "deb" | "zip" | "tar-gz" | "binary"; +} export function bootstrapEmbeddedRoot(bytes: Uint8Array, nowMs: number): VerifiedRoot; +export function verifyReleaseRecord(bytes: Uint8Array, envelopeBytes: Uint8Array, trustedRoot: VerifiedRoot, expectedChannel: "latest" | "preview" | "nightly", nowMs: number): VerifiedRelease; +export function selectVerifiedTarget(verifiedRelease: VerifiedRelease, selection: UpdateSelection): VerifiedCandidate; diff --git a/src/update/signed-supply.mjs b/src/update/signed-supply.mjs index 77a63ea3524..8a03dbe35c4 100644 --- a/src/update/signed-supply.mjs +++ b/src/update/signed-supply.mjs @@ -1,10 +1,21 @@ import { createHash } from "node:crypto"; -import { parseUpdateDocument } from "./update-contracts.mjs"; +import { parseSignatureEnvelope, parseUpdateDocument } from "./update-contracts.mjs"; import { EMBEDDED_ROOT_SHA256 } from "./update-trust-anchor.mjs"; import { snapshotUpdateBytes } from "./update-bytes.mjs"; +import { verifySignatureThreshold } from "./update-signature-threshold.mjs"; +import { deriveCandidateId } from "./update-candidate-id.mjs"; // Handles are module-owned and contain no caller-mutable trust data. const ROOTS = new WeakMap(); +const RELEASES = new WeakMap(); +const CANDIDATES = new WeakMap(); + +function currentRoot(handle, nowMs) { + if (!Number.isSafeInteger(nowMs) || nowMs < 0) throw new Error("Invalid trust clock"); + const state = ROOTS.get(handle); + if (!state || Date.parse(state.root.expiresAt) <= nowMs) throw new Error("Invalid or expired update root"); + return state; +} /** Authenticate the one root whose digest is compiled into this module closure. */ export function bootstrapEmbeddedRoot(bytes, nowMs) { @@ -18,3 +29,36 @@ export function bootstrapEmbeddedRoot(bytes, nowMs) { ROOTS.set(handle, { root, bytes: snapshot, digest }); return handle; } + +/** Verify exact release bytes under an opaque, current embedded root. */ +export function verifyReleaseRecord(bytes, envelopeBytes, trustedRoot, expectedChannel, nowMs) { + const state = currentRoot(trustedRoot, nowMs); + if (!state.root.channels.includes(expectedChannel)) throw new Error("Unsupported update channel"); + const releaseBytes = snapshotUpdateBytes(bytes, 1048576); + const signatureBytes = snapshotUpdateBytes(envelopeBytes, 65536); + const envelope = parseSignatureEnvelope(signatureBytes); + const keys = state.root.releaseKeys.filter((key) => key.channels.includes(expectedChannel) && key.roles.includes("release")); + verifySignatureThreshold(releaseBytes, envelope, keys, state.root.releaseThreshold); + const release = parseUpdateDocument(releaseBytes, "ocx.update.release/1"); + if (release.channel !== expectedChannel) throw new Error("Signed release channel mismatch"); + const digest = createHash("sha256").update(releaseBytes).digest("hex"); + const handle = Object.freeze(Object.create(null)); + RELEASES.set(handle, { release, root: trustedRoot, digest }); + return handle; +} + +/** Select a signed tuple; the resulting identity is a lookup, not install authority. */ +export function selectVerifiedTarget(verifiedRelease, selection) { + const state = RELEASES.get(verifiedRelease); + const fields = ["platform", "arch", "owner", "artifactKind", "bundleKind"]; + if (!state || !selection || typeof selection !== "object" || Array.isArray(selection) + || Object.keys(selection).length !== fields.length || !fields.every((field) => Object.hasOwn(selection, field))) { + throw new Error("Invalid verified update selection"); + } + const matches = state.release.targets.filter((target) => fields.every((field) => target[field] === selection[field])); + if (matches.length !== 1) throw new Error("Update target unavailable"); + const candidateId = deriveCandidateId(state.digest, matches[0].id); + const handle = Object.freeze({ candidateId }); + CANDIDATES.set(handle, { release: verifiedRelease, root: state.root, target: matches[0] }); + return handle; +} diff --git a/structure/runtime.md b/structure/runtime.md index 46ad80ee810..4a00b4f989a 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity. `signed-supply.mjs` snapshots input through `update-bytes.mjs` and creates an opaque handle only for the embedded, unexpired root; none of these operations grants install or activation authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity. `signed-supply.mjs` snapshots input through `update-bytes.mjs`, creates an opaque handle only for the embedded, unexpired root, verifies release signatures and selects signed target identities; none of these operations grants install or activation authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/update/update-signed-supply.test.ts b/tests/update/update-signed-supply.test.ts index 9ae01553413..64076254dc6 100644 --- a/tests/update/update-signed-supply.test.ts +++ b/tests/update/update-signed-supply.test.ts @@ -1,7 +1,12 @@ import { describe, expect, test } from "bun:test"; -import { readFileSync } from "node:fs"; +import { copyFileSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; +import { createHash, generateKeyPairSync, sign } from "node:crypto"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { pathToFileURL } from "node:url"; import { repoPath } from "../helpers/repo-root"; -import { bootstrapEmbeddedRoot } from "../../src/update/signed-supply.mjs"; +import { bootstrapEmbeddedRoot, selectVerifiedTarget, verifyReleaseRecord } from "../../src/update/signed-supply.mjs"; +import { deriveCandidateId } from "../../src/update/update-candidate-id.mjs"; describe("embedded update trust root", () => { const root = readFileSync(repoPath("src/update/trust-root.json")); @@ -25,3 +30,66 @@ describe("embedded update trust root", () => { } }); }); + +describe("verified release and candidate handles", () => { + test("uses an isolated compiled fixture anchor and rejects forged or cross-module handles", async () => { + const dir = mkdtempSync(join(tmpdir(), "ocx-update-fixture-")); + try { + const modules = ["signed-supply.mjs", "update-bytes.mjs", "update-contracts.mjs", "update-bounded-json.mjs", "update-candidate-id.mjs", "update-signed-version.mjs", "update-signature-threshold.mjs", "minisign.mjs"]; + for (const name of modules) { + const source = repoPath("src/update", name); + copyFileSync(source, join(dir, name)); + expect(readFileSync(join(dir, name))).toEqual(readFileSync(source)); + } + const { publicKey, privateKey } = generateKeyPairSync("ed25519"); + const raw = Buffer.from(publicKey.export({ format: "der", type: "spki" })).subarray(-32); + const id = Buffer.alloc(8, 7); + const fingerprint = createHash("sha256").update(raw).digest("hex"); + const publicBox = Buffer.from(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), id, raw]).toString("base64")}\n`).toString("base64"); + const key = { keyId: fingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey: publicBox }; + const root = Buffer.from(JSON.stringify({ schema: "ocx.update.root/1", revision: 1, expiresAt: "2030-01-01T00:00:00Z", rootKeys: [key], rootThreshold: 1, releaseKeys: [{ ...key, channels: ["latest"], roles: ["release", "desktop-artifact"] }], releaseThreshold: 1, channels: ["latest"] })); + const anchor = createHash("sha256").update(root).digest("hex"); + writeFileSync(join(dir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${anchor}";\n`); + const fixture = await import(pathToFileURL(join(dir, "signed-supply.mjs")).href); + const signBox = (bytes: Buffer) => { + const signature = sign(null, createHash("blake2b512").update(bytes).digest(), privateKey); + const comment = "timestamp:1\tversion:1.2.3"; + const global = sign(null, Buffer.concat([signature, Buffer.from(comment)]), privateKey); + const packet = Buffer.concat([Buffer.from("ED"), id, signature]).toString("base64"); + return Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: ${comment}\n${global.toString("base64")}\n`).toString("base64"); + }; + const artifact = Buffer.from("fixture artifact"); + const digest = createHash("sha256").update(artifact).digest("hex"); + const release = Buffer.from(JSON.stringify({ schema: "ocx.update.release/1", version: "1.2.3", channel: "latest", sequence: 1, sourceCommit: "a".repeat(40), rolloutNotBefore: "2026-01-01T00:00:00Z", receipt: { sha256: "b".repeat(64), size: 1 }, releaseNotes: [], targets: [{ id: "macos-x64-desktop-tauri", platform: "macos", arch: "x64", owner: "desktop", artifactKind: "tauri", bundleKind: "app-tar-gz", assetName: "OpenCodex-1.2.3-macos.app.tar.gz", artifact: { sha256: digest, size: artifact.length, signatureBox: signBox(artifact), signerFingerprint: fingerprint }, tree: null, capabilities: { sha256: "c".repeat(64), size: 1 } }] })); + const envelope = Buffer.from(JSON.stringify({ schema: "ocx.update.signatures/1", signatures: [{ keyFingerprint: fingerprint, signatureBox: signBox(release) }] })); + const now = Date.parse("2027-01-01T00:00:00Z"); + const rootHandle = fixture.bootstrapEmbeddedRoot(root, now); + const verified = fixture.verifyReleaseRecord(release, envelope, rootHandle, "latest", now); + class TrappedBytes extends Uint8Array { + get byteLength(): number { throw new Error("caller getter"); } + get byteOffset(): number { throw new Error("caller getter"); } + get buffer(): ArrayBuffer { throw new Error("caller getter"); } + get length(): number { throw new Error("caller getter"); } + [Symbol.iterator](): IterableIterator { throw new Error("caller iterator"); } + } + expect(() => fixture.verifyReleaseRecord(new TrappedBytes(release), new TrappedBytes(envelope), rootHandle, "latest", now)).not.toThrow(); + const selection = { platform: "macos", arch: "x64", owner: "desktop", artifactKind: "tauri", bundleKind: "app-tar-gz" }; + const candidate = fixture.selectVerifiedTarget(verified, selection); + expect(candidate.candidateId).toBe(deriveCandidateId(createHash("sha256").update(release).digest("hex"), "macos-x64-desktop-tauri")); + expect(Object.isFrozen(candidate)).toBe(true); + expect(() => fixture.verifyReleaseRecord(release, envelope, {}, "latest", now)).toThrow(); + expect(() => fixture.verifyReleaseRecord(Buffer.from("changed"), envelope, rootHandle, "latest", now)).toThrow(); + expect(() => fixture.verifyReleaseRecord(release, envelope, rootHandle, "preview", now)).toThrow(); + expect(() => fixture.verifyReleaseRecord(release, envelope, rootHandle, "latest", Date.parse("2030-01-01T00:00:00Z"))).toThrow(); + expect(() => fixture.selectVerifiedTarget(verified, { ...selection, arch: "arm64" })).toThrow(); + expect(() => fixture.selectVerifiedTarget(verified, { ...selection, url: "https://example.invalid" })).toThrow(); + expect(() => bootstrapEmbeddedRoot(root, now)).toThrow(); + expect(() => verifyReleaseRecord(release, envelope, rootHandle, "latest", now)).toThrow(); + expect(() => selectVerifiedTarget(verified, selection)).toThrow(); + root.fill(0); + expect(() => fixture.verifyReleaseRecord(release, envelope, rootHandle, "latest", now)).not.toThrow(); + } finally { + rmSync(dir, { recursive: true, force: true }); + } + }); +}); From 0ea7f1ed4318a113dcab32898b7aad339bf0c762 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:46:44 +0900 Subject: [PATCH 14/42] Check signed update comment versions --- src/update/update-signed-version.d.mts | 3 +++ src/update/update-signed-version.mjs | 7 +++++++ structure/runtime.md | 2 +- tests/update/update-signed-version.test.ts | 10 +++++++++- 4 files changed, 20 insertions(+), 2 deletions(-) diff --git a/src/update/update-signed-version.d.mts b/src/update/update-signed-version.d.mts index db34a2e00d6..5a8f82c9bb5 100644 --- a/src/update/update-signed-version.d.mts +++ b/src/update/update-signed-version.d.mts @@ -1,2 +1,5 @@ /** Strict full version equality, including build metadata; this grants no authority. */ export function sameSignedVersion(releaseVersion: string, signedVersion: string): boolean; + +/** Caller must authenticate the trusted comment before relying on this result. */ +export function trustedCommentMatchesVersion(comment: string, releaseVersion: string): boolean; diff --git a/src/update/update-signed-version.mjs b/src/update/update-signed-version.mjs index c0dc21f76c3..b50f8adf2b4 100644 --- a/src/update/update-signed-version.mjs +++ b/src/update/update-signed-version.mjs @@ -16,3 +16,10 @@ export function sameSignedVersion(releaseVersion, signedVersion) { const normalized = signedVersion.startsWith("v") ? signedVersion.slice(1) : signedVersion; return validVersion(normalized) && releaseVersion === normalized; } + +/** Compare a version field only after the caller authenticates the comment. */ +export function trustedCommentMatchesVersion(comment, releaseVersion) { + if (typeof comment !== "string" || Buffer.byteLength(comment, "utf8") > 4096) return false; + const versions = comment.split("\t").filter((field) => field.startsWith("version:")); + return versions.length === 1 && sameSignedVersion(releaseVersion, versions[0].slice("version:".length)); +} diff --git a/structure/runtime.md b/structure/runtime.md index 4a00b4f989a..e15950b8fcb 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity. `signed-supply.mjs` snapshots input through `update-bytes.mjs`, creates an opaque handle only for the embedded, unexpired root, verifies release signatures and selects signed target identities; none of these operations grants install or activation authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity and a unique comment field. `signed-supply.mjs` snapshots input through `update-bytes.mjs`, creates an opaque handle only for the embedded, unexpired root, verifies release signatures and selects signed target identities; none of these operations grants install or activation authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/update/update-signed-version.test.ts b/tests/update/update-signed-version.test.ts index 4d10c29a244..b7333efbb0d 100644 --- a/tests/update/update-signed-version.test.ts +++ b/tests/update/update-signed-version.test.ts @@ -1,5 +1,5 @@ import { describe, expect, test } from "bun:test"; -import { sameSignedVersion } from "../../src/update/update-signed-version.mjs"; +import { sameSignedVersion, trustedCommentMatchesVersion } from "../../src/update/update-signed-version.mjs"; describe("signed update version equality", () => { test("preserves full version identity and permits one signed v prefix", () => { @@ -18,4 +18,12 @@ describe("signed update version equality", () => { expect(sameSignedVersion("1.2.3", bad)).toBe(false); } }); + + test("requires exactly one matching version field in the authenticated comment", () => { + expect(trustedCommentMatchesVersion("timestamp:1\tfile:app.tar.gz\tversion:v1.2.3+build", "1.2.3+build")).toBe(true); + for (const comment of ["timestamp:1\tfile:app", "version:", "version:1.2.3\tversion:1.2.3", "version:1.2.3+other", "xversion:1.2.3", "version:vv1.2.3"]) { + expect(trustedCommentMatchesVersion(comment, "1.2.3+build")).toBe(false); + } + expect(trustedCommentMatchesVersion("version:1.2.3\tversion:1.2.3", "1.2.3")).toBe(false); + }); }); From 80492a47f38764f6ba934f0c39e2e6ad34d1efae Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:57:25 +0900 Subject: [PATCH 15/42] Add Node update primitive interoperability harness --- tests/helpers/update-node-harness.mjs | 41 +++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 tests/helpers/update-node-harness.mjs diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs new file mode 100644 index 00000000000..f216e65becc --- /dev/null +++ b/tests/helpers/update-node-harness.mjs @@ -0,0 +1,41 @@ +// Run with Node 18 for the required interoperability gate: +// node tests/helpers/update-node-harness.mjs --require-node18 +// This harness performs offline checks only; it never reads an installation. +import assert from "node:assert/strict"; +import { readFileSync } from "node:fs"; +import { fileURLToPath } from "node:url"; +import { decodePublicKey, verifyMinisignBytes } from "../../src/update/minisign.mjs"; +import { parseBoundedJson } from "../../src/update/update-bounded-json.mjs"; +import { deriveCandidateId } from "../../src/update/update-candidate-id.mjs"; +import { sameSignedVersion, trustedCommentMatchesVersion } from "../../src/update/update-signed-version.mjs"; +import { bootstrapEmbeddedRoot } from "../../src/update/signed-supply.mjs"; + +const args = process.argv.slice(2); +assert.ok(args.length === 0 || (args.length === 1 && args[0] === "--require-node18"), "unsupported arguments"); +if (args[0] === "--require-node18") assert.equal(Number(process.versions.node.split(".")[0]), 18, "Node 18 is required"); + +const fixture = JSON.parse(readFileSync(fileURLToPath(new URL("../fixtures/minisign/prehashed-vector.json", import.meta.url)), "utf8")); +const key = decodePublicKey(`untrusted comment: upstream key\n${fixture.publicKeyBase64}\n`); +const signature = Buffer.from(fixture.signatureBox).toString("base64"); +assert.equal(verifyMinisignBytes(Buffer.from(fixture.payload), signature, key).keyId, key.keyId); +assert.throws(() => verifyMinisignBytes(Buffer.from("changed"), signature, key)); + +assert.equal(deriveCandidateId("00".repeat(32), "linux-x64-npm"), "496737c902f9e38cbd89b81b0ba6935e245a026f4d0a931904ddd4617eafc7c4"); +assert.ok(sameSignedVersion("18446744073709551615.0.0+build", "v18446744073709551615.0.0+build")); +assert.ok(!sameSignedVersion("18446744073709551616.0.0", "18446744073709551616.0.0")); +assert.ok(!sameSignedVersion("1.2.3+one", "1.2.3+two")); +assert.ok(trustedCommentMatchesVersion("timestamp:1\tversion:v1.2.3+build", "1.2.3+build")); +assert.ok(!trustedCommentMatchesVersion("version:1.2.3\tversion:1.2.3", "1.2.3")); + +const encode = (text) => new TextEncoder().encode(text); +assert.equal(parseBoundedJson(encode('{"a":[1,true]}'), 65536).a[0], 1); +assert.throws(() => parseBoundedJson(encode('{"a":1,"\\u0061":2}'), 65536)); +const group = `[${Array(4096).fill("{}").join(",")}]`; +assert.throws(() => parseBoundedJson(encode(`[${Array(20).fill(group).join(",")}]`), 16777216)); + +const root = readFileSync(fileURLToPath(new URL("../../src/update/trust-root.json", import.meta.url))); +const expiry = Date.parse("2028-11-07T00:00:00Z"); +assert.ok(Object.isFrozen(bootstrapEmbeddedRoot(root, expiry - 1))); +assert.throws(() => bootstrapEmbeddedRoot(root, expiry)); +assert.throws(() => bootstrapEmbeddedRoot(Buffer.from("invalid"), expiry - 1)); +console.log(`Offline update primitive harness passed on Node ${process.versions.node}`); From 56545c8dc3bc586cf642c11afcecd057fd825e85 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 17:59:43 +0900 Subject: [PATCH 16/42] Separate root transition and release evidence --- src/update/signed-supply.d.mts | 24 +++++---- src/update/signed-supply.mjs | 44 +++++++++++++--- structure/runtime.md | 2 +- tests/update/update-signed-supply.test.ts | 64 +++++++++++++++++------ 4 files changed, 99 insertions(+), 35 deletions(-) diff --git a/src/update/signed-supply.d.mts b/src/update/signed-supply.d.mts index e3b75977b9b..30d99841dcc 100644 --- a/src/update/signed-supply.d.mts +++ b/src/update/signed-supply.d.mts @@ -1,11 +1,15 @@ -declare const verifiedRoot: unique symbol; -declare const verifiedRelease: unique symbol; -declare const verifiedCandidate: unique symbol; +declare const rootEvidence: unique symbol; +declare const rootTransition: unique symbol; +declare const releaseEvidence: unique symbol; +declare const targetEvidence: unique symbol; /** In-process module-owned root handle; parsing a document does not create one. */ -export interface VerifiedRoot { readonly [verifiedRoot]: never } -export interface VerifiedRelease { readonly [verifiedRelease]: never } -export interface VerifiedCandidate { readonly [verifiedCandidate]: never; readonly candidateId: string } +export interface RootEvidence { readonly [rootEvidence]: never } +export interface VerifiedRootTransition { readonly [rootTransition]: never } +export type RootBasis = RootEvidence | VerifiedRootTransition; +export interface ReleaseEvidence { readonly [releaseEvidence]: never } +export interface TargetEvidence { readonly [targetEvidence]: never; readonly candidateId: string } +export interface TransitionSummary { readonly predecessorDigest: string; readonly predecessorRevision: number; readonly successorDigest: string; readonly successorRevision: number } export interface UpdateSelection { platform: "macos" | "linux" | "windows"; arch: "x64" | "arm64"; @@ -14,6 +18,8 @@ export interface UpdateSelection { bundleKind: "app-tar-gz" | "msi" | "appimage" | "deb" | "zip" | "tar-gz" | "binary"; } -export function bootstrapEmbeddedRoot(bytes: Uint8Array, nowMs: number): VerifiedRoot; -export function verifyReleaseRecord(bytes: Uint8Array, envelopeBytes: Uint8Array, trustedRoot: VerifiedRoot, expectedChannel: "latest" | "preview" | "nightly", nowMs: number): VerifiedRelease; -export function selectVerifiedTarget(verifiedRelease: VerifiedRelease, selection: UpdateSelection): VerifiedCandidate; +export function bootstrapEmbeddedRoot(bytes: Uint8Array, nowMs: number): RootEvidence; +export function verifyRootTransition(predecessorBasis: RootBasis, bytes: Uint8Array, envelopeBytes: Uint8Array, nowMs: number): VerifiedRootTransition; +export function inspectTransition(transition: VerifiedRootTransition): TransitionSummary; +export function verifyReleaseEvidence(bytes: Uint8Array, envelopeBytes: Uint8Array, rootBasis: RootBasis, expectedChannel: "latest" | "preview" | "nightly", nowMs: number): ReleaseEvidence; +export function selectTargetEvidence(releaseEvidence: ReleaseEvidence, selection: UpdateSelection): TargetEvidence; diff --git a/src/update/signed-supply.mjs b/src/update/signed-supply.mjs index 8a03dbe35c4..1ec360955a3 100644 --- a/src/update/signed-supply.mjs +++ b/src/update/signed-supply.mjs @@ -7,12 +7,13 @@ import { deriveCandidateId } from "./update-candidate-id.mjs"; // Handles are module-owned and contain no caller-mutable trust data. const ROOTS = new WeakMap(); +const TRANSITIONS = new WeakMap(); const RELEASES = new WeakMap(); const CANDIDATES = new WeakMap(); function currentRoot(handle, nowMs) { if (!Number.isSafeInteger(nowMs) || nowMs < 0) throw new Error("Invalid trust clock"); - const state = ROOTS.get(handle); + const state = ROOTS.get(handle) || TRANSITIONS.get(handle); if (!state || Date.parse(state.root.expiresAt) <= nowMs) throw new Error("Invalid or expired update root"); return state; } @@ -30,9 +31,36 @@ export function bootstrapEmbeddedRoot(bytes, nowMs) { return handle; } -/** Verify exact release bytes under an opaque, current embedded root. */ -export function verifyReleaseRecord(bytes, envelopeBytes, trustedRoot, expectedChannel, nowMs) { - const state = currentRoot(trustedRoot, nowMs); +/** Verify a dual-threshold root transition as evidence, without promoting trust. */ +export function verifyRootTransition(predecessorBasis, bytes, envelopeBytes, nowMs) { + const previous = currentRoot(predecessorBasis, nowMs); + const nextBytes = snapshotUpdateBytes(bytes, 65536); + const signatureBytes = snapshotUpdateBytes(envelopeBytes, 65536); + const envelope = parseSignatureEnvelope(signatureBytes); + verifySignatureThreshold(nextBytes, envelope, previous.root.rootKeys, previous.root.rootThreshold); + const root = parseUpdateDocument(nextBytes, "ocx.update.root/1"); + if (root.revision <= previous.root.revision || Date.parse(root.expiresAt) <= nowMs) { + throw new Error("Invalid successor root"); + } + verifySignatureThreshold(nextBytes, envelope, root.rootKeys, root.rootThreshold); + const digest = createHash("sha256").update(nextBytes).digest("hex"); + const handle = Object.freeze(Object.create(null)); + TRANSITIONS.set(handle, { root, bytes: nextBytes, digest, predecessorDigest: previous.digest, + predecessorRevision: previous.root.revision, envelopeBytes: signatureBytes }); + return handle; +} + +/** Return diagnostic data only; this does not promote or persist a root. */ +export function inspectTransition(transition) { + const state = TRANSITIONS.get(transition); + if (!state) throw new Error("Invalid root transition evidence"); + return Object.freeze({ predecessorDigest: state.predecessorDigest, predecessorRevision: state.predecessorRevision, + successorDigest: state.digest, successorRevision: state.root.revision }); +} + +/** Verify exact release bytes under a root basis as evidence only. */ +export function verifyReleaseEvidence(bytes, envelopeBytes, rootBasis, expectedChannel, nowMs) { + const state = currentRoot(rootBasis, nowMs); if (!state.root.channels.includes(expectedChannel)) throw new Error("Unsupported update channel"); const releaseBytes = snapshotUpdateBytes(bytes, 1048576); const signatureBytes = snapshotUpdateBytes(envelopeBytes, 65536); @@ -43,13 +71,13 @@ export function verifyReleaseRecord(bytes, envelopeBytes, trustedRoot, expectedC if (release.channel !== expectedChannel) throw new Error("Signed release channel mismatch"); const digest = createHash("sha256").update(releaseBytes).digest("hex"); const handle = Object.freeze(Object.create(null)); - RELEASES.set(handle, { release, root: trustedRoot, digest }); + RELEASES.set(handle, { release, root: rootBasis, digest }); return handle; } /** Select a signed tuple; the resulting identity is a lookup, not install authority. */ -export function selectVerifiedTarget(verifiedRelease, selection) { - const state = RELEASES.get(verifiedRelease); +export function selectTargetEvidence(releaseEvidence, selection) { + const state = RELEASES.get(releaseEvidence); const fields = ["platform", "arch", "owner", "artifactKind", "bundleKind"]; if (!state || !selection || typeof selection !== "object" || Array.isArray(selection) || Object.keys(selection).length !== fields.length || !fields.every((field) => Object.hasOwn(selection, field))) { @@ -59,6 +87,6 @@ export function selectVerifiedTarget(verifiedRelease, selection) { if (matches.length !== 1) throw new Error("Update target unavailable"); const candidateId = deriveCandidateId(state.digest, matches[0].id); const handle = Object.freeze({ candidateId }); - CANDIDATES.set(handle, { release: verifiedRelease, root: state.root, target: matches[0] }); + CANDIDATES.set(handle, { release: releaseEvidence, root: state.root, target: matches[0] }); return handle; } diff --git a/structure/runtime.md b/structure/runtime.md index e15950b8fcb..be042f55a06 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity and a unique comment field. `signed-supply.mjs` snapshots input through `update-bytes.mjs`, creates an opaque handle only for the embedded, unexpired root, verifies release signatures and selects signed target identities; none of these operations grants install or activation authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity and a unique comment field. `signed-supply.mjs` snapshots input through `update-bytes.mjs` and returns opaque evidence for the embedded root, dual-threshold root transitions, signed releases and selected targets; it does not persist trust or grant install or activation authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/update/update-signed-supply.test.ts b/tests/update/update-signed-supply.test.ts index 64076254dc6..c6545dfc2b9 100644 --- a/tests/update/update-signed-supply.test.ts +++ b/tests/update/update-signed-supply.test.ts @@ -5,7 +5,7 @@ import { tmpdir } from "node:os"; import { join } from "node:path"; import { pathToFileURL } from "node:url"; import { repoPath } from "../helpers/repo-root"; -import { bootstrapEmbeddedRoot, selectVerifiedTarget, verifyReleaseRecord } from "../../src/update/signed-supply.mjs"; +import { bootstrapEmbeddedRoot, selectTargetEvidence, verifyReleaseEvidence, verifyRootTransition } from "../../src/update/signed-supply.mjs"; import { deriveCandidateId } from "../../src/update/update-candidate-id.mjs"; describe("embedded update trust root", () => { @@ -51,11 +51,11 @@ describe("verified release and candidate handles", () => { const anchor = createHash("sha256").update(root).digest("hex"); writeFileSync(join(dir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${anchor}";\n`); const fixture = await import(pathToFileURL(join(dir, "signed-supply.mjs")).href); - const signBox = (bytes: Buffer) => { - const signature = sign(null, createHash("blake2b512").update(bytes).digest(), privateKey); + const signBox = (bytes: Buffer, signingKey = privateKey, signingId = id) => { + const signature = sign(null, createHash("blake2b512").update(bytes).digest(), signingKey); const comment = "timestamp:1\tversion:1.2.3"; - const global = sign(null, Buffer.concat([signature, Buffer.from(comment)]), privateKey); - const packet = Buffer.concat([Buffer.from("ED"), id, signature]).toString("base64"); + const global = sign(null, Buffer.concat([signature, Buffer.from(comment)]), signingKey); + const packet = Buffer.concat([Buffer.from("ED"), signingId, signature]).toString("base64"); return Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: ${comment}\n${global.toString("base64")}\n`).toString("base64"); }; const artifact = Buffer.from("fixture artifact"); @@ -64,7 +64,7 @@ describe("verified release and candidate handles", () => { const envelope = Buffer.from(JSON.stringify({ schema: "ocx.update.signatures/1", signatures: [{ keyFingerprint: fingerprint, signatureBox: signBox(release) }] })); const now = Date.parse("2027-01-01T00:00:00Z"); const rootHandle = fixture.bootstrapEmbeddedRoot(root, now); - const verified = fixture.verifyReleaseRecord(release, envelope, rootHandle, "latest", now); + const verified = fixture.verifyReleaseEvidence(release, envelope, rootHandle, "latest", now); class TrappedBytes extends Uint8Array { get byteLength(): number { throw new Error("caller getter"); } get byteOffset(): number { throw new Error("caller getter"); } @@ -72,22 +72,52 @@ describe("verified release and candidate handles", () => { get length(): number { throw new Error("caller getter"); } [Symbol.iterator](): IterableIterator { throw new Error("caller iterator"); } } - expect(() => fixture.verifyReleaseRecord(new TrappedBytes(release), new TrappedBytes(envelope), rootHandle, "latest", now)).not.toThrow(); + expect(() => fixture.verifyReleaseEvidence(new TrappedBytes(release), new TrappedBytes(envelope), rootHandle, "latest", now)).not.toThrow(); const selection = { platform: "macos", arch: "x64", owner: "desktop", artifactKind: "tauri", bundleKind: "app-tar-gz" }; - const candidate = fixture.selectVerifiedTarget(verified, selection); + const candidate = fixture.selectTargetEvidence(verified, selection); expect(candidate.candidateId).toBe(deriveCandidateId(createHash("sha256").update(release).digest("hex"), "macos-x64-desktop-tauri")); expect(Object.isFrozen(candidate)).toBe(true); - expect(() => fixture.verifyReleaseRecord(release, envelope, {}, "latest", now)).toThrow(); - expect(() => fixture.verifyReleaseRecord(Buffer.from("changed"), envelope, rootHandle, "latest", now)).toThrow(); - expect(() => fixture.verifyReleaseRecord(release, envelope, rootHandle, "preview", now)).toThrow(); - expect(() => fixture.verifyReleaseRecord(release, envelope, rootHandle, "latest", Date.parse("2030-01-01T00:00:00Z"))).toThrow(); - expect(() => fixture.selectVerifiedTarget(verified, { ...selection, arch: "arm64" })).toThrow(); - expect(() => fixture.selectVerifiedTarget(verified, { ...selection, url: "https://example.invalid" })).toThrow(); + expect(() => fixture.verifyReleaseEvidence(release, envelope, {}, "latest", now)).toThrow(); + expect(() => fixture.verifyReleaseEvidence(Buffer.from("changed"), envelope, rootHandle, "latest", now)).toThrow(); + expect(() => fixture.verifyReleaseEvidence(release, envelope, rootHandle, "preview", now)).toThrow(); + expect(() => fixture.verifyReleaseEvidence(release, envelope, rootHandle, "latest", Date.parse("2030-01-01T00:00:00Z"))).toThrow(); + expect(() => fixture.selectTargetEvidence(verified, { ...selection, arch: "arm64" })).toThrow(); + expect(() => fixture.selectTargetEvidence(verified, { ...selection, url: "https://example.invalid" })).toThrow(); + expect("verifyReleaseRecord" in fixture).toBe(false); + expect("selectVerifiedTarget" in fixture).toBe(false); + + const successorPair = generateKeyPairSync("ed25519"); + const successorRaw = Buffer.from(successorPair.publicKey.export({ format: "der", type: "spki" })).subarray(-32); + const successorId = Buffer.alloc(8, 8); + const successorFingerprint = createHash("sha256").update(successorRaw).digest("hex"); + const successorBox = Buffer.from(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), successorId, successorRaw]).toString("base64")}\n`).toString("base64"); + const successorKey = { keyId: successorFingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey: successorBox }; + const successor = Buffer.from(JSON.stringify({ schema: "ocx.update.root/1", revision: 2, expiresAt: "2031-01-01T00:00:00Z", rootKeys: [successorKey], rootThreshold: 1, releaseKeys: [{ ...successorKey, channels: ["latest"], roles: ["release", "desktop-artifact"] }], releaseThreshold: 1, channels: ["latest"] })); + const oldSignature = { keyFingerprint: fingerprint, signatureBox: signBox(successor) }; + const newSignature = { keyFingerprint: successorFingerprint, signatureBox: signBox(successor, successorPair.privateKey, successorId) }; + const transitionEnvelope = (signatures: unknown[]) => Buffer.from(JSON.stringify({ schema: "ocx.update.signatures/1", signatures })); + const transition = fixture.verifyRootTransition(rootHandle, successor, transitionEnvelope([oldSignature, newSignature]), now); + expect(fixture.inspectTransition(transition)).toEqual({ predecessorDigest: anchor, predecessorRevision: 1, successorDigest: createHash("sha256").update(successor).digest("hex"), successorRevision: 2 }); + expect(() => fixture.verifyRootTransition(rootHandle, successor, transitionEnvelope([oldSignature]), now)).toThrow(); + expect(() => fixture.verifyRootTransition(rootHandle, successor, transitionEnvelope([newSignature]), now)).toThrow(); + expect(() => fixture.verifyRootTransition({}, successor, transitionEnvelope([oldSignature, newSignature]), now)).toThrow(); + expect(() => fixture.verifyRootTransition(rootHandle, root, transitionEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(root) }]), now)).toThrow(); + expect(() => fixture.verifyRootTransition(rootHandle, successor, transitionEnvelope([oldSignature, newSignature]), Date.parse("2030-01-01T00:00:00Z"))).toThrow(); + expect(() => verifyRootTransition(rootHandle, successor, transitionEnvelope([oldSignature, newSignature]), now)).toThrow(); + expect(() => fixture.inspectTransition({})).toThrow(); + const nextRelease = JSON.parse(release.toString()); + nextRelease.targets[0].artifact.signerFingerprint = successorFingerprint; + nextRelease.targets[0].artifact.signatureBox = signBox(artifact, successorPair.privateKey, successorId); + const nextBytes = Buffer.from(JSON.stringify(nextRelease)); + const nextEnvelope = transitionEnvelope([{ keyFingerprint: successorFingerprint, signatureBox: signBox(nextBytes, successorPair.privateKey, successorId) }]); + const nextEvidence = fixture.verifyReleaseEvidence(nextBytes, nextEnvelope, transition, "latest", now); + expect(fixture.selectTargetEvidence(nextEvidence, selection).candidateId).toMatch(/^[a-f0-9]{64}$/); + expect(() => fixture.verifyReleaseEvidence(nextBytes, nextEnvelope, rootHandle, "latest", now)).toThrow(); expect(() => bootstrapEmbeddedRoot(root, now)).toThrow(); - expect(() => verifyReleaseRecord(release, envelope, rootHandle, "latest", now)).toThrow(); - expect(() => selectVerifiedTarget(verified, selection)).toThrow(); + expect(() => verifyReleaseEvidence(release, envelope, rootHandle, "latest", now)).toThrow(); + expect(() => selectTargetEvidence(verified, selection)).toThrow(); root.fill(0); - expect(() => fixture.verifyReleaseRecord(release, envelope, rootHandle, "latest", now)).not.toThrow(); + expect(() => fixture.verifyReleaseEvidence(release, envelope, rootHandle, "latest", now)).not.toThrow(); } finally { rmSync(dir, { recursive: true, force: true }); } From d6476c71b242467ffeeeecdad437f02891c05c36 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:04:22 +0900 Subject: [PATCH 17/42] Verify signed update artifact evidence --- src/update/signed-supply.d.mts | 3 ++ src/update/signed-supply.mjs | 32 +++++++++++++++ structure/runtime.md | 2 +- tests/update/update-signed-supply.test.ts | 47 +++++++++++++++++++++-- 4 files changed, 79 insertions(+), 5 deletions(-) diff --git a/src/update/signed-supply.d.mts b/src/update/signed-supply.d.mts index 30d99841dcc..4b17114f8e8 100644 --- a/src/update/signed-supply.d.mts +++ b/src/update/signed-supply.d.mts @@ -2,6 +2,7 @@ declare const rootEvidence: unique symbol; declare const rootTransition: unique symbol; declare const releaseEvidence: unique symbol; declare const targetEvidence: unique symbol; +declare const artifactEvidence: unique symbol; /** In-process module-owned root handle; parsing a document does not create one. */ export interface RootEvidence { readonly [rootEvidence]: never } @@ -9,6 +10,7 @@ export interface VerifiedRootTransition { readonly [rootTransition]: never } export type RootBasis = RootEvidence | VerifiedRootTransition; export interface ReleaseEvidence { readonly [releaseEvidence]: never } export interface TargetEvidence { readonly [targetEvidence]: never; readonly candidateId: string } +export interface ArtifactEvidence { readonly [artifactEvidence]: never } export interface TransitionSummary { readonly predecessorDigest: string; readonly predecessorRevision: number; readonly successorDigest: string; readonly successorRevision: number } export interface UpdateSelection { platform: "macos" | "linux" | "windows"; @@ -23,3 +25,4 @@ export function verifyRootTransition(predecessorBasis: RootBasis, bytes: Uint8Ar export function inspectTransition(transition: VerifiedRootTransition): TransitionSummary; export function verifyReleaseEvidence(bytes: Uint8Array, envelopeBytes: Uint8Array, rootBasis: RootBasis, expectedChannel: "latest" | "preview" | "nightly", nowMs: number): ReleaseEvidence; export function selectTargetEvidence(releaseEvidence: ReleaseEvidence, selection: UpdateSelection): TargetEvidence; +export function verifyArtifactEvidence(target: TargetEvidence, bytes: Uint8Array, basis: RootBasis, nowMs: number): ArtifactEvidence; diff --git a/src/update/signed-supply.mjs b/src/update/signed-supply.mjs index 1ec360955a3..daf9c5c6619 100644 --- a/src/update/signed-supply.mjs +++ b/src/update/signed-supply.mjs @@ -4,12 +4,15 @@ import { EMBEDDED_ROOT_SHA256 } from "./update-trust-anchor.mjs"; import { snapshotUpdateBytes } from "./update-bytes.mjs"; import { verifySignatureThreshold } from "./update-signature-threshold.mjs"; import { deriveCandidateId } from "./update-candidate-id.mjs"; +import { decodePublicKey, verifyMinisignBytes } from "./minisign.mjs"; +import { trustedCommentMatchesVersion } from "./update-signed-version.mjs"; // Handles are module-owned and contain no caller-mutable trust data. const ROOTS = new WeakMap(); const TRANSITIONS = new WeakMap(); const RELEASES = new WeakMap(); const CANDIDATES = new WeakMap(); +const ARTIFACTS = new WeakMap(); function currentRoot(handle, nowMs) { if (!Number.isSafeInteger(nowMs) || nowMs < 0) throw new Error("Invalid trust clock"); @@ -90,3 +93,32 @@ export function selectTargetEvidence(releaseEvidence, selection) { CANDIDATES.set(handle, { release: releaseEvidence, root: state.root, target: matches[0] }); return handle; } + +/** Verify artifact bytes as evidence; this grants no staging or install authority. */ +export function verifyArtifactEvidence(targetEvidence, bytes, basis, nowMs) { + const state = currentRoot(basis, nowMs); + const candidate = CANDIDATES.get(targetEvidence); + if (!candidate || candidate.root !== basis) throw new Error("Invalid target evidence basis"); + const release = RELEASES.get(candidate.release); + if (!release || release.root !== basis) throw new Error("Invalid release evidence basis"); + const target = candidate.target; + const roles = { tauri: "desktop-artifact", standalone: "standalone-artifact", guardian: "guardian-artifact", tree: "tree" }; + const role = roles[target.artifactKind]; + if (!role || state.root.releaseThreshold !== 1) throw new Error("Unsupported artifact signature threshold"); + const key = state.root.releaseKeys.find((entry) => entry.keyId === target.artifact.signerFingerprint + && entry.channels.includes(release.release.channel) && entry.roles.includes(role)); + if (!key) throw new Error("Artifact signer is not delegated"); + const snapshot = snapshotUpdateBytes(bytes, target.artifact.size); + if (snapshot.byteLength !== target.artifact.size + || createHash("sha256").update(snapshot).digest("hex") !== target.artifact.sha256) { + throw new Error("Artifact bytes do not match signed target"); + } + const publicBox = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(Buffer.from(key.publicKey, "base64")); + const result = verifyMinisignBytes(snapshot, target.artifact.signatureBox, decodePublicKey(publicBox)); + if (!trustedCommentMatchesVersion(result.trustedComment, release.release.version)) { + throw new Error("Signed artifact version mismatch"); + } + const handle = Object.freeze(Object.create(null)); + ARTIFACTS.set(handle, { target: targetEvidence, basis, digest: target.artifact.sha256, size: snapshot.byteLength }); + return handle; +} diff --git a/structure/runtime.md b/structure/runtime.md index be042f55a06..6e8f04bdb88 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity and a unique comment field. `signed-supply.mjs` snapshots input through `update-bytes.mjs` and returns opaque evidence for the embedded root, dual-threshold root transitions, signed releases and selected targets; it does not persist trust or grant install or activation authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity and a unique comment field. `signed-supply.mjs` snapshots input through `update-bytes.mjs` and returns opaque evidence for the embedded root, dual-threshold root transitions, signed releases, selected targets and matching signed artifact bytes; it does not persist trust or grant install or activation authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/update/update-signed-supply.test.ts b/tests/update/update-signed-supply.test.ts index c6545dfc2b9..bd9e1f7d076 100644 --- a/tests/update/update-signed-supply.test.ts +++ b/tests/update/update-signed-supply.test.ts @@ -5,7 +5,7 @@ import { tmpdir } from "node:os"; import { join } from "node:path"; import { pathToFileURL } from "node:url"; import { repoPath } from "../helpers/repo-root"; -import { bootstrapEmbeddedRoot, selectTargetEvidence, verifyReleaseEvidence, verifyRootTransition } from "../../src/update/signed-supply.mjs"; +import { bootstrapEmbeddedRoot, selectTargetEvidence, verifyArtifactEvidence, verifyReleaseEvidence, verifyRootTransition } from "../../src/update/signed-supply.mjs"; import { deriveCandidateId } from "../../src/update/update-candidate-id.mjs"; describe("embedded update trust root", () => { @@ -51,9 +51,8 @@ describe("verified release and candidate handles", () => { const anchor = createHash("sha256").update(root).digest("hex"); writeFileSync(join(dir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${anchor}";\n`); const fixture = await import(pathToFileURL(join(dir, "signed-supply.mjs")).href); - const signBox = (bytes: Buffer, signingKey = privateKey, signingId = id) => { + const signBox = (bytes: Buffer, signingKey = privateKey, signingId = id, comment = "timestamp:1\tversion:1.2.3") => { const signature = sign(null, createHash("blake2b512").update(bytes).digest(), signingKey); - const comment = "timestamp:1\tversion:1.2.3"; const global = sign(null, Buffer.concat([signature, Buffer.from(comment)]), signingKey); const packet = Buffer.concat([Buffer.from("ED"), signingId, signature]).toString("base64"); return Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: ${comment}\n${global.toString("base64")}\n`).toString("base64"); @@ -77,6 +76,13 @@ describe("verified release and candidate handles", () => { const candidate = fixture.selectTargetEvidence(verified, selection); expect(candidate.candidateId).toBe(deriveCandidateId(createHash("sha256").update(release).digest("hex"), "macos-x64-desktop-tauri")); expect(Object.isFrozen(candidate)).toBe(true); + const artifactEvidence = fixture.verifyArtifactEvidence(candidate, artifact, rootHandle, now); + expect(Object.isFrozen(artifactEvidence)).toBe(true); + expect(Object.keys(artifactEvidence)).toEqual([]); + expect(() => fixture.verifyArtifactEvidence(candidate, Buffer.from("changed"), rootHandle, now)).toThrow(); + expect(() => fixture.verifyArtifactEvidence({}, artifact, rootHandle, now)).toThrow(); + expect(() => verifyArtifactEvidence(candidate, artifact, rootHandle, now)).toThrow(); + expect(() => fixture.verifyArtifactEvidence(candidate, artifact, rootHandle, Date.parse("2030-01-01T00:00:00Z"))).toThrow(); expect(() => fixture.verifyReleaseEvidence(release, envelope, {}, "latest", now)).toThrow(); expect(() => fixture.verifyReleaseEvidence(Buffer.from("changed"), envelope, rootHandle, "latest", now)).toThrow(); expect(() => fixture.verifyReleaseEvidence(release, envelope, rootHandle, "preview", now)).toThrow(); @@ -97,6 +103,7 @@ describe("verified release and candidate handles", () => { const newSignature = { keyFingerprint: successorFingerprint, signatureBox: signBox(successor, successorPair.privateKey, successorId) }; const transitionEnvelope = (signatures: unknown[]) => Buffer.from(JSON.stringify({ schema: "ocx.update.signatures/1", signatures })); const transition = fixture.verifyRootTransition(rootHandle, successor, transitionEnvelope([oldSignature, newSignature]), now); + expect(() => fixture.verifyArtifactEvidence(candidate, artifact, transition, now)).toThrow(); expect(fixture.inspectTransition(transition)).toEqual({ predecessorDigest: anchor, predecessorRevision: 1, successorDigest: createHash("sha256").update(successor).digest("hex"), successorRevision: 2 }); expect(() => fixture.verifyRootTransition(rootHandle, successor, transitionEnvelope([oldSignature]), now)).toThrow(); expect(() => fixture.verifyRootTransition(rootHandle, successor, transitionEnvelope([newSignature]), now)).toThrow(); @@ -111,8 +118,40 @@ describe("verified release and candidate handles", () => { const nextBytes = Buffer.from(JSON.stringify(nextRelease)); const nextEnvelope = transitionEnvelope([{ keyFingerprint: successorFingerprint, signatureBox: signBox(nextBytes, successorPair.privateKey, successorId) }]); const nextEvidence = fixture.verifyReleaseEvidence(nextBytes, nextEnvelope, transition, "latest", now); - expect(fixture.selectTargetEvidence(nextEvidence, selection).candidateId).toMatch(/^[a-f0-9]{64}$/); + const nextCandidate = fixture.selectTargetEvidence(nextEvidence, selection); + expect(nextCandidate.candidateId).toMatch(/^[a-f0-9]{64}$/); + expect(() => fixture.verifyArtifactEvidence(nextCandidate, artifact, transition, now)).not.toThrow(); expect(() => fixture.verifyReleaseEvidence(nextBytes, nextEnvelope, rootHandle, "latest", now)).toThrow(); + for (const comment of ["timestamp:1", "version:1.2.4", "version:1.2.3\tversion:1.2.3"]) { + const altered = JSON.parse(release.toString()); + altered.targets[0].artifact.signatureBox = signBox(artifact, privateKey, id, comment); + const alteredBytes = Buffer.from(JSON.stringify(altered)); + const alteredEnvelope = transitionEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(alteredBytes) }]); + const alteredRelease = fixture.verifyReleaseEvidence(alteredBytes, alteredEnvelope, rootHandle, "latest", now); + const alteredTarget = fixture.selectTargetEvidence(alteredRelease, selection); + expect(() => fixture.verifyArtifactEvidence(alteredTarget, artifact, rootHandle, now)).toThrow(); + } + const wrongSigner = JSON.parse(release.toString()); + wrongSigner.targets[0].artifact.signerFingerprint = successorFingerprint; + const wrongSignerBytes = Buffer.from(JSON.stringify(wrongSigner)); + const wrongSignerEnvelope = transitionEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(wrongSignerBytes) }]); + const wrongSignerRelease = fixture.verifyReleaseEvidence(wrongSignerBytes, wrongSignerEnvelope, rootHandle, "latest", now); + expect(() => fixture.verifyArtifactEvidence(fixture.selectTargetEvidence(wrongSignerRelease, selection), artifact, rootHandle, now)).toThrow(); + + const multiRoot = JSON.parse(successor.toString()); + multiRoot.releaseKeys = [key, successorKey].map((entry) => ({ ...entry, channels: ["latest"], roles: ["release", "desktop-artifact"] })); + multiRoot.releaseThreshold = 2; + const multiRootBytes = Buffer.from(JSON.stringify(multiRoot)); + const multiTransition = fixture.verifyRootTransition(rootHandle, multiRootBytes, transitionEnvelope([ + { keyFingerprint: fingerprint, signatureBox: signBox(multiRootBytes) }, + { keyFingerprint: successorFingerprint, signatureBox: signBox(multiRootBytes, successorPair.privateKey, successorId) }, + ]), now); + const multiReleaseEnvelope = transitionEnvelope([ + { keyFingerprint: fingerprint, signatureBox: signBox(nextBytes) }, + { keyFingerprint: successorFingerprint, signatureBox: signBox(nextBytes, successorPair.privateKey, successorId) }, + ]); + const multiRelease = fixture.verifyReleaseEvidence(nextBytes, multiReleaseEnvelope, multiTransition, "latest", now); + expect(() => fixture.verifyArtifactEvidence(fixture.selectTargetEvidence(multiRelease, selection), artifact, multiTransition, now)).toThrow(); expect(() => bootstrapEmbeddedRoot(root, now)).toThrow(); expect(() => verifyReleaseEvidence(release, envelope, rootHandle, "latest", now)).toThrow(); expect(() => selectTargetEvidence(verified, selection)).toThrow(); From d56a12200f0f771bae4f29f4195bad424ebedb2d Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:06:44 +0900 Subject: [PATCH 18/42] Cover artifact delegation and byte mismatches --- tests/update/update-signed-supply.test.ts | 30 ++++++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git a/tests/update/update-signed-supply.test.ts b/tests/update/update-signed-supply.test.ts index bd9e1f7d076..d99596dd40e 100644 --- a/tests/update/update-signed-supply.test.ts +++ b/tests/update/update-signed-supply.test.ts @@ -47,7 +47,16 @@ describe("verified release and candidate handles", () => { const fingerprint = createHash("sha256").update(raw).digest("hex"); const publicBox = Buffer.from(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), id, raw]).toString("base64")}\n`).toString("base64"); const key = { keyId: fingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey: publicBox }; - const root = Buffer.from(JSON.stringify({ schema: "ocx.update.root/1", revision: 1, expiresAt: "2030-01-01T00:00:00Z", rootKeys: [key], rootThreshold: 1, releaseKeys: [{ ...key, channels: ["latest"], roles: ["release", "desktop-artifact"] }], releaseThreshold: 1, channels: ["latest"] })); + const extraSigner = (byte: number) => { + const pair = generateKeyPairSync("ed25519"); + const publicBytes = Buffer.from(pair.publicKey.export({ format: "der", type: "spki" })).subarray(-32); + const keyId = createHash("sha256").update(publicBytes).digest("hex"); + const packetId = Buffer.alloc(8, byte); + const publicKeyBox = Buffer.from(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), packetId, publicBytes]).toString("base64")}\n`).toString("base64"); + return { pair, packetId, key: { keyId, algorithm: "minisign-ed25519-blake2b512/1", publicKey: publicKeyBox } }; + }; + const wrongRole = extraSigner(9), wrongChannel = extraSigner(10); + const root = Buffer.from(JSON.stringify({ schema: "ocx.update.root/1", revision: 1, expiresAt: "2030-01-01T00:00:00Z", rootKeys: [key], rootThreshold: 1, releaseKeys: [{ ...key, channels: ["latest"], roles: ["release", "desktop-artifact"] }, { ...wrongRole.key, channels: ["latest"], roles: ["release"] }, { ...wrongChannel.key, channels: ["preview"], roles: ["release", "desktop-artifact"] }], releaseThreshold: 1, channels: ["latest", "preview"] })); const anchor = createHash("sha256").update(root).digest("hex"); writeFileSync(join(dir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${anchor}";\n`); const fixture = await import(pathToFileURL(join(dir, "signed-supply.mjs")).href); @@ -80,6 +89,8 @@ describe("verified release and candidate handles", () => { expect(Object.isFrozen(artifactEvidence)).toBe(true); expect(Object.keys(artifactEvidence)).toEqual([]); expect(() => fixture.verifyArtifactEvidence(candidate, Buffer.from("changed"), rootHandle, now)).toThrow(); + const sameLengthChange = Buffer.from(artifact); sameLengthChange[0] ^= 1; + expect(() => fixture.verifyArtifactEvidence(candidate, sameLengthChange, rootHandle, now)).toThrow(); expect(() => fixture.verifyArtifactEvidence({}, artifact, rootHandle, now)).toThrow(); expect(() => verifyArtifactEvidence(candidate, artifact, rootHandle, now)).toThrow(); expect(() => fixture.verifyArtifactEvidence(candidate, artifact, rootHandle, Date.parse("2030-01-01T00:00:00Z"))).toThrow(); @@ -137,6 +148,23 @@ describe("verified release and candidate handles", () => { const wrongSignerEnvelope = transitionEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(wrongSignerBytes) }]); const wrongSignerRelease = fixture.verifyReleaseEvidence(wrongSignerBytes, wrongSignerEnvelope, rootHandle, "latest", now); expect(() => fixture.verifyArtifactEvidence(fixture.selectTargetEvidence(wrongSignerRelease, selection), artifact, rootHandle, now)).toThrow(); + for (const other of [wrongRole, wrongChannel]) { + const altered = JSON.parse(release.toString()); + altered.targets[0].artifact.signerFingerprint = other.key.keyId; + altered.targets[0].artifact.signatureBox = signBox(artifact, other.pair.privateKey, other.packetId); + const alteredBytes = Buffer.from(JSON.stringify(altered)); + const alteredEnvelope = transitionEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(alteredBytes) }]); + const alteredRelease = fixture.verifyReleaseEvidence(alteredBytes, alteredEnvelope, rootHandle, "latest", now); + expect(() => fixture.verifyArtifactEvidence(fixture.selectTargetEvidence(alteredRelease, selection), artifact, rootHandle, now)).toThrow(); + } + for (const alteredArtifact of [{ sha256: "f".repeat(64) }, { size: artifact.length + 1 }]) { + const altered = JSON.parse(release.toString()); + Object.assign(altered.targets[0].artifact, alteredArtifact); + const alteredBytes = Buffer.from(JSON.stringify(altered)); + const alteredEnvelope = transitionEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(alteredBytes) }]); + const alteredRelease = fixture.verifyReleaseEvidence(alteredBytes, alteredEnvelope, rootHandle, "latest", now); + expect(() => fixture.verifyArtifactEvidence(fixture.selectTargetEvidence(alteredRelease, selection), artifact, rootHandle, now)).toThrow(); + } const multiRoot = JSON.parse(successor.toString()); multiRoot.releaseKeys = [key, successorKey].map((entry) => ({ ...entry, channels: ["latest"], roles: ["release", "desktop-artifact"] })); From 67898300ba049bdef0c62e6c988b20909e0e053d Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:10:20 +0900 Subject: [PATCH 19/42] Clarify signed root transition envelope contract --- .../261107_auto_update_parity/003_contracts.md | 6 ++++-- .../010_signed_supply.md | 17 +++++++++++++---- 2 files changed, 17 insertions(+), 6 deletions(-) diff --git a/devlog/_plan/261107_auto_update_parity/003_contracts.md b/devlog/_plan/261107_auto_update_parity/003_contracts.md index 5da7009d802..2905c02cfc5 100644 --- a/devlog/_plan/261107_auto_update_parity/003_contracts.md +++ b/devlog/_plan/261107_auto_update_parity/003_contracts.md @@ -103,8 +103,10 @@ role. Root-key entries have no release delegation fields. Allowed release roles are `release`, `tree`, `desktop-artifact`, `standalone-artifact` and `guardian-artifact`; threshold and unique-key checks apply separately to the role being verified. -Detached signatures carry `{keyFingerprint, signatureBox}` in the envelope -defined in `010` and authenticate the exact file bytes. Reject duplicate keys, duplicate JSON names, thresholds outside the +Detached signatures carry `{keyFingerprint, signatureBox}` in the role-specific +envelopes defined in `010` and authenticate the exact file bytes. Root +transitions use the distinct bounded transition envelope; release and tree +metadata use the ordinary envelope. Reject duplicate keys, duplicate JSON names, thresholds outside the unique key count, unknown fields and unsupported algorithms. Initial threshold is one pinned root key and one delegated release key; a feed cannot add a new root without the rotation rule above. The signature-envelope proposal and diff --git a/devlog/_plan/261107_auto_update_parity/010_signed_supply.md b/devlog/_plan/261107_auto_update_parity/010_signed_supply.md index 38de74cc113..127a4d996bb 100644 --- a/devlog/_plan/261107_auto_update_parity/010_signed_supply.md +++ b/devlog/_plan/261107_auto_update_parity/010_signed_supply.md @@ -70,8 +70,10 @@ the minisign global signature over the raw signature and trusted comment signature box for artifacts; do not invent a different cryptographic meaning for an existing `.sig` file. -For root, release and tree metadata, propose a separate closed -`ocx.update.signatures/1` JSON envelope `{schema, signatures}`. Each entry is +For release and tree metadata, propose a closed `ocx.update.signatures/1` JSON +envelope `{schema, signatures}`. Root transitions use the separate closed +`ocx.update.root-transition-signatures/1` envelope with the same entry shape. +Each entry is `{keyFingerprint, signatureBox}`, where `keyFingerprint` is lowercase SHA-256 of the 32-byte Ed25519 public key and `signatureBox` is canonical standard base64 of the four-line Tauri minisign box. Each signature authenticates the @@ -79,8 +81,13 @@ exact accompanying metadata file bytes; no parse-and-reserialize step occurs before verification. The expected metadata schema and verification role are chosen by the consumer and checked after cryptographic verification; a root record cannot be accepted as a release record. Limit root metadata to 64 KiB, -release metadata to 1 MiB, tree inventory to 16 MiB, signature envelope to -64 KiB, and keys/signatures to 16 per role. Reject duplicate fingerprints, +release metadata to 1 MiB and tree inventory to 16 MiB. Ordinary signature +envelopes are limited to 64 KiB and 16 signatures; transition envelopes are +limited to 256 KiB and 32 signatures. Each root key set remains limited to 16 +keys. A transition envelope may contain only distinct keys from the old/new +union; verify each set's threshold independently over the same successor bytes. +An overlapping key may count once for each set when its packet identifier +matches both root records. Reject duplicate fingerprints, noncanonical encodings, unknown algorithms, short packet IDs that disagree with the full authorized key, malformed UTF-8, invalid global comments, duplicate JSON keys and schema/role mismatches. Initial key threshold is one, as stated @@ -101,6 +108,8 @@ only when signatures by distinct keys meet both the current-root and proposed- root thresholds; write the validated root and high-water mark atomically before using newly delegated keys. Replayed or partially authorized root transitions, unknown channels, mismatched key IDs and an interrupted persistence step refuse. +Producer, acquisition, persisted replay and native-verifier tests must use the +transition-specific schema and cap; ordinary metadata must reject that schema. For desktop assets require a verified minisign trusted comment containing the matching signed version on both fresh and restored updates. The pinned plugin From 978b5125c85bee2708efa17d1ba7858faeffb68d Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:13:30 +0900 Subject: [PATCH 20/42] Bind update metadata evidence to signed targets --- scripts/test-layout/layout.json | 2 +- src/update/signed-supply.d.mts | 9 ++ src/update/signed-supply.mjs | 96 ++++++++++++ structure/runtime.md | 2 +- tests/fixtures/test-layout-expected.json | 2 +- tests/update/update-external-metadata.test.ts | 138 ++++++++++++++++++ 6 files changed, 246 insertions(+), 3 deletions(-) create mode 100644 tests/update/update-external-metadata.test.ts diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json index aff413792ed..0447ee21143 100644 --- a/scripts/test-layout/layout.json +++ b/scripts/test-layout/layout.json @@ -1837,7 +1837,7 @@ "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", "update-async-routes.test.ts": "server", - "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-root-snapshot.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", + "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-external-metadata.test.ts": "update", "update-minisign.test.ts": "update", "update-root-snapshot.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", "update-standalone.test.ts": "update", "update-worker-launch.test.ts": "update", "update-notify.test.ts": "update", "update-npm-cache-preflight.test.ts": "update", diff --git a/src/update/signed-supply.d.mts b/src/update/signed-supply.d.mts index 4b17114f8e8..6520a02f1cb 100644 --- a/src/update/signed-supply.d.mts +++ b/src/update/signed-supply.d.mts @@ -3,6 +3,9 @@ declare const rootTransition: unique symbol; declare const releaseEvidence: unique symbol; declare const targetEvidence: unique symbol; declare const artifactEvidence: unique symbol; +declare const receiptEvidence: unique symbol; +declare const treeEvidence: unique symbol; +declare const capabilityEvidence: unique symbol; /** In-process module-owned root handle; parsing a document does not create one. */ export interface RootEvidence { readonly [rootEvidence]: never } @@ -11,6 +14,9 @@ export type RootBasis = RootEvidence | VerifiedRootTransition; export interface ReleaseEvidence { readonly [releaseEvidence]: never } export interface TargetEvidence { readonly [targetEvidence]: never; readonly candidateId: string } export interface ArtifactEvidence { readonly [artifactEvidence]: never } +export interface ReceiptEvidence { readonly [receiptEvidence]: never } +export interface TreeEvidence { readonly [treeEvidence]: never } +export interface CapabilityEvidence { readonly [capabilityEvidence]: never } export interface TransitionSummary { readonly predecessorDigest: string; readonly predecessorRevision: number; readonly successorDigest: string; readonly successorRevision: number } export interface UpdateSelection { platform: "macos" | "linux" | "windows"; @@ -26,3 +32,6 @@ export function inspectTransition(transition: VerifiedRootTransition): Transitio export function verifyReleaseEvidence(bytes: Uint8Array, envelopeBytes: Uint8Array, rootBasis: RootBasis, expectedChannel: "latest" | "preview" | "nightly", nowMs: number): ReleaseEvidence; export function selectTargetEvidence(releaseEvidence: ReleaseEvidence, selection: UpdateSelection): TargetEvidence; export function verifyArtifactEvidence(target: TargetEvidence, bytes: Uint8Array, basis: RootBasis, nowMs: number): ArtifactEvidence; +export function verifyExternalMetadataEvidence(target: TargetEvidence, input: { kind: "receipt"; bytes: Uint8Array }, basis: RootBasis, nowMs: number): ReceiptEvidence; +export function verifyExternalMetadataEvidence(target: TargetEvidence, input: { kind: "tree"; bytes: Uint8Array; signatureEnvelopeBytes: Uint8Array; receiptEvidence: ReceiptEvidence }, basis: RootBasis, nowMs: number): TreeEvidence; +export function verifyExternalMetadataEvidence(target: TargetEvidence, input: { kind: "capability"; bytes: Uint8Array; receiptEvidence: ReceiptEvidence }, basis: RootBasis, nowMs: number): CapabilityEvidence; diff --git a/src/update/signed-supply.mjs b/src/update/signed-supply.mjs index daf9c5c6619..93fc4de8199 100644 --- a/src/update/signed-supply.mjs +++ b/src/update/signed-supply.mjs @@ -13,6 +13,9 @@ const TRANSITIONS = new WeakMap(); const RELEASES = new WeakMap(); const CANDIDATES = new WeakMap(); const ARTIFACTS = new WeakMap(); +const RECEIPTS = new WeakMap(); +const TREES = new WeakMap(); +const CAPABILITIES = new WeakMap(); function currentRoot(handle, nowMs) { if (!Number.isSafeInteger(nowMs) || nowMs < 0) throw new Error("Invalid trust clock"); @@ -122,3 +125,96 @@ export function verifyArtifactEvidence(targetEvidence, bytes, basis, nowMs) { ARTIFACTS.set(handle, { target: targetEvidence, basis, digest: target.artifact.sha256, size: snapshot.byteLength }); return handle; } + +function checkedBytes(bytes, expected, cap) { + if (expected.size > cap) throw new Error("Metadata size exceeds limit"); + const snapshot = snapshotUpdateBytes(bytes, expected.size); + if (snapshot.byteLength !== expected.size || createHash("sha256").update(snapshot).digest("hex") !== expected.sha256) { + throw new Error("Metadata bytes do not match signed record"); + } + return snapshot; +} + +function requireAsset(receipt, name, expected) { + const matches = receipt.assets.filter((asset) => asset.name === name); + if (matches.length !== 1 || (expected && (matches[0].sha256 !== expected.sha256 || matches[0].size !== expected.size))) { + throw new Error("Receipt asset mismatch"); + } + return matches[0]; +} + +/** Verify receipt, tree or capability evidence against one signed target and basis. */ +export function verifyExternalMetadataEvidence(targetEvidence, input, basis, nowMs) { + const state = currentRoot(basis, nowMs); + const candidate = CANDIDATES.get(targetEvidence); + if (!candidate || candidate.root !== basis) throw new Error("Invalid target evidence basis"); + const releaseState = RELEASES.get(candidate.release); + if (!releaseState || releaseState.root !== basis || !input || typeof input !== "object" || Array.isArray(input)) { + throw new Error("Invalid metadata evidence input"); + } + const release = releaseState.release; + const target = candidate.target; + const prefix = `ocx-update-${release.version}-${release.channel}-${target.id}`; + const treeName = `${prefix}.tree.json`; + const capabilityName = `${prefix}.capabilities.json`; + const descriptors = Object.getOwnPropertyDescriptors(input); + const kind = descriptors.kind && Object.hasOwn(descriptors.kind, "value") ? descriptors.kind.value : undefined; + const fields = kind === "receipt" ? ["kind", "bytes"] + : kind === "tree" ? ["kind", "bytes", "signatureEnvelopeBytes", "receiptEvidence"] + : kind === "capability" ? ["kind", "bytes", "receiptEvidence"] : []; + if (!fields.length || Reflect.ownKeys(descriptors).length !== fields.length + || !fields.every((field) => Object.hasOwn(descriptors, field) && descriptors[field].enumerable + && Object.hasOwn(descriptors[field], "value"))) { + throw new Error("Invalid metadata evidence input"); + } + const data = Object.fromEntries(fields.map((field) => [field, descriptors[field].value])); + if (kind === "receipt") { + const bytes = checkedBytes(data.bytes, release.receipt, 1048576); + const receipt = parseUpdateDocument(bytes, "ocx.update.verification/1"); + if (receipt.version !== release.version || receipt.channel !== release.channel || receipt.sourceCommit !== release.sourceCommit) { + throw new Error("Receipt release mismatch"); + } + requireAsset(receipt, target.assetName, target.artifact); + requireAsset(receipt, capabilityName, target.capabilities); + if (target.tree) { + requireAsset(receipt, treeName, target.tree); + requireAsset(receipt, `${treeName}.signatures.json`); + } + if (target.platform === "macos" && target.owner === "desktop" && target.artifactKind === "tauri" && target.bundleKind === "app-tar-gz") { + const proofs = receipt.universalProofs.filter((proof) => proof.assetName === target.assetName && proof.artifactSha256 === target.artifact.sha256); + if (proofs.length !== 1) throw new Error("Missing or ambiguous universal artifact proof"); + } else if (target.platform === "macos") { + const proofs = receipt.architectureProofs.filter((proof) => proof.targetId === target.id && proof.assetName === target.assetName + && proof.artifactSha256 === target.artifact.sha256 && proof.arch === target.arch); + if (proofs.length !== 1) throw new Error("Missing or ambiguous architecture proof"); + } + const handle = Object.freeze(Object.create(null)); + RECEIPTS.set(handle, { receipt, target: targetEvidence, basis }); + return handle; + } + const receiptState = RECEIPTS.get(data.receiptEvidence); + if (!receiptState || receiptState.target !== targetEvidence || receiptState.basis !== basis) throw new Error("Receipt evidence mismatch"); + if (kind === "tree") { + if (!target.tree) throw new Error("Target has no tree metadata"); + const treeBytes = checkedBytes(data.bytes, target.tree, 16777216); + const signatureEntry = requireAsset(receiptState.receipt, `${treeName}.signatures.json`); + const signatureBytes = checkedBytes(data.signatureEnvelopeBytes, signatureEntry, 65536); + const envelope = parseSignatureEnvelope(signatureBytes); + const keys = state.root.releaseKeys.filter((key) => key.channels.includes(release.channel) && key.roles.includes("tree")); + verifySignatureThreshold(treeBytes, envelope, keys, state.root.releaseThreshold); + const tree = parseUpdateDocument(treeBytes, "ocx.update.tree/1"); + if (tree.version !== release.version || tree.target !== target.id) throw new Error("Tree target mismatch"); + const handle = Object.freeze(Object.create(null)); + TREES.set(handle, { tree, target: targetEvidence, basis, receipt: data.receiptEvidence }); + return handle; + } + const bytes = checkedBytes(data.bytes, target.capabilities, 1048576); + const capability = parseUpdateDocument(bytes, "ocx.link-capabilities/1"); + if (capability.version !== release.version || capability.channel !== release.channel + || capability.target !== target.id || capability.artifactSha256 !== target.artifact.sha256) { + throw new Error("Capability target mismatch"); + } + const handle = Object.freeze(Object.create(null)); + CAPABILITIES.set(handle, { capability, target: targetEvidence, basis, receipt: data.receiptEvidence }); + return handle; +} diff --git a/structure/runtime.md b/structure/runtime.md index 6e8f04bdb88..15844e9c419 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity and a unique comment field. `signed-supply.mjs` snapshots input through `update-bytes.mjs` and returns opaque evidence for the embedded root, dual-threshold root transitions, signed releases, selected targets and matching signed artifact bytes; it does not persist trust or grant install or activation authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity and a unique comment field. `signed-supply.mjs` snapshots input through `update-bytes.mjs` and returns opaque evidence for the embedded root, dual-threshold root transitions, signed releases, targets, artifact bytes and bound receipt/tree/capability metadata; it does not persist trust or grant install or activation authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json index e4a0f997104..fd8a28e5fca 100644 --- a/tests/fixtures/test-layout-expected.json +++ b/tests/fixtures/test-layout-expected.json @@ -1442,7 +1442,7 @@ "types-barrel-identity.test.ts": "config", "ultrafast-tier-honesty.test.ts": "codex-integration", "configured-ultrafast-picker.test.ts": "codex-integration", "ultrafast-live-catalog.test.ts": "codex-integration", "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", - "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-minisign.test.ts": "update", "update-root-snapshot.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", + "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-external-metadata.test.ts": "update", "update-minisign.test.ts": "update", "update-root-snapshot.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", diff --git a/tests/update/update-external-metadata.test.ts b/tests/update/update-external-metadata.test.ts new file mode 100644 index 00000000000..f1cc9a9182d --- /dev/null +++ b/tests/update/update-external-metadata.test.ts @@ -0,0 +1,138 @@ +import { describe, expect, test } from "bun:test"; +import { createHash, generateKeyPairSync, sign } from "node:crypto"; +import { copyFileSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { pathToFileURL } from "node:url"; +import { repoPath } from "../helpers/repo-root"; +import { verifyExternalMetadataEvidence } from "../../src/update/signed-supply.mjs"; + +describe("external signed update metadata", () => { + test("binds receipt, tree signatures and capability bytes to one target and basis", async () => { + const dir = mkdtempSync(join(tmpdir(), "ocx-update-metadata-")); + try { + for (const name of ["signed-supply.mjs", "update-bytes.mjs", "update-contracts.mjs", "update-bounded-json.mjs", "update-candidate-id.mjs", "update-signed-version.mjs", "update-signature-threshold.mjs", "minisign.mjs"]) copyFileSync(repoPath("src/update", name), join(dir, name)); + const pair = generateKeyPairSync("ed25519"); + const raw = Buffer.from(pair.publicKey.export({ format: "der", type: "spki" })).subarray(-32); + const id = Buffer.alloc(8, 7); + const fingerprint = createHash("sha256").update(raw).digest("hex"); + const publicKey = Buffer.from(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), id, raw]).toString("base64")}\n`).toString("base64"); + const key = { keyId: fingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey }; + const otherPair = generateKeyPairSync("ed25519"); + const otherRaw = Buffer.from(otherPair.publicKey.export({ format: "der", type: "spki" })).subarray(-32); + const otherId = Buffer.alloc(8, 8); + const otherFingerprint = createHash("sha256").update(otherRaw).digest("hex"); + const otherPublicKey = Buffer.from(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), otherId, otherRaw]).toString("base64")}\n`).toString("base64"); + const otherKey = { keyId: otherFingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey: otherPublicKey }; + const root = Buffer.from(JSON.stringify({ schema: "ocx.update.root/1", revision: 1, expiresAt: "2030-01-01T00:00:00Z", rootKeys: [key], rootThreshold: 1, releaseKeys: [{ ...key, channels: ["latest"], roles: ["release", "tree"] }, { ...otherKey, channels: ["latest"], roles: ["release"] }], releaseThreshold: 1, channels: ["latest"] })); + writeFileSync(join(dir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${createHash("sha256").update(root).digest("hex")}";\n`); + const fixture = await import(pathToFileURL(join(dir, "signed-supply.mjs")).href); + const signBox = (bytes: Buffer, privateKey = pair.privateKey, packetId = id) => { + const signature = sign(null, createHash("blake2b512").update(bytes).digest(), privateKey); + const global = sign(null, Buffer.concat([signature, Buffer.from("version:1.2.3")]), privateKey); + const packet = Buffer.concat([Buffer.from("ED"), packetId, signature]).toString("base64"); + return Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: version:1.2.3\n${global.toString("base64")}\n`).toString("base64"); + }; + const envelope = (bytes: Buffer, pretty = false) => Buffer.from(JSON.stringify({ schema: "ocx.update.signatures/1", signatures: [{ keyFingerprint: fingerprint, signatureBox: signBox(bytes) }] }, null, pretty ? 2 : undefined)); + const digest = (bytes: Buffer) => ({ sha256: createHash("sha256").update(bytes).digest("hex"), size: bytes.length }); + const artifact = Buffer.from("fixture archive"); + const target = "linux-x64-npm"; + const assetName = `ocx-update-1.2.3-latest-${target}.tar.gz`; + const treeName = `ocx-update-1.2.3-latest-${target}.tree.json`; + const capName = `ocx-update-1.2.3-latest-${target}.capabilities.json`; + const tree = Buffer.from(JSON.stringify({ schema: "ocx.update.tree/1", version: "1.2.3", target, entries: [{ path: "file", type: "file", mode: 420, size: 0, sha256: "a".repeat(64) }] })); + const treeEnvelope = envelope(tree); + const capability = Buffer.from(JSON.stringify({ schema: "ocx.link-capabilities/1", version: "1.2.3", channel: "latest", target, artifactSha256: digest(artifact).sha256, homeProvides: [], childRequires: [], updateActions: [], installerAdapters: [], recoveryProtocols: [], fleetJournalReaders: [], compatibilityEpoch: 1, compatibilityVectorSha256: "b".repeat(64) })); + const assets = [[assetName, artifact], [treeName, tree], [`${treeName}.signatures.json`, treeEnvelope], [capName, capability]].map(([name, bytes]) => ({ name, ...digest(bytes as Buffer) })).sort((a, b) => String(a.name) < String(b.name) ? -1 : 1); + const receipt = Buffer.from(JSON.stringify({ schema: "ocx.update.verification/1", sourceCommit: "c".repeat(40), version: "1.2.3", channel: "latest", workflowRunId: 1, workflowAttempt: 1, versionSources: ["package.json", "desktop/src-tauri/tauri.conf.json", "desktop/src-tauri/Cargo.toml", "desktop/src-tauri/Cargo.lock"].map(path => ({ path, sha256: "d".repeat(64) })), assets, universalProofs: [], architectureProofs: [] })); + const release = Buffer.from(JSON.stringify({ schema: "ocx.update.release/1", version: "1.2.3", channel: "latest", sequence: 1, sourceCommit: "c".repeat(40), rolloutNotBefore: "2026-01-01T00:00:00Z", receipt: digest(receipt), releaseNotes: [], targets: [{ id: target, platform: "linux", arch: "x64", owner: "npm", artifactKind: "tree", bundleKind: "tar-gz", assetName, artifact: { ...digest(artifact), signatureBox: signBox(artifact), signerFingerprint: fingerprint }, tree: digest(tree), capabilities: digest(capability) }] })); + const now = Date.parse("2027-01-01T00:00:00Z"); + const basis = fixture.bootstrapEmbeddedRoot(root, now); + const releaseEvidence = fixture.verifyReleaseEvidence(release, envelope(release), basis, "latest", now); + const selection = { platform: "linux", arch: "x64", owner: "npm", artifactKind: "tree", bundleKind: "tar-gz" }; + const candidate = fixture.selectTargetEvidence(releaseEvidence, selection); + const receiptEvidence = fixture.verifyExternalMetadataEvidence(candidate, { kind: "receipt", bytes: receipt }, basis, now); + const treeEvidence = fixture.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: tree, signatureEnvelopeBytes: treeEnvelope, receiptEvidence }, basis, now); + const capabilityEvidence = fixture.verifyExternalMetadataEvidence(candidate, { kind: "capability", bytes: capability, receiptEvidence }, basis, now); + expect(Object.isFrozen(receiptEvidence)).toBe(true); + expect(Object.isFrozen(treeEvidence)).toBe(true); + expect(Object.isFrozen(capabilityEvidence)).toBe(true); + expect(() => fixture.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: tree, signatureEnvelopeBytes: envelope(tree, true), receiptEvidence }, basis, now)).toThrow(); + expect(() => fixture.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: Buffer.from("changed"), signatureEnvelopeBytes: treeEnvelope, receiptEvidence }, basis, now)).toThrow(); + expect(() => fixture.verifyExternalMetadataEvidence(candidate, { kind: "capability", bytes: Buffer.from("changed"), receiptEvidence }, basis, now)).toThrow(); + expect(() => fixture.verifyExternalMetadataEvidence(candidate, { kind: "capability", bytes: capability, receiptEvidence, signatureEnvelopeBytes: treeEnvelope }, basis, now)).toThrow(); + expect(() => fixture.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: tree, receiptEvidence }, basis, now)).toThrow(); + expect(() => fixture.verifyExternalMetadataEvidence(candidate, { kind: "receipt", bytes: receipt }, fixture.bootstrapEmbeddedRoot(root, now), now)).toThrow(); + const accessorInput = { kind: "capability", get bytes() { throw new Error("getter invoked"); }, receiptEvidence }; + expect(() => fixture.verifyExternalMetadataEvidence(candidate, accessorInput, basis, now)).toThrow(/Invalid metadata evidence input/); + expect(() => fixture.verifyExternalMetadataEvidence(fixture.selectTargetEvidence(releaseEvidence, selection), { kind: "tree", bytes: tree, signatureEnvelopeBytes: treeEnvelope, receiptEvidence }, basis, now)).toThrow(); + expect(() => verifyExternalMetadataEvidence(candidate, { kind: "receipt", bytes: receipt }, basis, now)).toThrow(); + const wrongSignatureEnvelope = envelope(Buffer.from("different tree bytes")); + const wrongSignatureReceipt = JSON.parse(receipt.toString()); + Object.assign(wrongSignatureReceipt.assets.find((entry: {name: string}) => entry.name === `${treeName}.signatures.json`), digest(wrongSignatureEnvelope)); + const wrongSignatureReceiptBytes = Buffer.from(JSON.stringify(wrongSignatureReceipt)); + const wrongSignatureRelease = Buffer.from(JSON.stringify({ ...JSON.parse(release.toString()), receipt: digest(wrongSignatureReceiptBytes) })); + const wrongSignatureReleaseEvidence = fixture.verifyReleaseEvidence(wrongSignatureRelease, envelope(wrongSignatureRelease), basis, "latest", now); + const wrongSignatureCandidate = fixture.selectTargetEvidence(wrongSignatureReleaseEvidence, selection); + const wrongSignatureReceiptEvidence = fixture.verifyExternalMetadataEvidence(wrongSignatureCandidate, { kind: "receipt", bytes: wrongSignatureReceiptBytes }, basis, now); + expect(() => fixture.verifyExternalMetadataEvidence(wrongSignatureCandidate, { kind: "tree", bytes: tree, signatureEnvelopeBytes: wrongSignatureEnvelope, receiptEvidence: wrongSignatureReceiptEvidence }, basis, now)).toThrow(); + const wrongRoleEnvelope = Buffer.from(JSON.stringify({ schema: "ocx.update.signatures/1", signatures: [{ keyFingerprint: otherFingerprint, signatureBox: signBox(tree, otherPair.privateKey, otherId) }] })); + const wrongRoleReceipt = JSON.parse(receipt.toString()); + Object.assign(wrongRoleReceipt.assets.find((entry: {name: string}) => entry.name === `${treeName}.signatures.json`), digest(wrongRoleEnvelope)); + const wrongRoleReceiptBytes = Buffer.from(JSON.stringify(wrongRoleReceipt)); + const wrongRoleRelease = Buffer.from(JSON.stringify({ ...JSON.parse(release.toString()), receipt: digest(wrongRoleReceiptBytes) })); + const wrongRoleReleaseEvidence = fixture.verifyReleaseEvidence(wrongRoleRelease, envelope(wrongRoleRelease), basis, "latest", now); + const wrongRoleCandidate = fixture.selectTargetEvidence(wrongRoleReleaseEvidence, selection); + const wrongRoleReceiptEvidence = fixture.verifyExternalMetadataEvidence(wrongRoleCandidate, { kind: "receipt", bytes: wrongRoleReceiptBytes }, basis, now); + expect(() => fixture.verifyExternalMetadataEvidence(wrongRoleCandidate, { kind: "tree", bytes: tree, signatureEnvelopeBytes: wrongRoleEnvelope, receiptEvidence: wrongRoleReceiptEvidence }, basis, now)).toThrow(); + const wrongTargetCapability = Buffer.from(JSON.stringify({ ...JSON.parse(capability.toString()), target: "linux-arm64-npm" })); + const wrongTargetReceipt = JSON.parse(receipt.toString()); + Object.assign(wrongTargetReceipt.assets.find((entry: {name: string}) => entry.name === capName), digest(wrongTargetCapability)); + const wrongTargetReceiptBytes = Buffer.from(JSON.stringify(wrongTargetReceipt)); + const wrongTargetReleaseObject = JSON.parse(release.toString()); + wrongTargetReleaseObject.receipt = digest(wrongTargetReceiptBytes); + wrongTargetReleaseObject.targets[0].capabilities = digest(wrongTargetCapability); + const wrongTargetRelease = Buffer.from(JSON.stringify(wrongTargetReleaseObject)); + const wrongTargetReleaseEvidence = fixture.verifyReleaseEvidence(wrongTargetRelease, envelope(wrongTargetRelease), basis, "latest", now); + const wrongTargetCandidate = fixture.selectTargetEvidence(wrongTargetReleaseEvidence, selection); + const wrongTargetReceiptEvidence = fixture.verifyExternalMetadataEvidence(wrongTargetCandidate, { kind: "receipt", bytes: wrongTargetReceiptBytes }, basis, now); + expect(() => fixture.verifyExternalMetadataEvidence(wrongTargetCandidate, { kind: "capability", bytes: wrongTargetCapability, receiptEvidence: wrongTargetReceiptEvidence }, basis, now)).toThrow(); + + // Desktop's shared macOS archive requires universal proof for either target. + for (const arch of ["x64", "arm64"]) { + const macTarget = `macos-${arch}-desktop-tauri`; + const macAsset = "OpenCodex-1.2.3-macos.app.tar.gz"; + const macCapName = `ocx-update-1.2.3-latest-${macTarget}.capabilities.json`; + const macCapability = Buffer.from(JSON.stringify({ ...JSON.parse(capability.toString()), target: macTarget })); + const makeMacCandidate = (proofs: unknown[]) => { + const macReceipt = Buffer.from(JSON.stringify({ ...JSON.parse(receipt.toString()), assets: [{ name: macAsset, ...digest(artifact) }, { name: macCapName, ...digest(macCapability) }].sort((a, b) => a.name < b.name ? -1 : 1), universalProofs: proofs })); + const macRelease = Buffer.from(JSON.stringify({ ...JSON.parse(release.toString()), receipt: digest(macReceipt), targets: [{ id: macTarget, platform: "macos", arch, owner: "desktop", artifactKind: "tauri", bundleKind: "app-tar-gz", assetName: macAsset, artifact: { ...digest(artifact), signatureBox: signBox(artifact), signerFingerprint: fingerprint }, tree: null, capabilities: digest(macCapability) }] })); + const macReleaseEvidence = fixture.verifyReleaseEvidence(macRelease, envelope(macRelease), basis, "latest", now); + return { macReceipt, macCandidate: fixture.selectTargetEvidence(macReleaseEvidence, { platform: "macos", arch, owner: "desktop", artifactKind: "tauri", bundleKind: "app-tar-gz" }) }; + }; + const proof = { assetName: macAsset, artifactSha256: digest(artifact).sha256, architectures: ["arm64", "x64"], inspectionSha256: "e".repeat(64) }; + const valid = makeMacCandidate([proof]); + expect(() => fixture.verifyExternalMetadataEvidence(valid.macCandidate, { kind: "receipt", bytes: valid.macReceipt }, basis, now)).not.toThrow(); + const missing = makeMacCandidate([]); + expect(() => fixture.verifyExternalMetadataEvidence(missing.macCandidate, { kind: "receipt", bytes: missing.macReceipt }, basis, now)).toThrow(); + const wrong = makeMacCandidate([{ ...proof, artifactSha256: "f".repeat(64) }]); + expect(() => fixture.verifyExternalMetadataEvidence(wrong.macCandidate, { kind: "receipt", bytes: wrong.macReceipt }, basis, now)).toThrow(); + } + const standaloneTarget = "macos-x64-standalone"; + const standaloneAsset = "ocx-1.2.3-bun-darwin-x64.tar.gz"; + const standaloneTreeName = `ocx-update-1.2.3-latest-${standaloneTarget}.tree.json`; + const standaloneCapName = `ocx-update-1.2.3-latest-${standaloneTarget}.capabilities.json`; + const standaloneTree = Buffer.from(JSON.stringify({ ...JSON.parse(tree.toString()), target: standaloneTarget })); + const standaloneEnvelope = envelope(standaloneTree); + const standaloneCapability = Buffer.from(JSON.stringify({ ...JSON.parse(capability.toString()), target: standaloneTarget })); + const standaloneAssets = [[standaloneAsset, artifact], [standaloneTreeName, standaloneTree], [`${standaloneTreeName}.signatures.json`, standaloneEnvelope], [standaloneCapName, standaloneCapability]].map(([name, bytes]) => ({ name, ...digest(bytes as Buffer) })).sort((a, b) => String(a.name) < String(b.name) ? -1 : 1); + const standaloneReceipt = Buffer.from(JSON.stringify({ ...JSON.parse(receipt.toString()), assets: standaloneAssets, universalProofs: [], architectureProofs: [{ targetId: standaloneTarget, assetName: standaloneAsset, artifactSha256: digest(artifact).sha256, arch: "x64", inspectionSha256: "f".repeat(64) }] })); + const standaloneRelease = Buffer.from(JSON.stringify({ ...JSON.parse(release.toString()), receipt: digest(standaloneReceipt), targets: [{ id: standaloneTarget, platform: "macos", arch: "x64", owner: "standalone", artifactKind: "standalone", bundleKind: "tar-gz", assetName: standaloneAsset, artifact: { ...digest(artifact), signatureBox: signBox(artifact), signerFingerprint: fingerprint }, tree: digest(standaloneTree), capabilities: digest(standaloneCapability) }] })); + const standaloneReleaseEvidence = fixture.verifyReleaseEvidence(standaloneRelease, envelope(standaloneRelease), basis, "latest", now); + const standaloneCandidate = fixture.selectTargetEvidence(standaloneReleaseEvidence, { platform: "macos", arch: "x64", owner: "standalone", artifactKind: "standalone", bundleKind: "tar-gz" }); + expect(() => fixture.verifyExternalMetadataEvidence(standaloneCandidate, { kind: "receipt", bytes: standaloneReceipt }, basis, now)).not.toThrow(); + } finally { + rmSync(dir, { recursive: true, force: true }); + } + }); +}); From 3dc5bc402cf6447296abbeeb88977c5aff3fb92a Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:18:54 +0900 Subject: [PATCH 21/42] Cover signed metadata binding failures --- tests/update/update-external-metadata.test.ts | 77 ++++++++++++++++++- 1 file changed, 76 insertions(+), 1 deletion(-) diff --git a/tests/update/update-external-metadata.test.ts b/tests/update/update-external-metadata.test.ts index f1cc9a9182d..03b8ba1dd8e 100644 --- a/tests/update/update-external-metadata.test.ts +++ b/tests/update/update-external-metadata.test.ts @@ -1,6 +1,6 @@ import { describe, expect, test } from "bun:test"; import { createHash, generateKeyPairSync, sign } from "node:crypto"; -import { copyFileSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; +import { copyFileSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { pathToFileURL } from "node:url"; @@ -98,6 +98,53 @@ describe("external signed update metadata", () => { const wrongTargetReceiptEvidence = fixture.verifyExternalMetadataEvidence(wrongTargetCandidate, { kind: "receipt", bytes: wrongTargetReceiptBytes }, basis, now); expect(() => fixture.verifyExternalMetadataEvidence(wrongTargetCandidate, { kind: "capability", bytes: wrongTargetCapability, receiptEvidence: wrongTargetReceiptEvidence }, basis, now)).toThrow(); + // Re-sign the enclosing release so each refusal reaches the receipt binding. + for (const [name, change] of [ + [assetName, "missing"], [assetName, "digest"], [capName, "missing"], + [capName, "size"], [treeName, "missing"], [`${treeName}.signatures.json`, "missing"], + ]) { + const altered = JSON.parse(receipt.toString()); + if (change === "missing") altered.assets = altered.assets.filter((entry: {name: string}) => entry.name !== name); + else { + const entry = altered.assets.find((item: {name: string}) => item.name === name); + if (change === "digest") entry.sha256 = "f".repeat(64); else entry.size++; + } + const bytes = Buffer.from(JSON.stringify(altered)); + const signedRelease = Buffer.from(JSON.stringify({ ...JSON.parse(release.toString()), receipt: digest(bytes) })); + const evidence = fixture.verifyReleaseEvidence(signedRelease, envelope(signedRelease), basis, "latest", now); + const selected = fixture.selectTargetEvidence(evidence, selection); + expect(() => fixture.verifyExternalMetadataEvidence(selected, { kind: "receipt", bytes }, basis, now)).toThrow(/Receipt asset mismatch/); + } + + // Descriptors and receipt entries match the bytes, so these cases exercise + // semantic bindings rather than failing the earlier digest checks. + for (const [field, value] of [["version", "1.2.4"], ["channel", "preview"], ["artifactSha256", "f".repeat(64)]]) { + const bytes = Buffer.from(JSON.stringify({ ...JSON.parse(capability.toString()), [field]: value })); + const altered = JSON.parse(receipt.toString()); + Object.assign(altered.assets.find((entry: {name: string}) => entry.name === capName), digest(bytes)); + const receiptBytes = Buffer.from(JSON.stringify(altered)); + const signed = JSON.parse(release.toString()); + signed.receipt = digest(receiptBytes); + signed.targets[0].capabilities = digest(bytes); + const signedBytes = Buffer.from(JSON.stringify(signed)); + const selected = fixture.selectTargetEvidence(fixture.verifyReleaseEvidence(signedBytes, envelope(signedBytes), basis, "latest", now), selection); + const acceptedReceipt = fixture.verifyExternalMetadataEvidence(selected, { kind: "receipt", bytes: receiptBytes }, basis, now); + expect(() => fixture.verifyExternalMetadataEvidence(selected, { kind: "capability", bytes, receiptEvidence: acceptedReceipt }, basis, now)).toThrow(/Capability target mismatch/); + } + const wrongTree = Buffer.from(JSON.stringify({ ...JSON.parse(tree.toString()), version: "1.2.4" })); + const wrongTreeEnvelope = envelope(wrongTree); + const wrongTreeReceipt = JSON.parse(receipt.toString()); + Object.assign(wrongTreeReceipt.assets.find((entry: {name: string}) => entry.name === treeName), digest(wrongTree)); + Object.assign(wrongTreeReceipt.assets.find((entry: {name: string}) => entry.name === `${treeName}.signatures.json`), digest(wrongTreeEnvelope)); + const wrongTreeReceiptBytes = Buffer.from(JSON.stringify(wrongTreeReceipt)); + const wrongTreeRelease = JSON.parse(release.toString()); + wrongTreeRelease.receipt = digest(wrongTreeReceiptBytes); + wrongTreeRelease.targets[0].tree = digest(wrongTree); + const wrongTreeReleaseBytes = Buffer.from(JSON.stringify(wrongTreeRelease)); + const wrongTreeCandidate = fixture.selectTargetEvidence(fixture.verifyReleaseEvidence(wrongTreeReleaseBytes, envelope(wrongTreeReleaseBytes), basis, "latest", now), selection); + const wrongTreeReceiptEvidence = fixture.verifyExternalMetadataEvidence(wrongTreeCandidate, { kind: "receipt", bytes: wrongTreeReceiptBytes }, basis, now); + expect(() => fixture.verifyExternalMetadataEvidence(wrongTreeCandidate, { kind: "tree", bytes: wrongTree, signatureEnvelopeBytes: wrongTreeEnvelope, receiptEvidence: wrongTreeReceiptEvidence }, basis, now)).toThrow(/Tree target mismatch/); + // Desktop's shared macOS archive requires universal proof for either target. for (const arch of ["x64", "arm64"]) { const macTarget = `macos-${arch}-desktop-tauri`; @@ -131,6 +178,34 @@ describe("external signed update metadata", () => { const standaloneReleaseEvidence = fixture.verifyReleaseEvidence(standaloneRelease, envelope(standaloneRelease), basis, "latest", now); const standaloneCandidate = fixture.selectTargetEvidence(standaloneReleaseEvidence, { platform: "macos", arch: "x64", owner: "standalone", artifactKind: "standalone", bundleKind: "tar-gz" }); expect(() => fixture.verifyExternalMetadataEvidence(standaloneCandidate, { kind: "receipt", bytes: standaloneReceipt }, basis, now)).not.toThrow(); + for (const proofs of [[], [{ ...JSON.parse(standaloneReceipt.toString()).architectureProofs[0], arch: "arm64" }]]) { + const bytes = Buffer.from(JSON.stringify({ ...JSON.parse(standaloneReceipt.toString()), architectureProofs: proofs })); + const signedBytes = Buffer.from(JSON.stringify({ ...JSON.parse(standaloneRelease.toString()), receipt: digest(bytes) })); + const selected = fixture.selectTargetEvidence(fixture.verifyReleaseEvidence(signedBytes, envelope(signedBytes), basis, "latest", now), { platform: "macos", arch: "x64", owner: "standalone", artifactKind: "standalone", bundleKind: "tar-gz" }); + expect(() => fixture.verifyExternalMetadataEvidence(selected, { kind: "receipt", bytes }, basis, now)).toThrow(/architecture proof/); + } + + // A two-key root requires both tree signatures, independently of the + // enclosing receipt's authenticated envelope digest. + const thresholdDir = join(dir, "threshold"); + mkdirSync(thresholdDir); + for (const name of ["signed-supply.mjs", "update-bytes.mjs", "update-contracts.mjs", "update-bounded-json.mjs", "update-candidate-id.mjs", "update-signed-version.mjs", "update-signature-threshold.mjs", "minisign.mjs"]) copyFileSync(repoPath("src/update", name), join(thresholdDir, name)); + const thresholdRoot = Buffer.from(JSON.stringify({ ...JSON.parse(root.toString()), releaseKeys: [{ ...key, channels: ["latest"], roles: ["release", "tree"] }, { ...otherKey, channels: ["latest"], roles: ["release", "tree"] }], releaseThreshold: 2 })); + writeFileSync(join(thresholdDir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${createHash("sha256").update(thresholdRoot).digest("hex")}";\n`); + const thresholdFixture = await import(pathToFileURL(join(thresholdDir, "signed-supply.mjs")).href); + const thresholdBasis = thresholdFixture.bootstrapEmbeddedRoot(thresholdRoot, now); + const thresholdEnvelope = (bytes: Buffer, two: boolean) => Buffer.from(JSON.stringify({ schema: "ocx.update.signatures/1", signatures: [{ keyFingerprint: fingerprint, signatureBox: signBox(bytes) }, ...(two ? [{ keyFingerprint: otherFingerprint, signatureBox: signBox(bytes, otherPair.privateKey, otherId) }] : [])] })); + for (const two of [false, true]) { + const signatureBytes = thresholdEnvelope(tree, two); + const altered = JSON.parse(receipt.toString()); + Object.assign(altered.assets.find((entry: {name: string}) => entry.name === `${treeName}.signatures.json`), digest(signatureBytes)); + const receiptBytes = Buffer.from(JSON.stringify(altered)); + const signedBytes = Buffer.from(JSON.stringify({ ...JSON.parse(release.toString()), receipt: digest(receiptBytes) })); + const selected = thresholdFixture.selectTargetEvidence(thresholdFixture.verifyReleaseEvidence(signedBytes, thresholdEnvelope(signedBytes, true), thresholdBasis, "latest", now), selection); + const acceptedReceipt = thresholdFixture.verifyExternalMetadataEvidence(selected, { kind: "receipt", bytes: receiptBytes }, thresholdBasis, now); + const verify = () => thresholdFixture.verifyExternalMetadataEvidence(selected, { kind: "tree", bytes: tree, signatureEnvelopeBytes: signatureBytes, receiptEvidence: acceptedReceipt }, thresholdBasis, now); + if (two) expect(verify).not.toThrow(); else expect(verify).toThrow(); + } } finally { rmSync(dir, { recursive: true, force: true }); } From 652bd8c8b3f94b14b9d59fd83f23e3dc323ba4ec Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:20:32 +0900 Subject: [PATCH 22/42] Verify root transition signer unions --- src/update/signed-supply.mjs | 21 +++++-- src/update/update-contracts.d.mts | 3 +- src/update/update-contracts.mjs | 6 +- tests/update/update-contracts.test.ts | 10 +++- tests/update/update-signed-supply.test.ts | 67 ++++++++++++++++++++--- 5 files changed, 92 insertions(+), 15 deletions(-) diff --git a/src/update/signed-supply.mjs b/src/update/signed-supply.mjs index 93fc4de8199..e952bca1017 100644 --- a/src/update/signed-supply.mjs +++ b/src/update/signed-supply.mjs @@ -41,14 +41,27 @@ export function bootstrapEmbeddedRoot(bytes, nowMs) { export function verifyRootTransition(predecessorBasis, bytes, envelopeBytes, nowMs) { const previous = currentRoot(predecessorBasis, nowMs); const nextBytes = snapshotUpdateBytes(bytes, 65536); - const signatureBytes = snapshotUpdateBytes(envelopeBytes, 65536); - const envelope = parseSignatureEnvelope(signatureBytes); - verifySignatureThreshold(nextBytes, envelope, previous.root.rootKeys, previous.root.rootThreshold); + const signatureBytes = snapshotUpdateBytes(envelopeBytes, 262144); + const envelope = parseUpdateDocument(signatureBytes, "ocx.update.root-transition-signatures/1"); const root = parseUpdateDocument(nextBytes, "ocx.update.root/1"); if (root.revision <= previous.root.revision || Date.parse(root.expiresAt) <= nowMs) { throw new Error("Invalid successor root"); } - verifySignatureThreshold(nextBytes, envelope, root.rootKeys, root.rootThreshold); + const oldKeys = new Map(previous.root.rootKeys.map((key) => [key.keyId, key])); + const newKeys = new Map(root.rootKeys.map((key) => [key.keyId, key])); + for (const [fingerprint, oldKey] of oldKeys) { + const newKey = newKeys.get(fingerprint); + if (newKey) { + const decode = (key) => decodePublicKey(Buffer.from(key.publicKey, "base64").toString("utf8")); + if (decode(oldKey).keyId !== decode(newKey).keyId) throw new Error("Incompatible root key packet identifiers"); + } + } + if (envelope.signatures.some((signature) => !oldKeys.has(signature.keyFingerprint) && !newKeys.has(signature.keyFingerprint))) { + throw new Error("Unknown root transition signer"); + } + const subset = (keys) => ({ signatures: envelope.signatures.filter((signature) => keys.has(signature.keyFingerprint)) }); + verifySignatureThreshold(nextBytes, subset(oldKeys), previous.root.rootKeys, previous.root.rootThreshold); + verifySignatureThreshold(nextBytes, subset(newKeys), root.rootKeys, root.rootThreshold); const digest = createHash("sha256").update(nextBytes).digest("hex"); const handle = Object.freeze(Object.create(null)); TRANSITIONS.set(handle, { root, bytes: nextBytes, digest, predecessorDigest: previous.digest, diff --git a/src/update/update-contracts.d.mts b/src/update/update-contracts.d.mts index 28e0bc0eb65..d8afad6d8ca 100644 --- a/src/update/update-contracts.d.mts +++ b/src/update/update-contracts.d.mts @@ -6,6 +6,7 @@ export interface RootKey { keyId: string; algorithm: "minisign-ed25519-blake2b51 export interface ReleaseKey extends RootKey { channels: Channel[]; roles: UpdateRole[] } export interface UpdateRoot { schema: "ocx.update.root/1"; revision: number; expiresAt: string; rootKeys: RootKey[]; rootThreshold: number; releaseKeys: ReleaseKey[]; releaseThreshold: number; channels: Channel[] } export interface SignatureEnvelope { schema: "ocx.update.signatures/1"; signatures: { keyFingerprint: string; signatureBox: string }[] } +export interface RootTransitionEnvelope { schema: "ocx.update.root-transition-signatures/1"; signatures: { keyFingerprint: string; signatureBox: string }[] } export interface UpdateTarget { id: string; platform: "macos" | "linux" | "windows"; arch: "x64" | "arm64"; owner: "desktop" | "npm" | "pnpm" | "bun" | "standalone"; artifactKind: "tauri" | "tree" | "standalone" | "guardian"; bundleKind: "app-tar-gz" | "msi" | "appimage" | "deb" | "zip" | "tar-gz" | "binary"; assetName: string; artifact: DigestSize & { signatureBox: string; signerFingerprint: string }; tree: DigestSize | null; capabilities: DigestSize } export interface UpdateRelease { schema: "ocx.update.release/1"; version: string; channel: Channel; sequence: number; sourceCommit: string; rolloutNotBefore: string; receipt: DigestSize; releaseNotes: {title: string; body: string}[]; targets: UpdateTarget[] } export interface UpdateReceipt { schema: "ocx.update.verification/1"; sourceCommit: string; version: string; channel: Channel; workflowRunId: number; workflowAttempt: number; versionSources: {path: string; sha256: string}[]; assets: {name: string; sha256: string; size: number}[]; universalProofs: {assetName: string; artifactSha256: string; architectures: ["arm64", "x64"]; inspectionSha256: string}[]; architectureProofs: {targetId: string; assetName: string; artifactSha256: string; arch: "arm64" | "x64"; inspectionSha256: string}[] } @@ -17,6 +18,6 @@ export interface UpdatePolicy {schema: "ocx.update.policy/1"; revision: number; export type OwnerKind = "desktop" | "service" | "unmanaged"; export interface UpdatePrepared {schema: "ocx.update.prepared/1"; operationId: string; candidateDigest: string; stageIdentity: string; stageDigest: string; installationId: string; ownerKind: OwnerKind; policyRevision: number} export type UpdateActivation = {schema: "ocx.update.activation/1"; operationId: string; generation: number; runtimeInstance: string; pid: number; port: number; installationId: string; ownerKind: OwnerKind; candidateDigest: string; stageDigest: string; policyRevision: number; deadlineMs: number} & ({action: "reserve" | "inspect"} | {action: "commit" | "cancel"; permit: string}); -export interface UpdateDocumentSchemas {"ocx.update.root/1": UpdateRoot; "ocx.update.signatures/1": SignatureEnvelope; "ocx.update.release/1": UpdateRelease; "ocx.update.verification/1": UpdateReceipt; "ocx.update.tree/1": UpdateTree; "ocx.link-capabilities/1": UpdateCapabilities; "ocx.update.policy/1": UpdatePolicy; "ocx.update.prepared/1": UpdatePrepared; "ocx.update.activation/1": UpdateActivation} +export interface UpdateDocumentSchemas {"ocx.update.root/1": UpdateRoot; "ocx.update.signatures/1": SignatureEnvelope; "ocx.update.root-transition-signatures/1": RootTransitionEnvelope; "ocx.update.release/1": UpdateRelease; "ocx.update.verification/1": UpdateReceipt; "ocx.update.tree/1": UpdateTree; "ocx.link-capabilities/1": UpdateCapabilities; "ocx.update.policy/1": UpdatePolicy; "ocx.update.prepared/1": UpdatePrepared; "ocx.update.activation/1": UpdateActivation} export function parseUpdateDocument(bytes: Uint8Array, expectedSchema: S): UpdateDocumentSchemas[S]; export function parseSignatureEnvelope(bytes: Uint8Array): SignatureEnvelope; diff --git a/src/update/update-contracts.mjs b/src/update/update-contracts.mjs index 3c4e7f5a832..d894a289117 100644 --- a/src/update/update-contracts.mjs +++ b/src/update/update-contracts.mjs @@ -5,6 +5,7 @@ import { sameSignedVersion } from "./update-signed-version.mjs"; const CAPS = Object.freeze({ "ocx.update.root/1": 65536, "ocx.update.signatures/1": 65536, + "ocx.update.root-transition-signatures/1": 262144, "ocx.update.release/1": 1048576, "ocx.update.verification/1": 1048576, "ocx.update.tree/1": 16777216, "ocx.link-capabilities/1": 1048576, "ocx.update.policy/1": 4096, "ocx.update.prepared/1": 8192, @@ -75,8 +76,8 @@ function root(v) { } } } -function envelope(v) { - exact(obj(v, ["schema", "signatures"]) && array(v.signatures, 1, 16)); +function envelope(v, limit = 16) { + exact(obj(v, ["schema", "signatures"]) && array(v.signatures, 1, limit)); for (const entry of v.signatures) { exact(obj(entry, ["keyFingerprint", "signatureBox"]) && hash(entry.keyFingerprint)); signature(entry.signatureBox); } @@ -187,6 +188,7 @@ function activation(v) { } const VALIDATORS = Object.freeze({ "ocx.update.root/1": root, "ocx.update.signatures/1": envelope, + "ocx.update.root-transition-signatures/1": (value) => envelope(value, 32), "ocx.update.release/1": release, "ocx.update.verification/1": receipt, "ocx.update.tree/1": tree, "ocx.link-capabilities/1": capability, "ocx.update.policy/1": policy, "ocx.update.prepared/1": prepared, diff --git a/tests/update/update-contracts.test.ts b/tests/update/update-contracts.test.ts index e5f08cc9905..2188f553f82 100644 --- a/tests/update/update-contracts.test.ts +++ b/tests/update/update-contracts.test.ts @@ -38,6 +38,7 @@ function fixtures(): Record { return { "ocx.update.root/1": {schema: "ocx.update.root/1", revision: 1, expiresAt: "2000-02-29T12:00:00Z", rootKeys: [key], rootThreshold: 1, releaseKeys: [{...key, channels: ["latest"], roles: ["release", "tree", "desktop-artifact", "standalone-artifact", "guardian-artifact"]}], releaseThreshold: 1, channels: ["latest"]}, "ocx.update.signatures/1": {schema: "ocx.update.signatures/1", signatures: [{keyFingerprint: fingerprint, signatureBox: box}]}, + "ocx.update.root-transition-signatures/1": {schema: "ocx.update.root-transition-signatures/1", signatures: [{keyFingerprint: fingerprint, signatureBox: box}]}, "ocx.update.release/1": {schema: "ocx.update.release/1", version: "1.2.3", channel: "latest", sequence: 1, sourceCommit: "b".repeat(40), rolloutNotBefore: "2028-02-29T00:00:00Z", receipt: {...digest}, releaseNotes: [{title: "title", body: "body"}], targets: targets()}, "ocx.update.verification/1": {schema: "ocx.update.verification/1", sourceCommit: "b".repeat(40), version: "1.2.3", channel: "latest", workflowRunId: 1, workflowAttempt: 1, versionSources: ["package.json", "desktop/src-tauri/tauri.conf.json", "desktop/src-tauri/Cargo.toml", "desktop/src-tauri/Cargo.lock"].map(path => ({path, sha256: h})), assets: [{name: "a", ...digest}, {name: "b", ...digest}], universalProofs: [{assetName: "a", artifactSha256: h, architectures: ["arm64", "x64"], inspectionSha256: h}], architectureProofs: [{targetId: "linux-x64-npm", assetName: "b", artifactSha256: h, arch: "x64", inspectionSha256: h}]}, "ocx.update.tree/1": {schema: "ocx.update.tree/1", version: "1.2.3", target: "linux-x64-npm", entries: [{path: "bin", type: "directory", mode: 493}, {path: "bin/a", type: "file", mode: 420, size: 0, sha256: h}, {path: "bin/link", type: "symlink", target: "../bin/a"}]}, @@ -64,7 +65,7 @@ describe("closed unverified update contracts", () => { expect(parseSignatureEnvelope(bytes(all["ocx.update.signatures/1"])).signatures).toHaveLength(1); }); test("expected schema determines the immutable raw byte cap", () => { - const caps: Record = {"ocx.update.root/1":65536, "ocx.update.signatures/1":65536, "ocx.update.release/1":1048576, "ocx.update.verification/1":1048576, "ocx.update.tree/1":16777216, "ocx.link-capabilities/1":1048576, "ocx.update.policy/1":4096, "ocx.update.prepared/1":8192, "ocx.update.activation/1":8192}; + const caps: Record = {"ocx.update.root/1":65536, "ocx.update.signatures/1":65536, "ocx.update.root-transition-signatures/1":262144, "ocx.update.release/1":1048576, "ocx.update.verification/1":1048576, "ocx.update.tree/1":16777216, "ocx.link-capabilities/1":1048576, "ocx.update.policy/1":4096, "ocx.update.prepared/1":8192, "ocx.update.activation/1":8192}; for (const [schema, value] of Object.entries(fixtures()) as [Schema, any][]) { const raw = bytes(value); const exact = Buffer.concat([raw, Buffer.alloc(caps[schema] - raw.length, 32)]); expect(parseUpdateDocument(exact, schema).schema).toBe(schema); @@ -102,6 +103,13 @@ describe("closed unverified update contracts", () => { }); test("signature envelope rejects noncanonical encodings and duplicate fingerprints", () => { const e = fixtures()["ocx.update.signatures/1"]; + const entries = Array.from({ length: 33 }, (_, i) => ({ keyFingerprint: i.toString(16).padStart(64, "0"), signatureBox: box })); + const transition = { schema: "ocx.update.root-transition-signatures/1", signatures: entries.slice(0, 32) }; + expect(parse(transition).signatures).toHaveLength(32); + reject({ ...transition, signatures: entries }); + reject({ ...e, signatures: entries.slice(0, 17) }); + expect(() => parseSignatureEnvelope(bytes(transition))).toThrow(); + expect(() => parseUpdateDocument(bytes(e), "ocx.update.root-transition-signatures/1")).toThrow(); reject({...e, signatures: [e.signatures[0], e.signatures[0]]}); reject({...e, signatures: [{...e.signatures[0], signatureBox: `${box}\n`}]}); reject({...e, signatures: [{...e.signatures[0], signatureBox: Buffer.from("bad").toString("base64")}]}); diff --git a/tests/update/update-signed-supply.test.ts b/tests/update/update-signed-supply.test.ts index d99596dd40e..aba2c2691e7 100644 --- a/tests/update/update-signed-supply.test.ts +++ b/tests/update/update-signed-supply.test.ts @@ -32,6 +32,50 @@ describe("embedded update trust root", () => { }); describe("verified release and candidate handles", () => { + test("root transitions support disjoint threshold sets and reject invalid union members", async () => { + const dir = mkdtempSync(join(tmpdir(), "ocx-root-union-")); + try { + const makeKey = (n: number) => { + const pair = generateKeyPairSync("ed25519"); + const raw = Buffer.from(pair.publicKey.export({ format: "der", type: "spki" })).subarray(-32); + const packetId = Buffer.alloc(8, n); + const fingerprint = createHash("sha256").update(raw).digest("hex"); + const publicKey = Buffer.from(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), packetId, raw]).toString("base64")}\n`).toString("base64"); + return { pair, raw, packetId, key: { keyId: fingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey } }; + }; + const keys = Array.from({ length: 33 }, (_, i) => makeKey(i + 1)); + const signEntry = (bytes: Buffer, key: typeof keys[number]) => { + const signature = sign(null, createHash("blake2b512").update(bytes).digest(), key.pair.privateKey); + const global = sign(null, Buffer.concat([signature, Buffer.from("version:1.2.3")]), key.pair.privateKey); + const packet = Buffer.concat([Buffer.from("ED"), key.packetId, signature]).toString("base64"); + return { keyFingerprint: key.key.keyId, signatureBox: Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: version:1.2.3\n${global.toString("base64")}\n`).toString("base64") }; + }; + const makeRoot = (members: typeof keys, revision: number) => ({ schema: "ocx.update.root/1", revision, expiresAt: "2030-01-01T00:00:00Z", rootKeys: members.map(x => x.key), rootThreshold: members.length, releaseKeys: [{ ...members[0].key, channels: ["latest"], roles: ["release"] }], releaseThreshold: 1, channels: ["latest"] }); + const wrap = (entries: unknown[], schema = "ocx.update.root-transition-signatures/1") => Buffer.from(JSON.stringify({ schema, signatures: entries })); + const now = Date.parse("2027-01-01T00:00:00Z"); + for (const count of [9, 16]) { + const fixtureDir = join(dir, `fixture-${count}`); + const { mkdirSync } = await import("node:fs"); + mkdirSync(fixtureDir); + for (const name of ["signed-supply.mjs", "update-bytes.mjs", "update-contracts.mjs", "update-bounded-json.mjs", "update-candidate-id.mjs", "update-signed-version.mjs", "update-signature-threshold.mjs", "minisign.mjs"]) copyFileSync(repoPath("src/update", name), join(fixtureDir, name)); + const oldRoot = Buffer.from(JSON.stringify(makeRoot(keys.slice(0, count), 1))); + const nextRoot = Buffer.from(JSON.stringify(makeRoot(keys.slice(16, 16 + count), 2))); + writeFileSync(join(fixtureDir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${createHash("sha256").update(oldRoot).digest("hex")}";\n`); + const fixture = await import(pathToFileURL(join(fixtureDir, "signed-supply.mjs")).href); + const basis = fixture.bootstrapEmbeddedRoot(oldRoot, now); + const entries = [...keys.slice(0, count), ...keys.slice(16, 16 + count)].map(key => signEntry(nextRoot, key)); + expect(() => fixture.verifyRootTransition(basis, nextRoot, wrap(entries), now)).not.toThrow(); + expect(() => fixture.verifyRootTransition(basis, nextRoot, wrap(entries.slice(1)), now)).toThrow(); + expect(() => fixture.verifyRootTransition(basis, nextRoot, wrap([...entries, entries[0]]), now)).toThrow(); + expect(() => fixture.verifyRootTransition(basis, nextRoot, wrap([...entries, signEntry(nextRoot, keys[32])]), now)).toThrow(); + expect(() => fixture.verifyRootTransition(basis, nextRoot, wrap(entries, "ocx.update.signatures/1"), now)).toThrow(); + const invalid = [...entries]; invalid[0] = signEntry(Buffer.from("other"), keys[0]); + expect(() => fixture.verifyRootTransition(basis, nextRoot, wrap(invalid), now)).toThrow(); + } + } finally { + rmSync(dir, { recursive: true, force: true }); + } + }); test("uses an isolated compiled fixture anchor and rejects forged or cross-module handles", async () => { const dir = mkdtempSync(join(tmpdir(), "ocx-update-fixture-")); try { @@ -112,8 +156,17 @@ describe("verified release and candidate handles", () => { const successor = Buffer.from(JSON.stringify({ schema: "ocx.update.root/1", revision: 2, expiresAt: "2031-01-01T00:00:00Z", rootKeys: [successorKey], rootThreshold: 1, releaseKeys: [{ ...successorKey, channels: ["latest"], roles: ["release", "desktop-artifact"] }], releaseThreshold: 1, channels: ["latest"] })); const oldSignature = { keyFingerprint: fingerprint, signatureBox: signBox(successor) }; const newSignature = { keyFingerprint: successorFingerprint, signatureBox: signBox(successor, successorPair.privateKey, successorId) }; - const transitionEnvelope = (signatures: unknown[]) => Buffer.from(JSON.stringify({ schema: "ocx.update.signatures/1", signatures })); + const transitionEnvelope = (signatures: unknown[]) => Buffer.from(JSON.stringify({ schema: "ocx.update.root-transition-signatures/1", signatures })); + const releaseEnvelope = (signatures: unknown[]) => Buffer.from(JSON.stringify({ schema: "ocx.update.signatures/1", signatures })); const transition = fixture.verifyRootTransition(rootHandle, successor, transitionEnvelope([oldSignature, newSignature]), now); + const sharedRootObject = JSON.parse(successor.toString()); + sharedRootObject.rootKeys = [key]; + const sharedRoot = Buffer.from(JSON.stringify(sharedRootObject)); + expect(() => fixture.verifyRootTransition(rootHandle, sharedRoot, transitionEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(sharedRoot) }]), now)).not.toThrow(); + const incompatible = JSON.parse(sharedRoot.toString()); + incompatible.rootKeys[0].publicKey = Buffer.from(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), Buffer.alloc(8, 99), raw]).toString("base64")}\n`).toString("base64"); + const incompatibleBytes = Buffer.from(JSON.stringify(incompatible)); + expect(() => fixture.verifyRootTransition(rootHandle, incompatibleBytes, transitionEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(incompatibleBytes) }]), now)).toThrow(/packet identifiers/); expect(() => fixture.verifyArtifactEvidence(candidate, artifact, transition, now)).toThrow(); expect(fixture.inspectTransition(transition)).toEqual({ predecessorDigest: anchor, predecessorRevision: 1, successorDigest: createHash("sha256").update(successor).digest("hex"), successorRevision: 2 }); expect(() => fixture.verifyRootTransition(rootHandle, successor, transitionEnvelope([oldSignature]), now)).toThrow(); @@ -127,7 +180,7 @@ describe("verified release and candidate handles", () => { nextRelease.targets[0].artifact.signerFingerprint = successorFingerprint; nextRelease.targets[0].artifact.signatureBox = signBox(artifact, successorPair.privateKey, successorId); const nextBytes = Buffer.from(JSON.stringify(nextRelease)); - const nextEnvelope = transitionEnvelope([{ keyFingerprint: successorFingerprint, signatureBox: signBox(nextBytes, successorPair.privateKey, successorId) }]); + const nextEnvelope = releaseEnvelope([{ keyFingerprint: successorFingerprint, signatureBox: signBox(nextBytes, successorPair.privateKey, successorId) }]); const nextEvidence = fixture.verifyReleaseEvidence(nextBytes, nextEnvelope, transition, "latest", now); const nextCandidate = fixture.selectTargetEvidence(nextEvidence, selection); expect(nextCandidate.candidateId).toMatch(/^[a-f0-9]{64}$/); @@ -137,7 +190,7 @@ describe("verified release and candidate handles", () => { const altered = JSON.parse(release.toString()); altered.targets[0].artifact.signatureBox = signBox(artifact, privateKey, id, comment); const alteredBytes = Buffer.from(JSON.stringify(altered)); - const alteredEnvelope = transitionEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(alteredBytes) }]); + const alteredEnvelope = releaseEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(alteredBytes) }]); const alteredRelease = fixture.verifyReleaseEvidence(alteredBytes, alteredEnvelope, rootHandle, "latest", now); const alteredTarget = fixture.selectTargetEvidence(alteredRelease, selection); expect(() => fixture.verifyArtifactEvidence(alteredTarget, artifact, rootHandle, now)).toThrow(); @@ -145,7 +198,7 @@ describe("verified release and candidate handles", () => { const wrongSigner = JSON.parse(release.toString()); wrongSigner.targets[0].artifact.signerFingerprint = successorFingerprint; const wrongSignerBytes = Buffer.from(JSON.stringify(wrongSigner)); - const wrongSignerEnvelope = transitionEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(wrongSignerBytes) }]); + const wrongSignerEnvelope = releaseEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(wrongSignerBytes) }]); const wrongSignerRelease = fixture.verifyReleaseEvidence(wrongSignerBytes, wrongSignerEnvelope, rootHandle, "latest", now); expect(() => fixture.verifyArtifactEvidence(fixture.selectTargetEvidence(wrongSignerRelease, selection), artifact, rootHandle, now)).toThrow(); for (const other of [wrongRole, wrongChannel]) { @@ -153,7 +206,7 @@ describe("verified release and candidate handles", () => { altered.targets[0].artifact.signerFingerprint = other.key.keyId; altered.targets[0].artifact.signatureBox = signBox(artifact, other.pair.privateKey, other.packetId); const alteredBytes = Buffer.from(JSON.stringify(altered)); - const alteredEnvelope = transitionEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(alteredBytes) }]); + const alteredEnvelope = releaseEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(alteredBytes) }]); const alteredRelease = fixture.verifyReleaseEvidence(alteredBytes, alteredEnvelope, rootHandle, "latest", now); expect(() => fixture.verifyArtifactEvidence(fixture.selectTargetEvidence(alteredRelease, selection), artifact, rootHandle, now)).toThrow(); } @@ -161,7 +214,7 @@ describe("verified release and candidate handles", () => { const altered = JSON.parse(release.toString()); Object.assign(altered.targets[0].artifact, alteredArtifact); const alteredBytes = Buffer.from(JSON.stringify(altered)); - const alteredEnvelope = transitionEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(alteredBytes) }]); + const alteredEnvelope = releaseEnvelope([{ keyFingerprint: fingerprint, signatureBox: signBox(alteredBytes) }]); const alteredRelease = fixture.verifyReleaseEvidence(alteredBytes, alteredEnvelope, rootHandle, "latest", now); expect(() => fixture.verifyArtifactEvidence(fixture.selectTargetEvidence(alteredRelease, selection), artifact, rootHandle, now)).toThrow(); } @@ -174,7 +227,7 @@ describe("verified release and candidate handles", () => { { keyFingerprint: fingerprint, signatureBox: signBox(multiRootBytes) }, { keyFingerprint: successorFingerprint, signatureBox: signBox(multiRootBytes, successorPair.privateKey, successorId) }, ]), now); - const multiReleaseEnvelope = transitionEnvelope([ + const multiReleaseEnvelope = releaseEnvelope([ { keyFingerprint: fingerprint, signatureBox: signBox(nextBytes) }, { keyFingerprint: successorFingerprint, signatureBox: signBox(nextBytes, successorPair.privateKey, successorId) }, ]); From ba8244e1c02d75470e47d96af4a449d6846ae04b Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:22:21 +0900 Subject: [PATCH 23/42] Exercise transition envelope in runtime harness --- tests/helpers/update-node-harness.mjs | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index f216e65becc..c16d2bdc149 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -9,6 +9,7 @@ import { parseBoundedJson } from "../../src/update/update-bounded-json.mjs"; import { deriveCandidateId } from "../../src/update/update-candidate-id.mjs"; import { sameSignedVersion, trustedCommentMatchesVersion } from "../../src/update/update-signed-version.mjs"; import { bootstrapEmbeddedRoot } from "../../src/update/signed-supply.mjs"; +import { parseSignatureEnvelope, parseUpdateDocument } from "../../src/update/update-contracts.mjs"; const args = process.argv.slice(2); assert.ok(args.length === 0 || (args.length === 1 && args[0] === "--require-node18"), "unsupported arguments"); @@ -33,6 +34,16 @@ assert.throws(() => parseBoundedJson(encode('{"a":1,"\\u0061":2}'), 65536)); const group = `[${Array(4096).fill("{}").join(",")}]`; assert.throws(() => parseBoundedJson(encode(`[${Array(20).fill(group).join(",")}]`), 16777216)); +const transitionSchema = "ocx.update.root-transition-signatures/1"; +const signers = Array.from({ length: 33 }, (_, i) => ({ keyFingerprint: i.toString(16).padStart(64, "0"), signatureBox: signature })); +const transition = encode(JSON.stringify({ schema: transitionSchema, signatures: signers.slice(0, 32) })); +assert.equal(parseUpdateDocument(transition, transitionSchema).signatures.length, 32); +assert.throws(() => parseUpdateDocument(encode(JSON.stringify({ schema: transitionSchema, signatures: signers })), transitionSchema)); +assert.throws(() => parseSignatureEnvelope(transition)); +const capped = Buffer.concat([transition, Buffer.alloc(262144 - transition.length, 32)]); +assert.equal(parseUpdateDocument(capped, transitionSchema).signatures.length, 32); +assert.throws(() => parseUpdateDocument(Buffer.concat([capped, Buffer.from(" ")]), transitionSchema)); + const root = readFileSync(fileURLToPath(new URL("../../src/update/trust-root.json", import.meta.url))); const expiry = Date.parse("2028-11-07T00:00:00Z"); assert.ok(Object.isFrozen(bootstrapEmbeddedRoot(root, expiry - 1))); From b9d3b332f66e18badf5149a1949a189c8dd16fa9 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:22:47 +0900 Subject: [PATCH 24/42] Exercise signed transition evidence across runtimes --- tests/helpers/update-node-harness.mjs | 45 +++++++++++++++++++++++++-- 1 file changed, 43 insertions(+), 2 deletions(-) diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index c16d2bdc149..4da13cc815b 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -2,8 +2,11 @@ // node tests/helpers/update-node-harness.mjs --require-node18 // This harness performs offline checks only; it never reads an installation. import assert from "node:assert/strict"; -import { readFileSync } from "node:fs"; -import { fileURLToPath } from "node:url"; +import { copyFileSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; +import { createHash, generateKeyPairSync, sign } from "node:crypto"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { fileURLToPath, pathToFileURL } from "node:url"; import { decodePublicKey, verifyMinisignBytes } from "../../src/update/minisign.mjs"; import { parseBoundedJson } from "../../src/update/update-bounded-json.mjs"; import { deriveCandidateId } from "../../src/update/update-candidate-id.mjs"; @@ -44,6 +47,44 @@ const capped = Buffer.concat([transition, Buffer.alloc(262144 - transition.lengt assert.equal(parseUpdateDocument(capped, transitionSchema).signatures.length, 32); assert.throws(() => parseUpdateDocument(Buffer.concat([capped, Buffer.from(" ")]), transitionSchema)); +// Build an isolated fixture closure with a generated anchor; production trust +// is never overridden, and the exact kernel sources are copied unchanged. +const dir = mkdtempSync(join(tmpdir(), "ocx-node-supply-")); +try { + for (const name of ["signed-supply.mjs", "update-bytes.mjs", "update-contracts.mjs", "update-bounded-json.mjs", "update-candidate-id.mjs", "update-signed-version.mjs", "update-signature-threshold.mjs", "minisign.mjs"]) { + copyFileSync(fileURLToPath(new URL(`../../src/update/${name}`, import.meta.url)), join(dir, name)); + } + const makeKey = (number) => { + const pair = generateKeyPairSync("ed25519"); + const raw = Buffer.from(pair.publicKey.export({ format: "der", type: "spki" })).subarray(-32); + const id = Buffer.alloc(8, number); + const fingerprint = createHash("sha256").update(raw).digest("hex"); + const publicKey = Buffer.from(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), id, raw]).toString("base64")}\n`).toString("base64"); + return { pair, id, key: { keyId: fingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey } }; + }; + const keys = [1, 2, 3, 4].map(makeKey); + const buildRoot = (members, revision) => ({ schema: "ocx.update.root/1", revision, expiresAt: "2030-01-01T00:00:00Z", rootKeys: members.map(x => x.key), rootThreshold: 2, releaseKeys: [{ ...members[0].key, channels: ["latest"], roles: ["release"] }], releaseThreshold: 1, channels: ["latest"] }); + const before = Buffer.from(JSON.stringify(buildRoot(keys.slice(0, 2), 1))); + const after = Buffer.from(JSON.stringify(buildRoot(keys.slice(2), 2))); + writeFileSync(join(dir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${createHash("sha256").update(before).digest("hex")}";\n`); + const supply = await import(pathToFileURL(join(dir, "signed-supply.mjs")).href); + const basis = supply.bootstrapEmbeddedRoot(before, Date.parse("2027-01-01T00:00:00Z")); + const signed = keys.map(({ pair, id, key }) => { + const payload = sign(null, createHash("blake2b512").update(after).digest(), pair.privateKey); + const global = sign(null, Buffer.concat([payload, Buffer.from("fixture")]), pair.privateKey); + const packet = Buffer.concat([Buffer.from("ED"), id, payload]).toString("base64"); + const box = Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: fixture\n${global.toString("base64")}\n`).toString("base64"); + return { keyFingerprint: key.keyId, signatureBox: box }; + }); + const envelope = (entries) => Buffer.from(JSON.stringify({ schema: transitionSchema, signatures: entries })); + const now = Date.parse("2027-01-01T00:00:00Z"); + assert.equal(supply.inspectTransition(supply.verifyRootTransition(basis, after, envelope(signed), now)).successorRevision, 2); + assert.throws(() => supply.verifyRootTransition(basis, after, envelope(signed.slice(1)), now)); + assert.throws(() => supply.verifyRootTransition({}, after, envelope(signed), now)); +} finally { + rmSync(dir, { recursive: true, force: true }); +} + const root = readFileSync(fileURLToPath(new URL("../../src/update/trust-root.json", import.meta.url))); const expiry = Date.parse("2028-11-07T00:00:00Z"); assert.ok(Object.isFrozen(bootstrapEmbeddedRoot(root, expiry - 1))); From ca1361830feae8af5af345d0bf4092219b9b0e35 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:23:16 +0900 Subject: [PATCH 25/42] Expose root transition envelope parser --- src/update/signed-supply.mjs | 4 ++-- src/update/update-contracts.d.mts | 1 + src/update/update-contracts.mjs | 1 + tests/update/update-contracts.test.ts | 4 +++- 4 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/update/signed-supply.mjs b/src/update/signed-supply.mjs index e952bca1017..f9e2cd9d536 100644 --- a/src/update/signed-supply.mjs +++ b/src/update/signed-supply.mjs @@ -1,5 +1,5 @@ import { createHash } from "node:crypto"; -import { parseSignatureEnvelope, parseUpdateDocument } from "./update-contracts.mjs"; +import { parseRootTransitionEnvelope, parseSignatureEnvelope, parseUpdateDocument } from "./update-contracts.mjs"; import { EMBEDDED_ROOT_SHA256 } from "./update-trust-anchor.mjs"; import { snapshotUpdateBytes } from "./update-bytes.mjs"; import { verifySignatureThreshold } from "./update-signature-threshold.mjs"; @@ -42,7 +42,7 @@ export function verifyRootTransition(predecessorBasis, bytes, envelopeBytes, now const previous = currentRoot(predecessorBasis, nowMs); const nextBytes = snapshotUpdateBytes(bytes, 65536); const signatureBytes = snapshotUpdateBytes(envelopeBytes, 262144); - const envelope = parseUpdateDocument(signatureBytes, "ocx.update.root-transition-signatures/1"); + const envelope = parseRootTransitionEnvelope(signatureBytes); const root = parseUpdateDocument(nextBytes, "ocx.update.root/1"); if (root.revision <= previous.root.revision || Date.parse(root.expiresAt) <= nowMs) { throw new Error("Invalid successor root"); diff --git a/src/update/update-contracts.d.mts b/src/update/update-contracts.d.mts index d8afad6d8ca..03ffe39b7be 100644 --- a/src/update/update-contracts.d.mts +++ b/src/update/update-contracts.d.mts @@ -21,3 +21,4 @@ export type UpdateActivation = {schema: "ocx.update.activation/1"; operationId: export interface UpdateDocumentSchemas {"ocx.update.root/1": UpdateRoot; "ocx.update.signatures/1": SignatureEnvelope; "ocx.update.root-transition-signatures/1": RootTransitionEnvelope; "ocx.update.release/1": UpdateRelease; "ocx.update.verification/1": UpdateReceipt; "ocx.update.tree/1": UpdateTree; "ocx.link-capabilities/1": UpdateCapabilities; "ocx.update.policy/1": UpdatePolicy; "ocx.update.prepared/1": UpdatePrepared; "ocx.update.activation/1": UpdateActivation} export function parseUpdateDocument(bytes: Uint8Array, expectedSchema: S): UpdateDocumentSchemas[S]; export function parseSignatureEnvelope(bytes: Uint8Array): SignatureEnvelope; +export function parseRootTransitionEnvelope(bytes: Uint8Array): RootTransitionEnvelope; diff --git a/src/update/update-contracts.mjs b/src/update/update-contracts.mjs index d894a289117..77991b1c3e4 100644 --- a/src/update/update-contracts.mjs +++ b/src/update/update-contracts.mjs @@ -203,3 +203,4 @@ export function parseUpdateDocument(bytes, expectedSchema) { return value; } export function parseSignatureEnvelope(bytes) { return parseUpdateDocument(bytes, "ocx.update.signatures/1"); } +export function parseRootTransitionEnvelope(bytes) { return parseUpdateDocument(bytes, "ocx.update.root-transition-signatures/1"); } diff --git a/tests/update/update-contracts.test.ts b/tests/update/update-contracts.test.ts index 2188f553f82..fee00eb55fd 100644 --- a/tests/update/update-contracts.test.ts +++ b/tests/update/update-contracts.test.ts @@ -1,7 +1,7 @@ import { describe, expect, test } from "bun:test"; import { createHash } from "node:crypto"; import { readFileSync } from "node:fs"; -import { parseSignatureEnvelope, parseUpdateDocument } from "../../src/update/update-contracts.mjs"; +import { parseRootTransitionEnvelope, parseSignatureEnvelope, parseUpdateDocument } from "../../src/update/update-contracts.mjs"; import type { UpdateDocumentSchemas } from "../../src/update/update-contracts.mjs"; import { repoPath } from "../helpers/repo-root"; @@ -106,10 +106,12 @@ describe("closed unverified update contracts", () => { const entries = Array.from({ length: 33 }, (_, i) => ({ keyFingerprint: i.toString(16).padStart(64, "0"), signatureBox: box })); const transition = { schema: "ocx.update.root-transition-signatures/1", signatures: entries.slice(0, 32) }; expect(parse(transition).signatures).toHaveLength(32); + expect(parseRootTransitionEnvelope(bytes(transition)).signatures).toHaveLength(32); reject({ ...transition, signatures: entries }); reject({ ...e, signatures: entries.slice(0, 17) }); expect(() => parseSignatureEnvelope(bytes(transition))).toThrow(); expect(() => parseUpdateDocument(bytes(e), "ocx.update.root-transition-signatures/1")).toThrow(); + expect(() => parseRootTransitionEnvelope(bytes(e))).toThrow(); reject({...e, signatures: [e.signatures[0], e.signatures[0]]}); reject({...e, signatures: [{...e.signatures[0], signatureBox: `${box}\n`}]}); reject({...e, signatures: [{...e.signatures[0], signatureBox: Buffer.from("bad").toString("base64")}]}); From 4efe230dfc095077aeafb9d60474d70e4ad4d1c3 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:25:00 +0900 Subject: [PATCH 26/42] Allow bounded generated update asset names --- src/update/update-contracts.mjs | 9 ++--- tests/update/update-contracts.test.ts | 8 +++++ tests/update/update-external-metadata.test.ts | 36 ++++++++++++++++--- 3 files changed, 45 insertions(+), 8 deletions(-) diff --git a/src/update/update-contracts.mjs b/src/update/update-contracts.mjs index 77991b1c3e4..0ffbdd06053 100644 --- a/src/update/update-contracts.mjs +++ b/src/update/update-contracts.mjs @@ -21,6 +21,7 @@ const VERSION_PATHS = ["package.json", "desktop/src-tauri/tauri.conf.json", "des const FAIL = () => { throw new Error("Invalid update document"); }; const text = (v, max = 4096) => typeof v === "string" && Buffer.byteLength(v, "utf8") <= max; const id = (v) => text(v, 128) && ASCII_ID.test(v); +const assetName = (v) => text(v, 255) && ASCII_ID.test(v); const hash = (v) => typeof v === "string" && HASH.test(v); const integer = (v, min, max = Number.MAX_SAFE_INTEGER) => Number.isSafeInteger(v) && v >= min && v <= max; const oneOf = (v, values) => values.includes(v); @@ -109,7 +110,7 @@ function expectedAsset(t, ver, channel) { } function target(t, ver, channel) { exact(obj(t, ["id", "platform", "arch", "owner", "artifactKind", "bundleKind", "assetName", "artifact", "tree", "capabilities"])); - exact(id(t.id) && t.id === targetTuple(t) && id(t.assetName) && t.assetName === expectedAsset(t, ver, channel)); + exact(id(t.id) && t.id === targetTuple(t) && assetName(t.assetName) && t.assetName === expectedAsset(t, ver, channel)); exact(obj(t.artifact, ["sha256", "size", "signatureBox", "signerFingerprint"]) && hash(t.artifact.sha256) && hash(t.artifact.signerFingerprint) && integer(t.artifact.size, 1, 1073741824)); signature(t.artifact.signatureBox); if (t.artifactKind === "tauri" || t.artifactKind === "guardian") exact(t.tree === null); else digestSize(t.tree, 16777216); @@ -130,11 +131,11 @@ function receipt(v) { exact(array(v.versionSources, 4, 4)); for (const x of v.versionSources) exact(obj(x, ["path", "sha256"]) && VERSION_PATHS.includes(x.path) && hash(x.sha256)); exact(unique(v.versionSources.map((x) => x.path)) && array(v.assets, 1, 4096)); - for (const x of v.assets) exact(obj(x, ["name", "sha256", "size"]) && id(x.name) && hash(x.sha256) && integer(x.size, 1)); + for (const x of v.assets) exact(obj(x, ["name", "sha256", "size"]) && assetName(x.name) && hash(x.sha256) && integer(x.size, 1)); exact(v.assets.every((x, i) => i === 0 || v.assets[i - 1].name < x.name)); exact(array(v.universalProofs, 0, 4096) && array(v.architectureProofs, 0, 4096)); - for (const x of v.universalProofs) exact(obj(x, ["assetName", "artifactSha256", "architectures", "inspectionSha256"]) && id(x.assetName) && hash(x.artifactSha256) && hash(x.inspectionSha256) && array(x.architectures, 2, 2) && x.architectures[0] === "arm64" && x.architectures[1] === "x64"); - for (const x of v.architectureProofs) exact(obj(x, ["targetId", "assetName", "artifactSha256", "arch", "inspectionSha256"]) && id(x.targetId) && id(x.assetName) && hash(x.artifactSha256) && hash(x.inspectionSha256) && oneOf(x.arch, ["x64", "arm64"])); + for (const x of v.universalProofs) exact(obj(x, ["assetName", "artifactSha256", "architectures", "inspectionSha256"]) && assetName(x.assetName) && hash(x.artifactSha256) && hash(x.inspectionSha256) && array(x.architectures, 2, 2) && x.architectures[0] === "arm64" && x.architectures[1] === "x64"); + for (const x of v.architectureProofs) exact(obj(x, ["targetId", "assetName", "artifactSha256", "arch", "inspectionSha256"]) && id(x.targetId) && assetName(x.assetName) && hash(x.artifactSha256) && hash(x.inspectionSha256) && oneOf(x.arch, ["x64", "arm64"])); exact(unique(v.universalProofs.map((x) => JSON.stringify([x.assetName, x.artifactSha256, x.architectures, x.inspectionSha256]))) && unique(v.architectureProofs.map((x) => JSON.stringify([x.targetId, x.assetName, x.artifactSha256, x.arch, x.inspectionSha256])))); } diff --git a/tests/update/update-contracts.test.ts b/tests/update/update-contracts.test.ts index fee00eb55fd..518fa7fa5d7 100644 --- a/tests/update/update-contracts.test.ts +++ b/tests/update/update-contracts.test.ts @@ -132,6 +132,14 @@ describe("closed unverified update contracts", () => { reject({...r, assets: [...r.assets].reverse()}); reject({...r, assets: [r.assets[0], r.assets[0]]}); reject({...r, universalProofs: [{...r.universalProofs[0], architectures: ["x64", "arm64"]}]}); reject({...r, architectureProofs: [{...r.architectureProofs[0], arch: "other"}]}); + for (const field of ["assets", "universalProofs", "architectureProofs"]) { + const nameKey = field === "assets" ? "name" : "assetName"; + const entry = r[field][0]; + expect(parse({...r, [field]: [{...entry, [nameKey]: "a".repeat(255)}]})).toBeDefined(); + reject({...r, [field]: [{...entry, [nameKey]: "a".repeat(256)}]}); + reject({...r, [field]: [{...entry, [nameKey]: "a/b"}]}); + } + reject({...r, architectureProofs: [{...r.architectureProofs[0], targetId: "a".repeat(129)}]}); }); test("tree inventory is physical, requires real directory parents and accepts relative links", () => { const t = fixtures()["ocx.update.tree/1"]; diff --git a/tests/update/update-external-metadata.test.ts b/tests/update/update-external-metadata.test.ts index 03b8ba1dd8e..2f32619e9db 100644 --- a/tests/update/update-external-metadata.test.ts +++ b/tests/update/update-external-metadata.test.ts @@ -24,14 +24,14 @@ describe("external signed update metadata", () => { const otherFingerprint = createHash("sha256").update(otherRaw).digest("hex"); const otherPublicKey = Buffer.from(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), otherId, otherRaw]).toString("base64")}\n`).toString("base64"); const otherKey = { keyId: otherFingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey: otherPublicKey }; - const root = Buffer.from(JSON.stringify({ schema: "ocx.update.root/1", revision: 1, expiresAt: "2030-01-01T00:00:00Z", rootKeys: [key], rootThreshold: 1, releaseKeys: [{ ...key, channels: ["latest"], roles: ["release", "tree"] }, { ...otherKey, channels: ["latest"], roles: ["release"] }], releaseThreshold: 1, channels: ["latest"] })); + const root = Buffer.from(JSON.stringify({ schema: "ocx.update.root/1", revision: 1, expiresAt: "2030-01-01T00:00:00Z", rootKeys: [key], rootThreshold: 1, releaseKeys: [{ ...key, channels: ["latest"], roles: ["release", "tree", "guardian-artifact", "standalone-artifact"] }, { ...otherKey, channels: ["latest"], roles: ["release"] }], releaseThreshold: 1, channels: ["latest"] })); writeFileSync(join(dir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${createHash("sha256").update(root).digest("hex")}";\n`); const fixture = await import(pathToFileURL(join(dir, "signed-supply.mjs")).href); - const signBox = (bytes: Buffer, privateKey = pair.privateKey, packetId = id) => { + const signBox = (bytes: Buffer, privateKey = pair.privateKey, packetId = id, version = "1.2.3") => { const signature = sign(null, createHash("blake2b512").update(bytes).digest(), privateKey); - const global = sign(null, Buffer.concat([signature, Buffer.from("version:1.2.3")]), privateKey); + const global = sign(null, Buffer.concat([signature, Buffer.from(`version:${version}`)]), privateKey); const packet = Buffer.concat([Buffer.from("ED"), packetId, signature]).toString("base64"); - return Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: version:1.2.3\n${global.toString("base64")}\n`).toString("base64"); + return Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: version:${version}\n${global.toString("base64")}\n`).toString("base64"); }; const envelope = (bytes: Buffer, pretty = false) => Buffer.from(JSON.stringify({ schema: "ocx.update.signatures/1", signatures: [{ keyFingerprint: fingerprint, signatureBox: signBox(bytes) }] }, null, pretty ? 2 : undefined)); const digest = (bytes: Buffer) => ({ sha256: createHash("sha256").update(bytes).digest("hex"), size: bytes.length }); @@ -57,6 +57,34 @@ describe("external signed update metadata", () => { expect(Object.isFrozen(receiptEvidence)).toBe(true); expect(Object.isFrozen(treeEvidence)).toBe(true); expect(Object.isFrozen(capabilityEvidence)).toBe(true); + const longVersion = `1.2.3+${"a".repeat(58)}`; + const longTarget = "linux-x64-standalone-guardian"; + const longAsset = `ocx-update-${longVersion}-latest-${longTarget}`; + const longCapabilityName = `${longAsset}.capabilities.json`; + expect(longCapabilityName.length).toBeGreaterThan(128); + const longCapability = Buffer.from(JSON.stringify({ ...JSON.parse(capability.toString()), version: longVersion, target: longTarget })); + const longReceipt = Buffer.from(JSON.stringify({ ...JSON.parse(receipt.toString()), version: longVersion, assets: [{name: longAsset, ...digest(artifact)}, {name: longCapabilityName, ...digest(longCapability)}] })); + const longRelease = Buffer.from(JSON.stringify({ ...JSON.parse(release.toString()), version: longVersion, receipt: digest(longReceipt), targets: [{id: longTarget, platform: "linux", arch: "x64", owner: "standalone", artifactKind: "guardian", bundleKind: "binary", assetName: longAsset, artifact: {...digest(artifact), signatureBox: signBox(artifact, pair.privateKey, id, longVersion), signerFingerprint: fingerprint}, tree: null, capabilities: digest(longCapability)}] })); + const longReleaseEvidence = fixture.verifyReleaseEvidence(longRelease, envelope(longRelease), basis, "latest", now); + const longCandidate = fixture.selectTargetEvidence(longReleaseEvidence, {platform: "linux", arch: "x64", owner: "standalone", artifactKind: "guardian", bundleKind: "binary"}); + expect(() => fixture.verifyArtifactEvidence(longCandidate, artifact, basis, now)).not.toThrow(); + const longReceiptEvidence = fixture.verifyExternalMetadataEvidence(longCandidate, {kind: "receipt", bytes: longReceipt}, basis, now); + expect(() => fixture.verifyExternalMetadataEvidence(longCandidate, {kind: "capability", bytes: longCapability, receiptEvidence: longReceiptEvidence}, basis, now)).not.toThrow(); + const longTreeTarget = "linux-arm64-standalone"; + const longTreeAsset = `ocx-${longVersion}-bun-linux-arm64.tar.gz`; + const longTreeName = `ocx-update-${longVersion}-latest-${longTreeTarget}.tree.json`; + const longTreeCapName = `ocx-update-${longVersion}-latest-${longTreeTarget}.capabilities.json`; + const longTree = Buffer.from(JSON.stringify({ ...JSON.parse(tree.toString()), version: longVersion, target: longTreeTarget })); + const longTreeEnvelope = envelope(longTree); + const longTreeCapability = Buffer.from(JSON.stringify({ ...JSON.parse(capability.toString()), version: longVersion, target: longTreeTarget })); + const longTreeAssets = [[longTreeAsset, artifact], [longTreeName, longTree], [`${longTreeName}.signatures.json`, longTreeEnvelope], [longTreeCapName, longTreeCapability]].map(([name, bytes]) => ({ name, ...digest(bytes as Buffer) })).sort((a, b) => String(a.name) < String(b.name) ? -1 : 1); + const longTreeReceipt = Buffer.from(JSON.stringify({ ...JSON.parse(receipt.toString()), version: longVersion, assets: longTreeAssets })); + const longTreeRelease = Buffer.from(JSON.stringify({ ...JSON.parse(release.toString()), version: longVersion, receipt: digest(longTreeReceipt), targets: [{id: longTreeTarget, platform: "linux", arch: "arm64", owner: "standalone", artifactKind: "standalone", bundleKind: "tar-gz", assetName: longTreeAsset, artifact: {...digest(artifact), signatureBox: signBox(artifact, pair.privateKey, id, longVersion), signerFingerprint: fingerprint}, tree: digest(longTree), capabilities: digest(longTreeCapability)}] })); + const longTreeCandidate = fixture.selectTargetEvidence(fixture.verifyReleaseEvidence(longTreeRelease, envelope(longTreeRelease), basis, "latest", now), {platform: "linux", arch: "arm64", owner: "standalone", artifactKind: "standalone", bundleKind: "tar-gz"}); + expect(() => fixture.verifyArtifactEvidence(longTreeCandidate, artifact, basis, now)).not.toThrow(); + const longTreeReceiptEvidence = fixture.verifyExternalMetadataEvidence(longTreeCandidate, {kind: "receipt", bytes: longTreeReceipt}, basis, now); + expect(() => fixture.verifyExternalMetadataEvidence(longTreeCandidate, {kind: "tree", bytes: longTree, signatureEnvelopeBytes: longTreeEnvelope, receiptEvidence: longTreeReceiptEvidence}, basis, now)).not.toThrow(); + expect(() => fixture.verifyExternalMetadataEvidence(longTreeCandidate, {kind: "capability", bytes: longTreeCapability, receiptEvidence: longTreeReceiptEvidence}, basis, now)).not.toThrow(); expect(() => fixture.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: tree, signatureEnvelopeBytes: envelope(tree, true), receiptEvidence }, basis, now)).toThrow(); expect(() => fixture.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: Buffer.from("changed"), signatureEnvelopeBytes: treeEnvelope, receiptEvidence }, basis, now)).toThrow(); expect(() => fixture.verifyExternalMetadataEvidence(candidate, { kind: "capability", bytes: Buffer.from("changed"), receiptEvidence }, basis, now)).toThrow(); From 6b2cee37c9f744a215b73dab4d4d493641523b5d Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:26:34 +0900 Subject: [PATCH 27/42] Exercise signed supply chain on Node 18 --- tests/helpers/update-node-harness.mjs | 38 +++++++++++++++++++++------ 1 file changed, 30 insertions(+), 8 deletions(-) diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index 4da13cc815b..97f586bedce 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -63,24 +63,46 @@ try { return { pair, id, key: { keyId: fingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey } }; }; const keys = [1, 2, 3, 4].map(makeKey); - const buildRoot = (members, revision) => ({ schema: "ocx.update.root/1", revision, expiresAt: "2030-01-01T00:00:00Z", rootKeys: members.map(x => x.key), rootThreshold: 2, releaseKeys: [{ ...members[0].key, channels: ["latest"], roles: ["release"] }], releaseThreshold: 1, channels: ["latest"] }); + const buildRoot = (members, revision) => ({ schema: "ocx.update.root/1", revision, expiresAt: "2030-01-01T00:00:00Z", rootKeys: members.map(x => x.key), rootThreshold: 2, releaseKeys: [{ ...members[0].key, channels: ["latest"], roles: ["release", "tree"] }], releaseThreshold: 1, channels: ["latest"] }); const before = Buffer.from(JSON.stringify(buildRoot(keys.slice(0, 2), 1))); const after = Buffer.from(JSON.stringify(buildRoot(keys.slice(2), 2))); writeFileSync(join(dir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${createHash("sha256").update(before).digest("hex")}";\n`); const supply = await import(pathToFileURL(join(dir, "signed-supply.mjs")).href); const basis = supply.bootstrapEmbeddedRoot(before, Date.parse("2027-01-01T00:00:00Z")); - const signed = keys.map(({ pair, id, key }) => { - const payload = sign(null, createHash("blake2b512").update(after).digest(), pair.privateKey); - const global = sign(null, Buffer.concat([payload, Buffer.from("fixture")]), pair.privateKey); + const signEntry = (bytes, { pair, id, key }) => { + const payload = sign(null, createHash("blake2b512").update(bytes).digest(), pair.privateKey); + const global = sign(null, Buffer.concat([payload, Buffer.from("version:1.2.3")]), pair.privateKey); const packet = Buffer.concat([Buffer.from("ED"), id, payload]).toString("base64"); - const box = Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: fixture\n${global.toString("base64")}\n`).toString("base64"); + const box = Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: version:1.2.3\n${global.toString("base64")}\n`).toString("base64"); return { keyFingerprint: key.keyId, signatureBox: box }; - }); + }; + const signed = keys.map(key => signEntry(after, key)); const envelope = (entries) => Buffer.from(JSON.stringify({ schema: transitionSchema, signatures: entries })); const now = Date.parse("2027-01-01T00:00:00Z"); - assert.equal(supply.inspectTransition(supply.verifyRootTransition(basis, after, envelope(signed), now)).successorRevision, 2); + const successor = supply.verifyRootTransition(basis, after, envelope(signed), now); + assert.equal(supply.inspectTransition(successor).successorRevision, 2); assert.throws(() => supply.verifyRootTransition(basis, after, envelope(signed.slice(1)), now)); assert.throws(() => supply.verifyRootTransition({}, after, envelope(signed), now)); + const digest = (bytes) => ({ sha256: createHash("sha256").update(bytes).digest("hex"), size: bytes.length }); + const metadataEnvelope = (bytes) => Buffer.from(JSON.stringify({ schema: "ocx.update.signatures/1", signatures: [signEntry(bytes, keys[2])] })); + const artifact = Buffer.from("fixture artifact"); + const target = "linux-x64-npm"; + const prefix = `ocx-update-1.2.3-latest-${target}`; + const tree = Buffer.from(JSON.stringify({ schema: "ocx.update.tree/1", version: "1.2.3", target, entries: [{ path: "file", type: "file", mode: 420, size: 0, sha256: "a".repeat(64) }] })); + const treeEnvelope = metadataEnvelope(tree); + const capability = Buffer.from(JSON.stringify({ schema: "ocx.link-capabilities/1", version: "1.2.3", channel: "latest", target, artifactSha256: digest(artifact).sha256, homeProvides: [], childRequires: [], updateActions: [], installerAdapters: [], recoveryProtocols: [], fleetJournalReaders: [], compatibilityEpoch: 1, compatibilityVectorSha256: "b".repeat(64) })); + const assets = [[`${prefix}.tar.gz`, artifact], [`${prefix}.tree.json`, tree], [`${prefix}.tree.json.signatures.json`, treeEnvelope], [`${prefix}.capabilities.json`, capability]].map(([name, bytes]) => ({ name, ...digest(bytes) })).sort((a, b) => a.name < b.name ? -1 : 1); + const receipt = Buffer.from(JSON.stringify({ schema: "ocx.update.verification/1", sourceCommit: "c".repeat(40), version: "1.2.3", channel: "latest", workflowRunId: 1, workflowAttempt: 1, versionSources: ["package.json", "desktop/src-tauri/tauri.conf.json", "desktop/src-tauri/Cargo.toml", "desktop/src-tauri/Cargo.lock"].map(path => ({ path, sha256: "d".repeat(64) })), assets, universalProofs: [], architectureProofs: [] })); + const release = Buffer.from(JSON.stringify({ schema: "ocx.update.release/1", version: "1.2.3", channel: "latest", sequence: 1, sourceCommit: "c".repeat(40), rolloutNotBefore: "2026-01-01T00:00:00Z", receipt: digest(receipt), releaseNotes: [], targets: [{ id: target, platform: "linux", arch: "x64", owner: "npm", artifactKind: "tree", bundleKind: "tar-gz", assetName: `${prefix}.tar.gz`, artifact: { ...digest(artifact), signatureBox: signEntry(artifact, keys[2]).signatureBox, signerFingerprint: keys[2].key.keyId }, tree: digest(tree), capabilities: digest(capability) }] })); + const releaseEvidence = supply.verifyReleaseEvidence(release, metadataEnvelope(release), successor, "latest", now); + const candidate = supply.selectTargetEvidence(releaseEvidence, { platform: "linux", arch: "x64", owner: "npm", artifactKind: "tree", bundleKind: "tar-gz" }); + assert.ok(Object.isFrozen(supply.verifyArtifactEvidence(candidate, artifact, successor, now))); + const receiptEvidence = supply.verifyExternalMetadataEvidence(candidate, { kind: "receipt", bytes: receipt }, successor, now); + assert.ok(Object.isFrozen(supply.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: tree, signatureEnvelopeBytes: treeEnvelope, receiptEvidence }, successor, now))); + assert.ok(Object.isFrozen(supply.verifyExternalMetadataEvidence(candidate, { kind: "capability", bytes: capability, receiptEvidence }, successor, now))); + assert.throws(() => supply.verifyArtifactEvidence(candidate, Buffer.from("wrong"), successor, now)); + assert.throws(() => supply.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: tree, signatureEnvelopeBytes: metadataEnvelope(Buffer.from("wrong")), receiptEvidence }, successor, now)); + assert.throws(() => supply.verifyReleaseEvidence(release, metadataEnvelope(release), successor, "preview", now)); } finally { rmSync(dir, { recursive: true, force: true }); } @@ -90,4 +112,4 @@ const expiry = Date.parse("2028-11-07T00:00:00Z"); assert.ok(Object.isFrozen(bootstrapEmbeddedRoot(root, expiry - 1))); assert.throws(() => bootstrapEmbeddedRoot(root, expiry)); assert.throws(() => bootstrapEmbeddedRoot(Buffer.from("invalid"), expiry - 1)); -console.log(`Offline update primitive harness passed on Node ${process.versions.node}`); +console.log(`Offline update primitive harness passed on ${globalThis.Bun ? `Bun ${globalThis.Bun.version}` : `Node ${process.versions.node}`}`); From 577dda374e06d03484feb3828036398d72fffe9a Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:28:47 +0900 Subject: [PATCH 28/42] Check schema byte caps across runtimes --- tests/helpers/update-node-harness.mjs | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index 97f586bedce..5cdd7294a73 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -103,6 +103,28 @@ try { assert.throws(() => supply.verifyArtifactEvidence(candidate, Buffer.from("wrong"), successor, now)); assert.throws(() => supply.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: tree, signatureEnvelopeBytes: metadataEnvelope(Buffer.from("wrong")), receiptEvidence }, successor, now)); assert.throws(() => supply.verifyReleaseEvidence(release, metadataEnvelope(release), successor, "preview", now)); + + const token = Buffer.alloc(32, 9).toString("base64url"); + const operationId = "12345678-1234-1234-1234-123456789abc"; + const policy = Buffer.from(JSON.stringify({ schema: "ocx.update.policy/1", revision: 0, channel: "latest", check: "manual", download: "manual", install: "manual" })); + const prepared = Buffer.from(JSON.stringify({ schema: "ocx.update.prepared/1", operationId, candidateDigest: "a".repeat(64), stageIdentity: token, stageDigest: "b".repeat(64), installationId: "install-1", ownerKind: "desktop", policyRevision: 0 })); + const activation = Buffer.from(JSON.stringify({ schema: "ocx.update.activation/1", action: "reserve", operationId, generation: 1, runtimeInstance: "runtime-1", pid: 1, port: 1, installationId: "install-1", ownerKind: "service", candidateDigest: "a".repeat(64), stageDigest: "b".repeat(64), policyRevision: 0, deadlineMs: 0 })); + const cappedDocuments = [ + ["ocx.update.root/1", before, 65536], ["ocx.update.signatures/1", metadataEnvelope(release), 65536], + [transitionSchema, envelope(signed), 262144], ["ocx.update.release/1", release, 1048576], + ["ocx.update.verification/1", receipt, 1048576], ["ocx.update.tree/1", tree, 16777216], + ["ocx.link-capabilities/1", capability, 1048576], ["ocx.update.policy/1", policy, 4096], + ["ocx.update.prepared/1", prepared, 8192], ["ocx.update.activation/1", activation, 8192], + ]; + for (const [schema, bytes, cap] of cappedDocuments) { + const exact = Buffer.concat([bytes, Buffer.alloc(cap - bytes.length, 32)]); + assert.equal(parseUpdateDocument(exact, schema).schema, schema); + assert.throws(() => parseUpdateDocument(Buffer.concat([exact, Buffer.from(" ")]), schema)); + } + const unicodeRelease = Buffer.from(JSON.stringify({ ...JSON.parse(release.toString()), releaseNotes: [{ title: "é", body: "é" }] })); + const unicodeExact = Buffer.concat([unicodeRelease, Buffer.alloc(1048576 - unicodeRelease.length, 32)]); + assert.equal(parseUpdateDocument(unicodeExact, "ocx.update.release/1").releaseNotes[0].title, "é"); + assert.throws(() => parseUpdateDocument(Buffer.concat([unicodeExact, Buffer.from(" ")]), "ocx.update.release/1")); } finally { rmSync(dir, { recursive: true, force: true }); } From a5e837174fff465da7fdd5f80be7d426c2a83153 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:29:45 +0900 Subject: [PATCH 29/42] Check root expiry across supported runtimes --- tests/helpers/update-node-harness.mjs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index 5cdd7294a73..878ae1ce14b 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -83,6 +83,12 @@ try { assert.equal(supply.inspectTransition(successor).successorRevision, 2); assert.throws(() => supply.verifyRootTransition(basis, after, envelope(signed.slice(1)), now)); assert.throws(() => supply.verifyRootTransition({}, after, envelope(signed), now)); + const rootExpiry = Date.parse("2030-01-01T00:00:00Z"); + assert.equal(parseUpdateDocument(before, "ocx.update.root/1").expiresAt, "2030-01-01T00:00:00Z"); + assert.ok(Object.isFrozen(supply.verifyRootTransition(basis, after, envelope(signed), rootExpiry - 1))); + for (const time of [rootExpiry, rootExpiry + 1, -1, NaN, Infinity, 1.5, Number.MAX_SAFE_INTEGER + 1]) { + assert.throws(() => supply.verifyRootTransition(basis, after, envelope(signed), time)); + } const digest = (bytes) => ({ sha256: createHash("sha256").update(bytes).digest("hex"), size: bytes.length }); const metadataEnvelope = (bytes) => Buffer.from(JSON.stringify({ schema: "ocx.update.signatures/1", signatures: [signEntry(bytes, keys[2])] })); const artifact = Buffer.from("fixture artifact"); From 3c498c47f202aac56438ba5948e8eefbbe5d30cf Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:31:17 +0900 Subject: [PATCH 30/42] Test schema field limits across runtimes --- tests/helpers/update-node-harness.mjs | 49 +++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index 878ae1ce14b..98fb80b6888 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -131,6 +131,55 @@ try { const unicodeExact = Buffer.concat([unicodeRelease, Buffer.alloc(1048576 - unicodeRelease.length, 32)]); assert.equal(parseUpdateDocument(unicodeExact, "ocx.update.release/1").releaseNotes[0].title, "é"); assert.throws(() => parseUpdateDocument(Buffer.concat([unicodeExact, Buffer.from(" ")]), "ocx.update.release/1")); + + // These are decoded field bounds, independent of the document caps above. + // Only release notes and inventory paths permit Unicode in these fixtures; + // all other selected identifier, hash, token and envelope fields are ASCII. + const checkField = (schema, value) => parseUpdateDocument(Buffer.from(JSON.stringify(value)), schema); + const rootValue = JSON.parse(before.toString()); + const rootKeyBox = Buffer.from(rootValue.rootKeys[0].publicKey, "base64").toString("utf8").replace(/\n$/, ""); + const padFirstLine = (text, size) => { + const split = text.indexOf("\n"); + return text.slice(0, split) + "x".repeat(size - Buffer.byteLength(text)) + text.slice(split); + }; + const rootWithBox = (size) => ({ ...rootValue, rootKeys: [{ ...rootValue.rootKeys[0], publicKey: Buffer.from(padFirstLine(rootKeyBox, size)).toString("base64") }, rootValue.rootKeys[1]] }); + assert.ok(checkField("ocx.update.root/1", rootWithBox(4096))); + assert.throws(() => checkField("ocx.update.root/1", rootWithBox(4097))); + assert.throws(() => checkField("ocx.update.root/1", { ...rootValue, rootKeys: [{ ...rootValue.rootKeys[0], keyId: "é" }, rootValue.rootKeys[1]] })); + for (const schema of ["ocx.update.signatures/1", transitionSchema]) { + const withBox = (size) => ({ schema, signatures: [{ keyFingerprint: "a".repeat(64), signatureBox: Buffer.from(padFirstLine(fixture.signatureBox, size)).toString("base64") }] }); + assert.ok(checkField(schema, withBox(4096))); + assert.throws(() => checkField(schema, withBox(4097))); + assert.throws(() => checkField(schema, { schema, signatures: [{ keyFingerprint: "é", signatureBox: signature }] })); + } + const releaseValue = JSON.parse(release.toString()); + const withTitle = (title) => ({ ...releaseValue, releaseNotes: [{ title, body: "" }] }); + assert.ok(checkField("ocx.update.release/1", withTitle("é".repeat(8192)))); + assert.throws(() => checkField("ocx.update.release/1", withTitle(`${"é".repeat(8192)}a`))); + const receiptValue = JSON.parse(receipt.toString()); + const withAssetName = (name) => ({ ...receiptValue, assets: [{ name, ...digest(artifact) }] }); + assert.ok(checkField("ocx.update.verification/1", withAssetName("a".repeat(255)))); + assert.throws(() => checkField("ocx.update.verification/1", withAssetName("a".repeat(256)))); + assert.throws(() => checkField("ocx.update.verification/1", withAssetName("é"))); + const treeValue = JSON.parse(tree.toString()); + const withPath = (path) => ({ ...treeValue, entries: [{ path, type: "directory", mode: 0 }] }); + assert.ok(checkField("ocx.update.tree/1", withPath("é".repeat(512)))); + assert.throws(() => checkField("ocx.update.tree/1", withPath(`${"é".repeat(512)}a`))); + const capabilityValue = JSON.parse(capability.toString()); + const withCapabilityId = (id) => ({ ...capabilityValue, homeProvides: [{ id, version: 1 }] }); + assert.ok(checkField("ocx.link-capabilities/1", withCapabilityId("a".repeat(128)))); + assert.throws(() => checkField("ocx.link-capabilities/1", withCapabilityId("a".repeat(129)))); + assert.throws(() => checkField("ocx.link-capabilities/1", withCapabilityId("é"))); + const policyValue = JSON.parse(policy.toString()); + assert.ok(checkField("ocx.update.policy/1", { ...policyValue, revision: Number.MAX_SAFE_INTEGER })); + assert.throws(() => checkField("ocx.update.policy/1", { ...policyValue, revision: Number.MAX_SAFE_INTEGER + 1 })); + assert.throws(() => checkField("ocx.update.policy/1", { ...policyValue, channel: "é" })); + for (const [schema, bytes, field] of [["ocx.update.prepared/1", prepared, "installationId"], ["ocx.update.activation/1", activation, "runtimeInstance"]]) { + const value = JSON.parse(bytes.toString()); + assert.ok(checkField(schema, { ...value, [field]: "a".repeat(128) })); + assert.throws(() => checkField(schema, { ...value, [field]: "a".repeat(129) })); + assert.throws(() => checkField(schema, { ...value, [field]: "é" })); + } } finally { rmSync(dir, { recursive: true, force: true }); } From 6176db61bf68a4678fcb5a1824f68ba6ff49cba4 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:34:32 +0900 Subject: [PATCH 31/42] Exercise malformed Unicode across runtimes --- tests/helpers/update-node-harness.mjs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index 98fb80b6888..7f5ae6b0281 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -171,6 +171,13 @@ try { assert.throws(() => checkField("ocx.link-capabilities/1", withCapabilityId("a".repeat(129)))); assert.throws(() => checkField("ocx.link-capabilities/1", withCapabilityId("é"))); const policyValue = JSON.parse(policy.toString()); + assert.ok(checkField("ocx.update.policy/1", policyValue)); + const channelOffset = policy.indexOf(Buffer.from("latest")); + assert.ok(channelOffset >= 0); + const malformedUtf8 = Buffer.concat([policy.subarray(0, channelOffset), Buffer.from([0xff]), policy.subarray(channelOffset + 6)]); + assert.throws(() => parseUpdateDocument(malformedUtf8, "ocx.update.policy/1")); + const loneSurrogate = Buffer.from(policy.toString().replace('"latest"', '"\\ud800"')); + assert.throws(() => parseUpdateDocument(loneSurrogate, "ocx.update.policy/1")); assert.ok(checkField("ocx.update.policy/1", { ...policyValue, revision: Number.MAX_SAFE_INTEGER })); assert.throws(() => checkField("ocx.update.policy/1", { ...policyValue, revision: Number.MAX_SAFE_INTEGER + 1 })); assert.throws(() => checkField("ocx.update.policy/1", { ...policyValue, channel: "é" })); From ba3970913f833dd6804995c074612029205aadb8 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:35:12 +0900 Subject: [PATCH 32/42] Prove malformed Unicode rejection is observable --- tests/helpers/update-node-harness.mjs | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index 7f5ae6b0281..a2cf30a0ca4 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -170,14 +170,17 @@ try { assert.ok(checkField("ocx.link-capabilities/1", withCapabilityId("a".repeat(128)))); assert.throws(() => checkField("ocx.link-capabilities/1", withCapabilityId("a".repeat(129)))); assert.throws(() => checkField("ocx.link-capabilities/1", withCapabilityId("é"))); + // Release-note text permits Unicode, so accepting replacement characters or + // lone surrogates here cannot be masked by an ASCII-only field validator. + const validText = Buffer.from(JSON.stringify(withTitle("marker"))); + assert.ok(parseUpdateDocument(validText, "ocx.update.release/1")); + const markerOffset = validText.indexOf(Buffer.from("marker")); + assert.ok(markerOffset >= 0); + const malformedUtf8 = Buffer.concat([validText.subarray(0, markerOffset), Buffer.from([0xff]), validText.subarray(markerOffset + 6)]); + assert.throws(() => parseUpdateDocument(malformedUtf8, "ocx.update.release/1")); + const loneSurrogate = Buffer.from(validText.toString().replace('"marker"', '"\\ud800"')); + assert.throws(() => parseUpdateDocument(loneSurrogate, "ocx.update.release/1")); const policyValue = JSON.parse(policy.toString()); - assert.ok(checkField("ocx.update.policy/1", policyValue)); - const channelOffset = policy.indexOf(Buffer.from("latest")); - assert.ok(channelOffset >= 0); - const malformedUtf8 = Buffer.concat([policy.subarray(0, channelOffset), Buffer.from([0xff]), policy.subarray(channelOffset + 6)]); - assert.throws(() => parseUpdateDocument(malformedUtf8, "ocx.update.policy/1")); - const loneSurrogate = Buffer.from(policy.toString().replace('"latest"', '"\\ud800"')); - assert.throws(() => parseUpdateDocument(loneSurrogate, "ocx.update.policy/1")); assert.ok(checkField("ocx.update.policy/1", { ...policyValue, revision: Number.MAX_SAFE_INTEGER })); assert.throws(() => checkField("ocx.update.policy/1", { ...policyValue, revision: Number.MAX_SAFE_INTEGER + 1 })); assert.throws(() => checkField("ocx.update.policy/1", { ...policyValue, channel: "é" })); From cc1c4f3dd232cc16c931080cd691d4ae6ba2580b Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:42:37 +0900 Subject: [PATCH 33/42] Bind verifier keys and parser input snapshots --- src/update/minisign.mjs | 18 ++++++++++++++---- src/update/update-bounded-json.mjs | 6 ++++-- tests/helpers/update-node-harness.mjs | 13 +++++++++++++ tests/update/update-bounded-json.test.ts | 11 +++++++++++ tests/update/update-contracts.test.ts | 4 ++++ tests/update/update-minisign.test.ts | 16 ++++++++++++++++ 6 files changed, 62 insertions(+), 6 deletions(-) diff --git a/src/update/minisign.mjs b/src/update/minisign.mjs index 256e07084f4..3b0b151c0eb 100644 --- a/src/update/minisign.mjs +++ b/src/update/minisign.mjs @@ -1,6 +1,7 @@ // Offline minisign primitives. These results prove only cryptographic validity; // update authority is assigned separately by the signed-supply policy. import { createHash, createPublicKey, verify } from "node:crypto"; +import { snapshotUpdateBytes } from "./update-bytes.mjs"; const ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex"); const TRUSTED_PREFIX = "trusted comment: "; @@ -54,15 +55,24 @@ function verifyBox(bytes, signatureBox, key, legacy) { const algorithm = packet.subarray(0, 2).toString("utf8"); if (algorithm !== "ED") throw new Error(`Unsupported signature algorithm: ${JSON.stringify(algorithm)}`); const keyId = packet.subarray(2, 10).toString("hex"); - if (keyId !== key.keyId) throw new Error(`Signature was made by key ${keyId}, not the pinned updater key ${key.keyId}`); + const expectedKeyId = key.keyId; + if (keyId !== expectedKeyId) throw new Error(`Signature was made by key ${keyId}, not the pinned updater key ${expectedKeyId}`); + // Capture one public-key representation, then reconstruct a private verifier + // so caller-controlled accessors cannot change the signer between checks. + let publicKeyDer; + try { publicKeyDer = snapshotUpdateBytes(key.publicKey.export({ format: "der", type: "spki" }), 44); } + catch { throw new Error("Malformed minisign public key"); } + if (publicKeyDer.length !== 44 || !Buffer.from(publicKeyDer.subarray(0, 12)).equals(ED25519_SPKI_PREFIX)) { + throw new Error("Malformed minisign public key"); + } + const publicKey = createPublicKey({ key: Buffer.from(publicKeyDer), format: "der", type: "spki" }); const signature = packet.subarray(10); const digest = createHash("blake2b512").update(bytes).digest(); - if (!verify(null, digest, key.publicKey, signature)) throw new Error("Signature verification failed"); + if (!verify(null, digest, publicKey, signature)) throw new Error("Signature verification failed"); const exactComment = lines[2].slice(TRUSTED_PREFIX.length); const trustedComment = legacy ? exactComment.trim() : exactComment; const message = Buffer.concat([signature, Buffer.from(trustedComment, "utf8")]); - if (!verify(null, message, key.publicKey, commentSignature)) throw new Error("Comment signature verification failed"); - const publicKeyDer = key.publicKey.export({ format: "der", type: "spki" }); + if (!verify(null, message, publicKey, commentSignature)) throw new Error("Comment signature verification failed"); const fingerprint = createHash("sha256").update(publicKeyDer.subarray(-32)).digest("hex"); return { keyId, fingerprint, trustedComment }; } diff --git a/src/update/update-bounded-json.mjs b/src/update/update-bounded-json.mjs index 0ecda3552ca..c38d4387cb7 100644 --- a/src/update/update-bounded-json.mjs +++ b/src/update/update-bounded-json.mjs @@ -1,4 +1,5 @@ // Parsing produces data only. It does not establish schema validity or trust. +import { snapshotUpdateBytes } from "./update-bytes.mjs"; const MAX_DOCUMENT_BYTES = 16 * 1024 * 1024; const MAX_DEPTH = 16; const MAX_MEMBERS = 32; @@ -26,10 +27,11 @@ function validUnicode(text) { /** Parse bounded UTF-8 JSON, refusing ambiguous names and unsafe numbers. */ export function parseBoundedJson(bytes, maxBytes) { if (!(bytes instanceof Uint8Array) || !Number.isSafeInteger(maxBytes) - || maxBytes < 1 || maxBytes > MAX_DOCUMENT_BYTES || bytes.byteLength > maxBytes) invalid(); + || maxBytes < 1 || maxBytes > MAX_DOCUMENT_BYTES) invalid(); let source; try { - source = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes); + const snapshot = snapshotUpdateBytes(bytes, maxBytes); + source = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(snapshot); } catch { invalid(); } diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index a2cf30a0ca4..2f97109af2d 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -23,6 +23,16 @@ const key = decodePublicKey(`untrusted comment: upstream key\n${fixture.publicKe const signature = Buffer.from(fixture.signatureBox).toString("base64"); assert.equal(verifyMinisignBytes(Buffer.from(fixture.payload), signature, key).keyId, key.keyId); assert.throws(() => verifyMinisignBytes(Buffer.from("changed"), signature, key)); +const pairA = generateKeyPairSync("ed25519"), pairB = generateKeyPairSync("ed25519"), pairC = generateKeyPairSync("ed25519"); +const hostileBytes = Buffer.from("key-snapshot"), hostileId = Buffer.alloc(8, 42), hostileComment = "version:1.2.3"; +const hostilePayload = sign(null, createHash("blake2b512").update(hostileBytes).digest(), pairA.privateKey); +const hostileGlobal = sign(null, Buffer.concat([hostilePayload, Buffer.from(hostileComment)]), pairB.privateKey); +const hostilePacket = Buffer.concat([Buffer.from("ED"), hostileId, hostilePayload]).toString("base64"); +const hostileBox = Buffer.from(`untrusted comment: fixture\n${hostilePacket}\ntrusted comment: ${hostileComment}\n${hostileGlobal.toString("base64")}\n`).toString("base64"); +let keyReads = 0; +const hostileKey = { keyId: hostileId.toString("hex"), get publicKey() { return [pairA.publicKey, pairB.publicKey, pairC.publicKey][keyReads++] ?? pairC.publicKey; } }; +assert.throws(() => verifyMinisignBytes(hostileBytes, hostileBox, hostileKey)); +assert.equal(keyReads, 1); assert.equal(deriveCandidateId("00".repeat(32), "linux-x64-npm"), "496737c902f9e38cbd89b81b0ba6935e245a026f4d0a931904ddd4617eafc7c4"); assert.ok(sameSignedVersion("18446744073709551615.0.0+build", "v18446744073709551615.0.0+build")); @@ -34,6 +44,9 @@ assert.ok(!trustedCommentMatchesVersion("version:1.2.3\tversion:1.2.3", "1.2.3") const encode = (text) => new TextEncoder().encode(text); assert.equal(parseBoundedJson(encode('{"a":[1,true]}'), 65536).a[0], 1); assert.throws(() => parseBoundedJson(encode('{"a":1,"\\u0061":2}'), 65536)); +const oversizedView = Buffer.from(`{}${" ".repeat(4095)}`); +Object.defineProperty(oversizedView, "byteLength", { value: 0 }); +assert.throws(() => parseBoundedJson(oversizedView, 4096)); const group = `[${Array(4096).fill("{}").join(",")}]`; assert.throws(() => parseBoundedJson(encode(`[${Array(20).fill(group).join(",")}]`), 16777216)); diff --git a/tests/update/update-bounded-json.test.ts b/tests/update/update-bounded-json.test.ts index 6e89e54c17c..dea0f4593ab 100644 --- a/tests/update/update-bounded-json.test.ts +++ b/tests/update/update-bounded-json.test.ts @@ -35,6 +35,17 @@ describe("bounded unverified update JSON", () => { expect(parse("[".repeat(16) + "0" + "]".repeat(16))).toBeDefined(); }); + test("does not trust a caller-shadowed byte length when enforcing the raw cap", () => { + const oversized = Buffer.from(`{}${" ".repeat(4095)}`); + Object.defineProperty(oversized, "byteLength", { value: 0 }); + expect(() => parseBoundedJson(oversized, 4096)).toThrow(); + const valid = Buffer.from("{}"); + let reads = 0; + Object.defineProperty(valid, "byteLength", { get() { reads++; return 0; } }); + expect(parseBoundedJson(valid, 4096)).toEqual({}); + expect(reads).toBe(0); + }); + test("bounds aggregate values while retaining the largest planned capability-array shape", () => { const entries = Array.from({ length: 4096 }, (_, index) => ({ id: `item-${index}`, version: 1 })); const capabilityShape = Object.fromEntries( diff --git a/tests/update/update-contracts.test.ts b/tests/update/update-contracts.test.ts index 518fa7fa5d7..d32661b43b4 100644 --- a/tests/update/update-contracts.test.ts +++ b/tests/update/update-contracts.test.ts @@ -74,6 +74,10 @@ describe("closed unverified update contracts", () => { expect(() => parseUpdateDocument(bytes(fixtures()["ocx.update.policy/1"]), "ocx.update.tree/1")).toThrow(); expect(() => Reflect.apply(parseUpdateDocument, null, [Buffer.from("{}"), "__proto__"])).toThrow(); const release = fixtures()["ocx.update.release/1"]; + const policyBytes = bytes(fixtures()["ocx.update.policy/1"]); + const oversizedPolicy = Buffer.concat([policyBytes, Buffer.alloc(4097 - policyBytes.length, 32)]); + Object.defineProperty(oversizedPolicy, "byteLength", { value: 0 }); + expect(() => parseUpdateDocument(oversizedPolicy, "ocx.update.policy/1")).toThrow(); release.releaseNotes = [{title: "é", body: "é"}]; const raw = bytes(release); const exact = Buffer.concat([raw, Buffer.alloc(1048576 - raw.length, 32)]); diff --git a/tests/update/update-minisign.test.ts b/tests/update/update-minisign.test.ts index 77e0b4f9109..8bfc6f149f1 100644 --- a/tests/update/update-minisign.test.ts +++ b/tests/update/update-minisign.test.ts @@ -6,6 +6,22 @@ import { decodePublicKey, verifyMinisignBytes, verifyLegacyMinisignBytes } from import { verifySignatureThreshold } from "../../src/update/update-signature-threshold.mjs"; describe("offline minisign verification", () => { + test("uses one key identity for both signatures and the returned fingerprint", () => { + const a = generateKeyPairSync("ed25519"), b = generateKeyPairSync("ed25519"), c = generateKeyPairSync("ed25519"); + const bytes = Buffer.from("fixture"), id = Buffer.alloc(8, 7), comment = "version:1.2.3"; + const payload = sign(null, createHash("blake2b512").update(bytes).digest(), a.privateKey); + const global = sign(null, Buffer.concat([payload, Buffer.from(comment)]), b.privateKey); + const packet = Buffer.concat([Buffer.from("ED"), id, payload]).toString("base64"); + const box = Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: ${comment}\n${global.toString("base64")}\n`).toString("base64"); + let reads = 0; + const key = { keyId: id.toString("hex"), get publicKey() { return [a.publicKey, b.publicKey, c.publicKey][reads++] ?? c.publicKey; }, fingerprint: "" }; + expect(() => verifyMinisignBytes(bytes, box, key)).toThrow(); + expect(reads).toBe(1); + const sameKeyGlobal = sign(null, Buffer.concat([payload, Buffer.from(comment)]), a.privateKey); + const sameKeyBox = Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: ${comment}\n${sameKeyGlobal.toString("base64")}\n`).toString("base64"); + Object.defineProperty(a.publicKey, "export", { value: () => c.publicKey.export({ format: "der", type: "spki" }) }); + expect(() => verifyMinisignBytes(bytes, sameKeyBox, { keyId: id.toString("hex"), publicKey: a.publicKey, fingerprint: "" })).toThrow(/Signature verification failed/); + }); test("accepts the independent upstream prehashed vector and rejects changed bytes", () => { const fixture = JSON.parse(readFileSync(repoPath("tests/fixtures/minisign/prehashed-vector.json"), "utf8")); const key = decodePublicKey(`untrusted comment: upstream key\n${fixture.publicKeyBase64}\n`); From 8c927ba1fc37041d3eaeea6dc288118ca496d6a3 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:43:18 +0900 Subject: [PATCH 34/42] Exercise full root thresholds on Node 18 --- tests/helpers/update-node-harness.mjs | 32 ++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index 2f97109af2d..e7c04990ead 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -2,7 +2,7 @@ // node tests/helpers/update-node-harness.mjs --require-node18 // This harness performs offline checks only; it never reads an installation. import assert from "node:assert/strict"; -import { copyFileSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; +import { copyFileSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; import { createHash, generateKeyPairSync, sign } from "node:crypto"; import { tmpdir } from "node:os"; import { join } from "node:path"; @@ -102,6 +102,36 @@ try { for (const time of [rootExpiry, rootExpiry + 1, -1, NaN, Infinity, 1.5, Number.MAX_SAFE_INTEGER + 1]) { assert.throws(() => supply.verifyRootTransition(basis, after, envelope(signed), time)); } + const unionKeys = Array.from({ length: 33 }, (_, i) => makeKey(i + 10)); + for (const count of [9, 16]) { + const fixtureDir = join(dir, `threshold-${count}`); + mkdirSync(fixtureDir); + for (const name of ["signed-supply.mjs", "update-bytes.mjs", "update-contracts.mjs", "update-bounded-json.mjs", "update-candidate-id.mjs", "update-signed-version.mjs", "update-signature-threshold.mjs", "minisign.mjs"]) copyFileSync(join(dir, name), join(fixtureDir, name)); + const oldRoot = Buffer.from(JSON.stringify({ ...buildRoot(unionKeys.slice(0, count), 1), rootThreshold: count })); + const newRoot = Buffer.from(JSON.stringify({ ...buildRoot(unionKeys.slice(16, 16 + count), 2), rootThreshold: count })); + writeFileSync(join(fixtureDir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${createHash("sha256").update(oldRoot).digest("hex")}";\n`); + const unionSupply = await import(pathToFileURL(join(fixtureDir, "signed-supply.mjs")).href); + const oldBasis = unionSupply.bootstrapEmbeddedRoot(oldRoot, now); + const entries = [...unionKeys.slice(0, count), ...unionKeys.slice(16, 16 + count)].map(key => signEntry(newRoot, key)); + assert.equal(unionSupply.inspectTransition(unionSupply.verifyRootTransition(oldBasis, newRoot, envelope(entries), now)).successorRevision, 2); + assert.throws(() => unionSupply.verifyRootTransition(oldBasis, newRoot, envelope(entries.slice(1)), now)); + assert.throws(() => unionSupply.verifyRootTransition(oldBasis, newRoot, envelope([...entries, entries[0]]), now)); + assert.throws(() => unionSupply.verifyRootTransition(oldBasis, newRoot, envelope([...entries, signEntry(newRoot, unionKeys[32])]), now)); + const changed = [...entries]; changed[0] = signEntry(Buffer.from("different"), unionKeys[0]); + assert.throws(() => unionSupply.verifyRootTransition(oldBasis, newRoot, envelope(changed), now)); + if (count === 16) { + const overlapping = [unionKeys[0], ...unionKeys.slice(16, 31)]; + const overlapObject = { ...buildRoot(overlapping, 2), rootThreshold: 16 }; + const overlapBytes = Buffer.from(JSON.stringify(overlapObject)); + const overlapSigners = [...unionKeys.slice(0, 16), ...unionKeys.slice(16, 31)]; + const overlapEntries = overlapSigners.map(key => signEntry(overlapBytes, key)); + assert.equal(unionSupply.inspectTransition(unionSupply.verifyRootTransition(oldBasis, overlapBytes, envelope(overlapEntries), now)).successorRevision, 2); + const raw = Buffer.from(unionKeys[0].pair.publicKey.export({ format: "der", type: "spki" })).subarray(-32); + overlapObject.rootKeys[0].publicKey = Buffer.from(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), Buffer.alloc(8, 201), raw]).toString("base64")}\n`).toString("base64"); + const incompatibleBytes = Buffer.from(JSON.stringify(overlapObject)); + assert.throws(() => unionSupply.verifyRootTransition(oldBasis, incompatibleBytes, envelope(overlapSigners.map(key => signEntry(incompatibleBytes, key))), now), /packet identifiers/); + } + } const digest = (bytes) => ({ sha256: createHash("sha256").update(bytes).digest("hex"), size: bytes.length }); const metadataEnvelope = (bytes) => Buffer.from(JSON.stringify({ schema: "ocx.update.signatures/1", signatures: [signEntry(bytes, keys[2])] })); const artifact = Buffer.from("fixture artifact"); From 04b14a1ee594e5d24020a369be979513bc798a44 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 18:45:04 +0900 Subject: [PATCH 35/42] Exercise signed version and legacy adapter parity --- tests/helpers/update-node-harness.mjs | 25 ++++++++-- tests/helpers/update-release-adapter-entry.ts | 3 ++ .../update-release-adapter-harness.mjs | 47 +++++++++++++++++++ 3 files changed, 72 insertions(+), 3 deletions(-) create mode 100644 tests/helpers/update-release-adapter-entry.ts create mode 100644 tests/helpers/update-release-adapter-harness.mjs diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index e7c04990ead..bfc0ec77900 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -82,11 +82,11 @@ try { writeFileSync(join(dir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${createHash("sha256").update(before).digest("hex")}";\n`); const supply = await import(pathToFileURL(join(dir, "signed-supply.mjs")).href); const basis = supply.bootstrapEmbeddedRoot(before, Date.parse("2027-01-01T00:00:00Z")); - const signEntry = (bytes, { pair, id, key }) => { + const signEntry = (bytes, { pair, id, key }, comment = "version:1.2.3", signedComment = comment, newline = "\n") => { const payload = sign(null, createHash("blake2b512").update(bytes).digest(), pair.privateKey); - const global = sign(null, Buffer.concat([payload, Buffer.from("version:1.2.3")]), pair.privateKey); + const global = sign(null, Buffer.concat([payload, Buffer.from(signedComment)]), pair.privateKey); const packet = Buffer.concat([Buffer.from("ED"), id, payload]).toString("base64"); - const box = Buffer.from(`untrusted comment: fixture\n${packet}\ntrusted comment: version:1.2.3\n${global.toString("base64")}\n`).toString("base64"); + const box = Buffer.from(["untrusted comment: fixture", packet, `trusted comment: ${comment}`, global.toString("base64"), ""].join(newline)).toString("base64"); return { keyFingerprint: key.keyId, signatureBox: box }; }; const signed = keys.map(key => signEntry(after, key)); @@ -152,6 +152,25 @@ try { assert.throws(() => supply.verifyArtifactEvidence(candidate, Buffer.from("wrong"), successor, now)); assert.throws(() => supply.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: tree, signatureEnvelopeBytes: metadataEnvelope(Buffer.from("wrong")), receiptEvidence }, successor, now)); assert.throws(() => supply.verifyReleaseEvidence(release, metadataEnvelope(release), successor, "preview", now)); + const commentCases = [ + { version: "1.2.3", comment: "version:v1.2.3", allowed: true, newline: "\n" }, + { version: "1.2.3+one", comment: "version:1.2.3+one", allowed: true, newline: "\r\n" }, + { version: "1.2.3+one", comment: "version:1.2.3+two", allowed: false, newline: "\n" }, + { version: "1.2.3", comment: "timestamp:1", allowed: false, newline: "\n" }, + { version: "1.2.3", comment: "version:1.2.3\tversion:1.2.3", allowed: false, newline: "\n" }, + { version: "1.2.3", comment: " timestamp:1\tversion:1.2.3\t", allowed: true, newline: "\r\n" }, + { version: "1.2.3", comment: " timestamp:1\tversion:1.2.3\t", signedComment: "timestamp:1\tversion:1.2.3", allowed: false, newline: "\n" }, + ]; + for (const item of commentCases) { + const value = JSON.parse(release.toString()); + value.version = item.version; + value.targets[0].assetName = `ocx-update-${item.version}-latest-${target}.tar.gz`; + value.targets[0].artifact.signatureBox = signEntry(artifact, keys[2], item.comment, item.signedComment ?? item.comment, item.newline).signatureBox; + const bytes = Buffer.from(JSON.stringify(value)); + const selected = supply.selectTargetEvidence(supply.verifyReleaseEvidence(bytes, metadataEnvelope(bytes), successor, "latest", now), { platform: "linux", arch: "x64", owner: "npm", artifactKind: "tree", bundleKind: "tar-gz" }); + const verify = () => supply.verifyArtifactEvidence(selected, artifact, successor, now); + if (item.allowed) assert.ok(Object.isFrozen(verify())); else assert.throws(verify); + } const token = Buffer.alloc(32, 9).toString("base64url"); const operationId = "12345678-1234-1234-1234-123456789abc"; diff --git a/tests/helpers/update-release-adapter-entry.ts b/tests/helpers/update-release-adapter-entry.ts new file mode 100644 index 00000000000..e6c2ec9e6a3 --- /dev/null +++ b/tests/helpers/update-release-adapter-entry.ts @@ -0,0 +1,3 @@ +// A non-main entry keeps the release CLI dormant when its actual exports are +// bundled for the Node 18 interoperability harness. +export { parseMinisignPublicKey, verifyUpdaterSignature } from "../../desktop/scripts/verify-release-assets"; diff --git a/tests/helpers/update-release-adapter-harness.mjs b/tests/helpers/update-release-adapter-harness.mjs new file mode 100644 index 00000000000..3a3c5f216f1 --- /dev/null +++ b/tests/helpers/update-release-adapter-harness.mjs @@ -0,0 +1,47 @@ +// Build the repository's actual TypeScript release adapter for Node first: +// bun build tests/helpers/update-release-adapter-entry.ts --target=node --format=esm --outfile .tmp/auto-update-parity/verify-release-assets-node.mjs +// Then pass that bundle as the only argument to Node 18 and Bun. No release is published. +import assert from "node:assert/strict"; +import { createHash, generateKeyPairSync, sign } from "node:crypto"; +import { mkdtempSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join, resolve } from "node:path"; +import { pathToFileURL } from "node:url"; +import { decodePublicKey, verifyMinisignBytes } from "../../src/update/minisign.mjs"; + +assert.equal(process.argv.length, 3, "pass the built release-adapter module"); +const adapter = await import(pathToFileURL(resolve(process.argv[2])).href); +const dir = mkdtempSync(join(tmpdir(), "ocx-release-adapter-")); +try { + const { publicKey, privateKey } = generateKeyPairSync("ed25519"); + const raw = Buffer.from(publicKey.export({ format: "der", type: "spki" })).subarray(-32); + const id = Buffer.alloc(8, 7); + const publicBox = `untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), id, raw]).toString("base64")}\n`; + const strictKey = decodePublicKey(publicBox), legacyKey = adapter.parseMinisignPublicKey(publicBox); + const bytes = Buffer.from("fixture artifact"), asset = join(dir, "artifact"); + writeFileSync(asset, bytes); + const signature = sign(null, createHash("blake2b512").update(bytes).digest(), privateKey); + const packet = Buffer.concat([Buffer.from("ED"), id, signature]).toString("base64"); + const box = (comment, signedComment, newline) => { + const global = sign(null, Buffer.concat([signature, Buffer.from(signedComment)]), privateKey).toString("base64"); + return Buffer.from(["untrusted comment: fixture", packet, `trusted comment: ${comment}`, global, ""].join(newline)).toString("base64"); + }; + for (const newline of ["\n", "\r\n"]) { + const comment = " timestamp:1\tversion:1.2.3\t"; + const exact = box(comment, comment, newline); + writeFileSync(`${asset}.sig`, exact); + assert.equal(verifyMinisignBytes(bytes, exact, strictKey).trustedComment, comment); + assert.throws(() => adapter.verifyUpdaterSignature(asset, legacyKey), /Comment signature verification failed/); + const normalized = box(comment, comment.trim(), newline); + writeFileSync(`${asset}.sig`, normalized); + assert.throws(() => verifyMinisignBytes(bytes, normalized, strictKey), /Comment signature verification failed/); + assert.doesNotThrow(() => adapter.verifyUpdaterSignature(asset, legacyKey)); + const versionless = box("timestamp:1", "timestamp:1", newline); + writeFileSync(`${asset}.sig`, versionless); + assert.doesNotThrow(() => adapter.verifyUpdaterSignature(asset, legacyKey)); + assert.equal(verifyMinisignBytes(bytes, versionless, strictKey).trustedComment, "timestamp:1"); + } +} finally { + rmSync(dir, { recursive: true, force: true }); +} +console.log(`Release adapter harness passed on ${globalThis.Bun ? `Bun ${globalThis.Bun.version}` : `Node ${process.versions.node}`}`); From 01dd17f60be3ed105d67439a07f240a8814f24bd Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 19:02:30 +0900 Subject: [PATCH 36/42] Exercise signed evidence for every target tuple --- tests/update/update-external-metadata.test.ts | 40 ++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-) diff --git a/tests/update/update-external-metadata.test.ts b/tests/update/update-external-metadata.test.ts index 2f32619e9db..2f9ca0e7419 100644 --- a/tests/update/update-external-metadata.test.ts +++ b/tests/update/update-external-metadata.test.ts @@ -24,7 +24,7 @@ describe("external signed update metadata", () => { const otherFingerprint = createHash("sha256").update(otherRaw).digest("hex"); const otherPublicKey = Buffer.from(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), otherId, otherRaw]).toString("base64")}\n`).toString("base64"); const otherKey = { keyId: otherFingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey: otherPublicKey }; - const root = Buffer.from(JSON.stringify({ schema: "ocx.update.root/1", revision: 1, expiresAt: "2030-01-01T00:00:00Z", rootKeys: [key], rootThreshold: 1, releaseKeys: [{ ...key, channels: ["latest"], roles: ["release", "tree", "guardian-artifact", "standalone-artifact"] }, { ...otherKey, channels: ["latest"], roles: ["release"] }], releaseThreshold: 1, channels: ["latest"] })); + const root = Buffer.from(JSON.stringify({ schema: "ocx.update.root/1", revision: 1, expiresAt: "2030-01-01T00:00:00Z", rootKeys: [key], rootThreshold: 1, releaseKeys: [{ ...key, channels: ["latest"], roles: ["release", "tree", "guardian-artifact", "standalone-artifact", "desktop-artifact"] }, { ...otherKey, channels: ["latest"], roles: ["release"] }], releaseThreshold: 1, channels: ["latest"] })); writeFileSync(join(dir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${createHash("sha256").update(root).digest("hex")}";\n`); const fixture = await import(pathToFileURL(join(dir, "signed-supply.mjs")).href); const signBox = (bytes: Buffer, privateKey = pair.privateKey, packetId = id, version = "1.2.3") => { @@ -173,6 +173,44 @@ describe("external signed update metadata", () => { const wrongTreeReceiptEvidence = fixture.verifyExternalMetadataEvidence(wrongTreeCandidate, { kind: "receipt", bytes: wrongTreeReceiptBytes }, basis, now); expect(() => fixture.verifyExternalMetadataEvidence(wrongTreeCandidate, { kind: "tree", bytes: wrongTree, signatureEnvelopeBytes: wrongTreeEnvelope, receiptEvidence: wrongTreeReceiptEvidence }, basis, now)).toThrow(/Tree target mismatch/); + // Every supported tuple gets its own signed artifact and exact receipt / + // metadata chain. These synthetic bytes do not prove payload layout. + const tuples: { platform: string; arch: string; owner: string; artifactKind: string; bundleKind: string; id: string }[] = []; + for (const [platform, arch] of [["macos", "x64"], ["macos", "arm64"], ["windows", "x64"], ["linux", "x64"], ["linux", "arm64"]]) { + const prefix = `${platform}-${arch}`; + const add = (owner: string, artifactKind: string, bundleKind: string, id: string) => tuples.push({ platform, arch, owner, artifactKind, bundleKind, id }); + if (platform === "macos") add("desktop", "tauri", "app-tar-gz", `${prefix}-desktop-tauri`); + if (platform === "windows") add("desktop", "tauri", "msi", `${prefix}-desktop-tauri`); + if (platform === "linux" && arch === "x64") for (const bundle of ["appimage", "deb"]) add("desktop", "tauri", bundle, `${prefix}-desktop-${bundle}`); + add("standalone", "standalone", platform === "windows" ? "zip" : "tar-gz", `${prefix}-standalone`); + for (const owner of ["npm", "pnpm", "bun"]) add(owner, "tree", "tar-gz", `${prefix}-${owner}`); + if (!(platform === "linux" && arch === "arm64")) add("desktop", "guardian", "binary", `${prefix}-desktop-guardian`); + add("standalone", "guardian", "binary", `${prefix}-standalone-guardian`); + } + expect(tuples).toHaveLength(34); + for (const tuple of tuples) { + const metadataPrefix = `ocx-update-1.2.3-latest-${tuple.id}`; + const targetAsset = tuple.artifactKind === "tree" || tuple.artifactKind === "guardian" + ? `${metadataPrefix}${tuple.artifactKind === "tree" ? ".tar.gz" : ""}` + : tuple.artifactKind === "standalone" ? `ocx-1.2.3-bun-${tuple.platform === "macos" ? "darwin" : tuple.platform}-${tuple.arch}.${tuple.platform === "windows" ? "zip" : "tar.gz"}` + : `OpenCodex-1.2.3-${tuple.platform === "macos" ? "macos.app.tar.gz" : tuple.platform === "windows" ? "windows-x64.msi" : tuple.bundleKind === "deb" ? "linux-amd64.deb" : "linux-x86_64.AppImage"}`; + const targetCapability = Buffer.from(JSON.stringify({ ...JSON.parse(capability.toString()), target: tuple.id })); + const hasTree = tuple.artifactKind === "tree" || tuple.artifactKind === "standalone"; + const targetTree = Buffer.from(JSON.stringify({ ...JSON.parse(tree.toString()), target: tuple.id })); + const targetTreeEnvelope = envelope(targetTree); + const targetAssets: [string, Buffer][] = [[targetAsset, artifact], [`${metadataPrefix}.capabilities.json`, targetCapability]]; + if (hasTree) targetAssets.push([`${metadataPrefix}.tree.json`, targetTree], [`${metadataPrefix}.tree.json.signatures.json`, targetTreeEnvelope]); + const targetProof = { assetName: targetAsset, artifactSha256: digest(artifact).sha256, inspectionSha256: "e".repeat(64) }; + const targetReceipt = Buffer.from(JSON.stringify({ ...JSON.parse(receipt.toString()), assets: targetAssets.map(([name, bytes]) => ({ name, ...digest(bytes) })).sort((a, b) => a.name < b.name ? -1 : 1), universalProofs: tuple.platform === "macos" && tuple.artifactKind === "tauri" ? [{ ...targetProof, architectures: ["arm64", "x64"] }] : [], architectureProofs: tuple.platform === "macos" && tuple.artifactKind !== "tauri" ? [{ ...targetProof, targetId: tuple.id, arch: tuple.arch }] : [] })); + const targetRelease = Buffer.from(JSON.stringify({ ...JSON.parse(release.toString()), receipt: digest(targetReceipt), targets: [{ ...tuple, assetName: targetAsset, artifact: { ...digest(artifact), signatureBox: signBox(artifact), signerFingerprint: fingerprint }, tree: hasTree ? digest(targetTree) : null, capabilities: digest(targetCapability) }] })); + const targetReleaseEvidence = fixture.verifyReleaseEvidence(targetRelease, envelope(targetRelease), basis, "latest", now); + const targetCandidate = fixture.selectTargetEvidence(targetReleaseEvidence, { platform: tuple.platform, arch: tuple.arch, owner: tuple.owner, artifactKind: tuple.artifactKind, bundleKind: tuple.bundleKind }); + expect(() => fixture.verifyArtifactEvidence(targetCandidate, artifact, basis, now)).not.toThrow(); + const targetReceiptEvidence = fixture.verifyExternalMetadataEvidence(targetCandidate, { kind: "receipt", bytes: targetReceipt }, basis, now); + expect(() => fixture.verifyExternalMetadataEvidence(targetCandidate, { kind: "capability", bytes: targetCapability, receiptEvidence: targetReceiptEvidence }, basis, now)).not.toThrow(); + if (hasTree) expect(() => fixture.verifyExternalMetadataEvidence(targetCandidate, { kind: "tree", bytes: targetTree, signatureEnvelopeBytes: targetTreeEnvelope, receiptEvidence: targetReceiptEvidence }, basis, now)).not.toThrow(); + } + // Desktop's shared macOS archive requires universal proof for either target. for (const arch of ["x64", "arm64"]) { const macTarget = `macos-${arch}-desktop-tauri`; From 25d08222d9baf206f9b0919563f486225fad6ebf Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 19:05:43 +0900 Subject: [PATCH 37/42] Verify evidence across supported channels --- tests/update/update-external-metadata.test.ts | 24 ++++++++++--------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/tests/update/update-external-metadata.test.ts b/tests/update/update-external-metadata.test.ts index 2f9ca0e7419..13e3bd762c9 100644 --- a/tests/update/update-external-metadata.test.ts +++ b/tests/update/update-external-metadata.test.ts @@ -24,7 +24,7 @@ describe("external signed update metadata", () => { const otherFingerprint = createHash("sha256").update(otherRaw).digest("hex"); const otherPublicKey = Buffer.from(`untrusted comment: fixture\n${Buffer.concat([Buffer.from("Ed"), otherId, otherRaw]).toString("base64")}\n`).toString("base64"); const otherKey = { keyId: otherFingerprint, algorithm: "minisign-ed25519-blake2b512/1", publicKey: otherPublicKey }; - const root = Buffer.from(JSON.stringify({ schema: "ocx.update.root/1", revision: 1, expiresAt: "2030-01-01T00:00:00Z", rootKeys: [key], rootThreshold: 1, releaseKeys: [{ ...key, channels: ["latest"], roles: ["release", "tree", "guardian-artifact", "standalone-artifact", "desktop-artifact"] }, { ...otherKey, channels: ["latest"], roles: ["release"] }], releaseThreshold: 1, channels: ["latest"] })); + const root = Buffer.from(JSON.stringify({ schema: "ocx.update.root/1", revision: 1, expiresAt: "2030-01-01T00:00:00Z", rootKeys: [key], rootThreshold: 1, releaseKeys: [{ ...key, channels: ["latest", "preview", "nightly"], roles: ["release", "tree", "guardian-artifact", "standalone-artifact", "desktop-artifact"] }, { ...otherKey, channels: ["latest"], roles: ["release"] }], releaseThreshold: 1, channels: ["latest", "preview", "nightly"] })); writeFileSync(join(dir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${createHash("sha256").update(root).digest("hex")}";\n`); const fixture = await import(pathToFileURL(join(dir, "signed-supply.mjs")).href); const signBox = (bytes: Buffer, privateKey = pair.privateKey, packetId = id, version = "1.2.3") => { @@ -188,22 +188,24 @@ describe("external signed update metadata", () => { add("standalone", "guardian", "binary", `${prefix}-standalone-guardian`); } expect(tuples).toHaveLength(34); - for (const tuple of tuples) { - const metadataPrefix = `ocx-update-1.2.3-latest-${tuple.id}`; + for (const channel of ["latest", "preview", "nightly"]) for (const tuple of tuples) { + const version = channel === "latest" ? "1.2.3" : "1.2.3-preview.7"; + const metadataPrefix = `ocx-update-${version}-${channel}-${tuple.id}`; const targetAsset = tuple.artifactKind === "tree" || tuple.artifactKind === "guardian" ? `${metadataPrefix}${tuple.artifactKind === "tree" ? ".tar.gz" : ""}` - : tuple.artifactKind === "standalone" ? `ocx-1.2.3-bun-${tuple.platform === "macos" ? "darwin" : tuple.platform}-${tuple.arch}.${tuple.platform === "windows" ? "zip" : "tar.gz"}` - : `OpenCodex-1.2.3-${tuple.platform === "macos" ? "macos.app.tar.gz" : tuple.platform === "windows" ? "windows-x64.msi" : tuple.bundleKind === "deb" ? "linux-amd64.deb" : "linux-x86_64.AppImage"}`; - const targetCapability = Buffer.from(JSON.stringify({ ...JSON.parse(capability.toString()), target: tuple.id })); + : tuple.artifactKind === "standalone" ? `ocx-${version}-bun-${tuple.platform === "macos" ? "darwin" : tuple.platform}-${tuple.arch}.${tuple.platform === "windows" ? "zip" : "tar.gz"}` + : `OpenCodex-${version}-${tuple.platform === "macos" ? "macos.app.tar.gz" : tuple.platform === "windows" ? "windows-x64.msi" : tuple.bundleKind === "deb" ? "linux-amd64.deb" : "linux-x86_64.AppImage"}`; + const targetCapability = Buffer.from(JSON.stringify({ ...JSON.parse(capability.toString()), version, channel, target: tuple.id })); const hasTree = tuple.artifactKind === "tree" || tuple.artifactKind === "standalone"; - const targetTree = Buffer.from(JSON.stringify({ ...JSON.parse(tree.toString()), target: tuple.id })); + const targetTree = Buffer.from(JSON.stringify({ ...JSON.parse(tree.toString()), version, target: tuple.id })); const targetTreeEnvelope = envelope(targetTree); const targetAssets: [string, Buffer][] = [[targetAsset, artifact], [`${metadataPrefix}.capabilities.json`, targetCapability]]; if (hasTree) targetAssets.push([`${metadataPrefix}.tree.json`, targetTree], [`${metadataPrefix}.tree.json.signatures.json`, targetTreeEnvelope]); const targetProof = { assetName: targetAsset, artifactSha256: digest(artifact).sha256, inspectionSha256: "e".repeat(64) }; - const targetReceipt = Buffer.from(JSON.stringify({ ...JSON.parse(receipt.toString()), assets: targetAssets.map(([name, bytes]) => ({ name, ...digest(bytes) })).sort((a, b) => a.name < b.name ? -1 : 1), universalProofs: tuple.platform === "macos" && tuple.artifactKind === "tauri" ? [{ ...targetProof, architectures: ["arm64", "x64"] }] : [], architectureProofs: tuple.platform === "macos" && tuple.artifactKind !== "tauri" ? [{ ...targetProof, targetId: tuple.id, arch: tuple.arch }] : [] })); - const targetRelease = Buffer.from(JSON.stringify({ ...JSON.parse(release.toString()), receipt: digest(targetReceipt), targets: [{ ...tuple, assetName: targetAsset, artifact: { ...digest(artifact), signatureBox: signBox(artifact), signerFingerprint: fingerprint }, tree: hasTree ? digest(targetTree) : null, capabilities: digest(targetCapability) }] })); - const targetReleaseEvidence = fixture.verifyReleaseEvidence(targetRelease, envelope(targetRelease), basis, "latest", now); + const targetReceipt = Buffer.from(JSON.stringify({ ...JSON.parse(receipt.toString()), version, channel, assets: targetAssets.map(([name, bytes]) => ({ name, ...digest(bytes) })).sort((a, b) => a.name < b.name ? -1 : 1), universalProofs: tuple.platform === "macos" && tuple.artifactKind === "tauri" ? [{ ...targetProof, architectures: ["arm64", "x64"] }] : [], architectureProofs: tuple.platform === "macos" && tuple.artifactKind !== "tauri" ? [{ ...targetProof, targetId: tuple.id, arch: tuple.arch }] : [] })); + const targetRelease = Buffer.from(JSON.stringify({ ...JSON.parse(release.toString()), version, channel, receipt: digest(targetReceipt), targets: [{ ...tuple, assetName: targetAsset, artifact: { ...digest(artifact), signatureBox: signBox(artifact, pair.privateKey, id, version), signerFingerprint: fingerprint }, tree: hasTree ? digest(targetTree) : null, capabilities: digest(targetCapability) }] })); + const targetReleaseEvidence = fixture.verifyReleaseEvidence(targetRelease, envelope(targetRelease), basis, channel, now); + expect(() => fixture.verifyReleaseEvidence(targetRelease, envelope(targetRelease), basis, channel === "preview" ? "nightly" : "preview", now)).toThrow(/Signed release channel mismatch/); const targetCandidate = fixture.selectTargetEvidence(targetReleaseEvidence, { platform: tuple.platform, arch: tuple.arch, owner: tuple.owner, artifactKind: tuple.artifactKind, bundleKind: tuple.bundleKind }); expect(() => fixture.verifyArtifactEvidence(targetCandidate, artifact, basis, now)).not.toThrow(); const targetReceiptEvidence = fixture.verifyExternalMetadataEvidence(targetCandidate, { kind: "receipt", bytes: targetReceipt }, basis, now); @@ -256,7 +258,7 @@ describe("external signed update metadata", () => { const thresholdDir = join(dir, "threshold"); mkdirSync(thresholdDir); for (const name of ["signed-supply.mjs", "update-bytes.mjs", "update-contracts.mjs", "update-bounded-json.mjs", "update-candidate-id.mjs", "update-signed-version.mjs", "update-signature-threshold.mjs", "minisign.mjs"]) copyFileSync(repoPath("src/update", name), join(thresholdDir, name)); - const thresholdRoot = Buffer.from(JSON.stringify({ ...JSON.parse(root.toString()), releaseKeys: [{ ...key, channels: ["latest"], roles: ["release", "tree"] }, { ...otherKey, channels: ["latest"], roles: ["release", "tree"] }], releaseThreshold: 2 })); + const thresholdRoot = Buffer.from(JSON.stringify({ ...JSON.parse(root.toString()), channels: ["latest"], releaseKeys: [{ ...key, channels: ["latest"], roles: ["release", "tree"] }, { ...otherKey, channels: ["latest"], roles: ["release", "tree"] }], releaseThreshold: 2 })); writeFileSync(join(thresholdDir, "update-trust-anchor.mjs"), `export const EMBEDDED_ROOT_SHA256 = "${createHash("sha256").update(thresholdRoot).digest("hex")}";\n`); const thresholdFixture = await import(pathToFileURL(join(thresholdDir, "signed-supply.mjs")).href); const thresholdBasis = thresholdFixture.bootstrapEmbeddedRoot(thresholdRoot, now); From 8e52a10ea5dbb825075f7f03b1bc45eb0f20f19a Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 19:15:32 +0900 Subject: [PATCH 38/42] Expose detached signed supply evidence snapshots --- src/update/signed-supply.d.mts | 22 +++++ src/update/signed-supply.mjs | 64 +++++++++++++- structure/runtime.md | 2 +- tests/helpers/update-node-harness.mjs | 86 +++++++++++++++++-- tests/update/update-external-metadata.test.ts | 13 +++ tests/update/update-signed-supply.test.ts | 8 +- 6 files changed, 184 insertions(+), 11 deletions(-) diff --git a/src/update/signed-supply.d.mts b/src/update/signed-supply.d.mts index 6520a02f1cb..a12849ed4c1 100644 --- a/src/update/signed-supply.d.mts +++ b/src/update/signed-supply.d.mts @@ -25,6 +25,19 @@ export interface UpdateSelection { artifactKind: "tauri" | "tree" | "standalone" | "guardian"; bundleKind: "app-tar-gz" | "msi" | "appimage" | "deb" | "zip" | "tar-gz" | "binary"; } +/** Detached diagnostic data; none of these shapes is an evidence handle. */ +export interface SnapshotBasis { readonly basisDigest: string; readonly basisRevision: number } +export interface SnapshotTargetBinding extends SnapshotBasis { readonly releaseDigest: string; readonly targetId: string; readonly candidateId: string } +export interface RootEvidenceSnapshot { readonly kind: "root"; readonly rootBytes: Uint8Array; readonly rootDigest: string; readonly rootRevision: number; readonly anchorDigest: string } +export interface TransitionEvidenceSnapshot { readonly kind: "transition"; readonly rootBytes: Uint8Array; readonly envelopeBytes: Uint8Array; readonly rootDigest: string; readonly rootRevision: number; readonly predecessorDigest: string; readonly predecessorRevision: number } +export interface ReleaseEvidenceSnapshot extends SnapshotBasis { readonly kind: "release"; readonly releaseBytes: Uint8Array; readonly envelopeBytes: Uint8Array; readonly releaseDigest: string; readonly channel: "latest" | "preview" | "nightly" } +export interface TargetEvidenceSnapshot extends SnapshotTargetBinding { readonly kind: "target"; readonly selection: Readonly } +export interface ArtifactEvidenceSnapshot extends SnapshotTargetBinding { readonly kind: "artifact"; readonly artifactDigest: string; readonly artifactSize: number; readonly signatureBox: string; readonly signerFingerprint: string } +export interface ReceiptEvidenceSnapshot extends SnapshotTargetBinding { readonly kind: "receipt"; readonly receiptBytes: Uint8Array; readonly receiptDigest: string; readonly receiptSize: number } +export interface TreeEvidenceSnapshot extends SnapshotTargetBinding { readonly kind: "tree"; readonly treeBytes: Uint8Array; readonly envelopeBytes: Uint8Array; readonly treeDigest: string; readonly treeSize: number; readonly envelopeDigest: string; readonly envelopeSize: number; readonly receiptDigest: string } +export interface CapabilityEvidenceSnapshot extends SnapshotTargetBinding { readonly kind: "capability"; readonly capabilityBytes: Uint8Array; readonly capabilityDigest: string; readonly capabilitySize: number; readonly receiptDigest: string } +export type EvidenceHandle = RootBasis | ReleaseEvidence | TargetEvidence | ArtifactEvidence | ReceiptEvidence | TreeEvidence | CapabilityEvidence; +export type EvidenceSnapshot = RootEvidenceSnapshot | TransitionEvidenceSnapshot | ReleaseEvidenceSnapshot | TargetEvidenceSnapshot | ArtifactEvidenceSnapshot | ReceiptEvidenceSnapshot | TreeEvidenceSnapshot | CapabilityEvidenceSnapshot; export function bootstrapEmbeddedRoot(bytes: Uint8Array, nowMs: number): RootEvidence; export function verifyRootTransition(predecessorBasis: RootBasis, bytes: Uint8Array, envelopeBytes: Uint8Array, nowMs: number): VerifiedRootTransition; @@ -35,3 +48,12 @@ export function verifyArtifactEvidence(target: TargetEvidence, bytes: Uint8Array export function verifyExternalMetadataEvidence(target: TargetEvidence, input: { kind: "receipt"; bytes: Uint8Array }, basis: RootBasis, nowMs: number): ReceiptEvidence; export function verifyExternalMetadataEvidence(target: TargetEvidence, input: { kind: "tree"; bytes: Uint8Array; signatureEnvelopeBytes: Uint8Array; receiptEvidence: ReceiptEvidence }, basis: RootBasis, nowMs: number): TreeEvidence; export function verifyExternalMetadataEvidence(target: TargetEvidence, input: { kind: "capability"; bytes: Uint8Array; receiptEvidence: ReceiptEvidence }, basis: RootBasis, nowMs: number): CapabilityEvidence; +export function snapshotEvidence(handle: RootEvidence): RootEvidenceSnapshot; +export function snapshotEvidence(handle: VerifiedRootTransition): TransitionEvidenceSnapshot; +export function snapshotEvidence(handle: ReleaseEvidence): ReleaseEvidenceSnapshot; +export function snapshotEvidence(handle: TargetEvidence): TargetEvidenceSnapshot; +export function snapshotEvidence(handle: ArtifactEvidence): ArtifactEvidenceSnapshot; +export function snapshotEvidence(handle: ReceiptEvidence): ReceiptEvidenceSnapshot; +export function snapshotEvidence(handle: TreeEvidence): TreeEvidenceSnapshot; +export function snapshotEvidence(handle: CapabilityEvidence): CapabilityEvidenceSnapshot; +export function snapshotEvidence(handle: EvidenceHandle): EvidenceSnapshot; diff --git a/src/update/signed-supply.mjs b/src/update/signed-supply.mjs index f9e2cd9d536..cb2bcb43f33 100644 --- a/src/update/signed-supply.mjs +++ b/src/update/signed-supply.mjs @@ -90,7 +90,7 @@ export function verifyReleaseEvidence(bytes, envelopeBytes, rootBasis, expectedC if (release.channel !== expectedChannel) throw new Error("Signed release channel mismatch"); const digest = createHash("sha256").update(releaseBytes).digest("hex"); const handle = Object.freeze(Object.create(null)); - RELEASES.set(handle, { release, root: rootBasis, digest }); + RELEASES.set(handle, { release, root: rootBasis, digest, bytes: releaseBytes, envelopeBytes: signatureBytes }); return handle; } @@ -202,7 +202,7 @@ export function verifyExternalMetadataEvidence(targetEvidence, input, basis, now if (proofs.length !== 1) throw new Error("Missing or ambiguous architecture proof"); } const handle = Object.freeze(Object.create(null)); - RECEIPTS.set(handle, { receipt, target: targetEvidence, basis }); + RECEIPTS.set(handle, { receipt, bytes, target: targetEvidence, basis }); return handle; } const receiptState = RECEIPTS.get(data.receiptEvidence); @@ -218,7 +218,7 @@ export function verifyExternalMetadataEvidence(targetEvidence, input, basis, now const tree = parseUpdateDocument(treeBytes, "ocx.update.tree/1"); if (tree.version !== release.version || tree.target !== target.id) throw new Error("Tree target mismatch"); const handle = Object.freeze(Object.create(null)); - TREES.set(handle, { tree, target: targetEvidence, basis, receipt: data.receiptEvidence }); + TREES.set(handle, { tree, bytes: treeBytes, envelopeBytes: signatureBytes, target: targetEvidence, basis, receipt: data.receiptEvidence }); return handle; } const bytes = checkedBytes(data.bytes, target.capabilities, 1048576); @@ -228,6 +228,62 @@ export function verifyExternalMetadataEvidence(targetEvidence, input, basis, now throw new Error("Capability target mismatch"); } const handle = Object.freeze(Object.create(null)); - CAPABILITIES.set(handle, { capability, target: targetEvidence, basis, receipt: data.receiptEvidence }); + CAPABILITIES.set(handle, { capability, bytes, target: targetEvidence, basis, receipt: data.receiptEvidence }); return handle; } + +const evidenceRecord = (kind, fields) => Object.freeze(Object.assign(Object.create(null), { kind }, fields)); +const copyEvidenceBytes = (bytes, cap) => snapshotUpdateBytes(bytes, cap); +const evidenceDigest = (bytes) => createHash("sha256").update(bytes).digest("hex"); + +function evidenceBasis(handle) { + const state = ROOTS.get(handle) || TRANSITIONS.get(handle); + return { basisDigest: state.digest, basisRevision: state.root.revision }; +} + +function targetSnapshotFields(handle) { + const candidate = CANDIDATES.get(handle); + const release = RELEASES.get(candidate.release); + return { releaseDigest: release.digest, targetId: candidate.target.id, + candidateId: deriveCandidateId(release.digest, candidate.target.id), ...evidenceBasis(candidate.root) }; +} + +/** Return detached evidence data only; snapshots confer no update authority. */ +export function snapshotEvidence(handle) { + let state = ROOTS.get(handle); + if (state) return evidenceRecord("root", { rootBytes: copyEvidenceBytes(state.bytes, 65536), + rootDigest: state.digest, rootRevision: state.root.revision, anchorDigest: EMBEDDED_ROOT_SHA256 }); + state = TRANSITIONS.get(handle); + if (state) return evidenceRecord("transition", { rootBytes: copyEvidenceBytes(state.bytes, 65536), + envelopeBytes: copyEvidenceBytes(state.envelopeBytes, 262144), rootDigest: state.digest, + rootRevision: state.root.revision, predecessorDigest: state.predecessorDigest, predecessorRevision: state.predecessorRevision }); + state = RELEASES.get(handle); + if (state) return evidenceRecord("release", { releaseBytes: copyEvidenceBytes(state.bytes, 1048576), + envelopeBytes: copyEvidenceBytes(state.envelopeBytes, 65536), releaseDigest: state.digest, + channel: state.release.channel, ...evidenceBasis(state.root) }); + state = CANDIDATES.get(handle); + if (state) { + const { platform, arch, owner, artifactKind, bundleKind } = state.target; + return evidenceRecord("target", { ...targetSnapshotFields(handle), + selection: Object.freeze({ platform, arch, owner, artifactKind, bundleKind }) }); + } + state = ARTIFACTS.get(handle); + if (state) { + const target = CANDIDATES.get(state.target).target; + return evidenceRecord("artifact", { ...targetSnapshotFields(state.target), artifactDigest: state.digest, + artifactSize: state.size, signatureBox: target.artifact.signatureBox, signerFingerprint: target.artifact.signerFingerprint }); + } + state = RECEIPTS.get(handle); + if (state) return evidenceRecord("receipt", { receiptBytes: copyEvidenceBytes(state.bytes, 1048576), + receiptDigest: evidenceDigest(state.bytes), receiptSize: state.bytes.byteLength, ...targetSnapshotFields(state.target) }); + state = TREES.get(handle); + if (state) return evidenceRecord("tree", { treeBytes: copyEvidenceBytes(state.bytes, 16777216), + envelopeBytes: copyEvidenceBytes(state.envelopeBytes, 65536), treeDigest: evidenceDigest(state.bytes), + treeSize: state.bytes.byteLength, envelopeDigest: evidenceDigest(state.envelopeBytes), envelopeSize: state.envelopeBytes.byteLength, + receiptDigest: evidenceDigest(RECEIPTS.get(state.receipt).bytes), ...targetSnapshotFields(state.target) }); + state = CAPABILITIES.get(handle); + if (state) return evidenceRecord("capability", { capabilityBytes: copyEvidenceBytes(state.bytes, 1048576), + capabilityDigest: evidenceDigest(state.bytes), capabilitySize: state.bytes.byteLength, + receiptDigest: evidenceDigest(RECEIPTS.get(state.receipt).bytes), ...targetSnapshotFields(state.target) }); + throw new Error("Invalid update evidence"); +} diff --git a/structure/runtime.md b/structure/runtime.md index 15844e9c419..09e1e080cf2 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity and a unique comment field. `signed-supply.mjs` snapshots input through `update-bytes.mjs` and returns opaque evidence for the embedded root, dual-threshold root transitions, signed releases, targets, artifact bytes and bound receipt/tree/capability metadata; it does not persist trust or grant install or activation authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity and a unique comment field. `signed-supply.mjs` snapshots input through `update-bytes.mjs` and returns opaque evidence for the embedded root, dual-threshold root transitions, signed releases, targets, artifact bytes and bound receipt/tree/capability metadata. Its read-only evidence snapshots return detached diagnostic data without retaining artifact payloads; they do not persist trust or grant install or activation authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index bfc0ec77900..a255cd7d12c 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -92,7 +92,8 @@ try { const signed = keys.map(key => signEntry(after, key)); const envelope = (entries) => Buffer.from(JSON.stringify({ schema: transitionSchema, signatures: entries })); const now = Date.parse("2027-01-01T00:00:00Z"); - const successor = supply.verifyRootTransition(basis, after, envelope(signed), now); + const transitionEnvelope = envelope(signed); + const successor = supply.verifyRootTransition(basis, after, transitionEnvelope, now); assert.equal(supply.inspectTransition(successor).successorRevision, 2); assert.throws(() => supply.verifyRootTransition(basis, after, envelope(signed.slice(1)), now)); assert.throws(() => supply.verifyRootTransition({}, after, envelope(signed), now)); @@ -143,12 +144,16 @@ try { const assets = [[`${prefix}.tar.gz`, artifact], [`${prefix}.tree.json`, tree], [`${prefix}.tree.json.signatures.json`, treeEnvelope], [`${prefix}.capabilities.json`, capability]].map(([name, bytes]) => ({ name, ...digest(bytes) })).sort((a, b) => a.name < b.name ? -1 : 1); const receipt = Buffer.from(JSON.stringify({ schema: "ocx.update.verification/1", sourceCommit: "c".repeat(40), version: "1.2.3", channel: "latest", workflowRunId: 1, workflowAttempt: 1, versionSources: ["package.json", "desktop/src-tauri/tauri.conf.json", "desktop/src-tauri/Cargo.toml", "desktop/src-tauri/Cargo.lock"].map(path => ({ path, sha256: "d".repeat(64) })), assets, universalProofs: [], architectureProofs: [] })); const release = Buffer.from(JSON.stringify({ schema: "ocx.update.release/1", version: "1.2.3", channel: "latest", sequence: 1, sourceCommit: "c".repeat(40), rolloutNotBefore: "2026-01-01T00:00:00Z", receipt: digest(receipt), releaseNotes: [], targets: [{ id: target, platform: "linux", arch: "x64", owner: "npm", artifactKind: "tree", bundleKind: "tar-gz", assetName: `${prefix}.tar.gz`, artifact: { ...digest(artifact), signatureBox: signEntry(artifact, keys[2]).signatureBox, signerFingerprint: keys[2].key.keyId }, tree: digest(tree), capabilities: digest(capability) }] })); - const releaseEvidence = supply.verifyReleaseEvidence(release, metadataEnvelope(release), successor, "latest", now); + const releaseEnvelope = metadataEnvelope(release); + const releaseEvidence = supply.verifyReleaseEvidence(release, releaseEnvelope, successor, "latest", now); const candidate = supply.selectTargetEvidence(releaseEvidence, { platform: "linux", arch: "x64", owner: "npm", artifactKind: "tree", bundleKind: "tar-gz" }); - assert.ok(Object.isFrozen(supply.verifyArtifactEvidence(candidate, artifact, successor, now))); + const artifactEvidence = supply.verifyArtifactEvidence(candidate, artifact, successor, now); + assert.ok(Object.isFrozen(artifactEvidence)); const receiptEvidence = supply.verifyExternalMetadataEvidence(candidate, { kind: "receipt", bytes: receipt }, successor, now); - assert.ok(Object.isFrozen(supply.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: tree, signatureEnvelopeBytes: treeEnvelope, receiptEvidence }, successor, now))); - assert.ok(Object.isFrozen(supply.verifyExternalMetadataEvidence(candidate, { kind: "capability", bytes: capability, receiptEvidence }, successor, now))); + const treeEvidence = supply.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: tree, signatureEnvelopeBytes: treeEnvelope, receiptEvidence }, successor, now); + const capabilityEvidence = supply.verifyExternalMetadataEvidence(candidate, { kind: "capability", bytes: capability, receiptEvidence }, successor, now); + assert.ok(Object.isFrozen(treeEvidence)); + assert.ok(Object.isFrozen(capabilityEvidence)); assert.throws(() => supply.verifyArtifactEvidence(candidate, Buffer.from("wrong"), successor, now)); assert.throws(() => supply.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: tree, signatureEnvelopeBytes: metadataEnvelope(Buffer.from("wrong")), receiptEvidence }, successor, now)); assert.throws(() => supply.verifyReleaseEvidence(release, metadataEnvelope(release), successor, "preview", now)); @@ -252,6 +257,77 @@ try { assert.throws(() => checkField(schema, { ...value, [field]: "a".repeat(129) })); assert.throws(() => checkField(schema, { ...value, [field]: "é" })); } + + // Evidence snapshots are detached diagnostic data, never authority handles. + const selection = { platform: "linux", arch: "x64", owner: "npm", artifactKind: "tree", bundleKind: "tar-gz" }; + const expected = [ + [basis, "root", ["rootBytes", "rootDigest", "rootRevision", "anchorDigest"]], + [successor, "transition", ["rootBytes", "envelopeBytes", "rootDigest", "rootRevision", "predecessorDigest", "predecessorRevision"]], + [releaseEvidence, "release", ["releaseBytes", "envelopeBytes", "releaseDigest", "channel", "basisDigest", "basisRevision"]], + [candidate, "target", ["releaseDigest", "targetId", "candidateId", "selection", "basisDigest", "basisRevision"]], + [artifactEvidence, "artifact", ["releaseDigest", "targetId", "candidateId", "artifactDigest", "artifactSize", "signatureBox", "signerFingerprint", "basisDigest", "basisRevision"]], + [receiptEvidence, "receipt", ["receiptBytes", "receiptDigest", "receiptSize", "releaseDigest", "targetId", "candidateId", "basisDigest", "basisRevision"]], + [treeEvidence, "tree", ["treeBytes", "envelopeBytes", "treeDigest", "treeSize", "envelopeDigest", "envelopeSize", "receiptDigest", "releaseDigest", "targetId", "candidateId", "basisDigest", "basisRevision"]], + [capabilityEvidence, "capability", ["capabilityBytes", "capabilityDigest", "capabilitySize", "receiptDigest", "releaseDigest", "targetId", "candidateId", "basisDigest", "basisRevision"]], + ]; + const originals = new Map([["root", {rootBytes: before}], ["transition", {rootBytes: after, envelopeBytes: transitionEnvelope}], ["release", {releaseBytes: release, envelopeBytes: releaseEnvelope}], ["receipt", {receiptBytes: receipt}], ["tree", {treeBytes: tree, envelopeBytes: treeEnvelope}], ["capability", {capabilityBytes: capability}]]); + for (const [handle, kind, fields] of expected) { + const first = supply.snapshotEvidence(handle), second = supply.snapshotEvidence(handle); + assert.equal(first.kind, kind); + assert.equal(Object.getPrototypeOf(first), null); + assert.ok(Object.isFrozen(first)); + assert.deepEqual(Object.keys(first).sort(), ["kind", ...fields].sort()); + for (const [field, value] of Object.entries(originals.get(kind) ?? {})) { + assert.deepEqual(Buffer.from(first[field]), value); + assert.notEqual(first[field].buffer, second[field].buffer); + first[field].fill(0); + assert.deepEqual(Buffer.from(supply.snapshotEvidence(handle)[field]), value); + } + if (kind !== "root" && kind !== "transition") { + assert.equal(first.basisDigest, digest(after).sha256); + assert.equal(first.basisRevision, 2); + } + if (["target", "artifact", "receipt", "tree", "capability"].includes(kind)) { + assert.equal(first.targetId, target); + assert.equal(first.candidateId, candidate.candidateId); + } + } + const targetSnapshot = supply.snapshotEvidence(candidate); + assert.deepEqual({ ...targetSnapshot.selection }, selection); + assert.ok(Object.isFrozen(targetSnapshot.selection)); + assert.equal(supply.snapshotEvidence(basis).anchorDigest, digest(before).sha256); + assert.equal(supply.snapshotEvidence(successor).predecessorDigest, digest(before).sha256); + assert.equal(supply.snapshotEvidence(treeEvidence).envelopeDigest, digest(treeEnvelope).sha256); + assert.equal(supply.snapshotEvidence(receiptEvidence).receiptDigest, digest(receipt).sha256); + assert.equal(supply.snapshotEvidence(artifactEvidence).artifactDigest, digest(artifact).sha256); + assert.equal("artifactBytes" in supply.snapshotEvidence(artifactEvidence), false); + assert.throws(() => supply.snapshotEvidence({})); + assert.throws(() => supply.snapshotEvidence({ ...candidate })); + assert.throws(() => supply.snapshotEvidence(targetSnapshot)); + assert.throws(() => supply.verifyArtifactEvidence(targetSnapshot, artifact, successor, now)); + assert.throws(() => supply.verifyArtifactEvidence(receiptEvidence, artifact, successor, now)); + const sameBasis = supply.bootstrapEmbeddedRoot(before, now); + const sameSuccessor = supply.verifyRootTransition(sameBasis, after, transitionEnvelope, now); + assert.equal(supply.snapshotEvidence(sameSuccessor).rootDigest, supply.snapshotEvidence(successor).rootDigest); + assert.throws(() => supply.verifyArtifactEvidence(candidate, artifact, sameSuccessor, now)); + const sameRelease = supply.verifyReleaseEvidence(release, releaseEnvelope, successor, "latest", now); + assert.equal(supply.snapshotEvidence(sameRelease).releaseDigest, supply.snapshotEvidence(releaseEvidence).releaseDigest); + const sameTarget = supply.selectTargetEvidence(sameRelease, selection); + assert.equal(sameTarget.candidateId, candidate.candidateId); + const sameReceipt = supply.verifyExternalMetadataEvidence(candidate, {kind: "receipt", bytes: receipt}, successor, now); + assert.ok(supply.verifyExternalMetadataEvidence(candidate, {kind: "tree", bytes: tree, signatureEnvelopeBytes: treeEnvelope, receiptEvidence: sameReceipt}, successor, now)); + assert.throws(() => supply.verifyExternalMetadataEvidence(sameTarget, {kind: "tree", bytes: tree, signatureEnvelopeBytes: treeEnvelope, receiptEvidence}, successor, now)); + const production = await import("../../src/update/signed-supply.mjs"); + assert.throws(() => production.snapshotEvidence(candidate)); + assert.throws(() => supply.snapshotEvidence(production.bootstrapEmbeddedRoot(readFileSync(new URL("../../src/update/trust-root.json", import.meta.url)), now))); + assert.ok(supply.snapshotEvidence(successor)); + assert.throws(() => supply.verifyReleaseEvidence(release, releaseEnvelope, successor, "latest", rootExpiry)); + const saved = expected.map(([handle]) => supply.snapshotEvidence(handle)); + for (const bytes of [before, after, transitionEnvelope, release, releaseEnvelope, receipt, tree, treeEnvelope, capability, artifact]) bytes.fill(0); + expected.forEach(([handle], index) => { + const again = supply.snapshotEvidence(handle); + for (const field of Object.keys(again)) if (again[field] instanceof Uint8Array) assert.deepEqual(again[field], saved[index][field]); + }); } finally { rmSync(dir, { recursive: true, force: true }); } diff --git a/tests/update/update-external-metadata.test.ts b/tests/update/update-external-metadata.test.ts index 13e3bd762c9..b3445afb457 100644 --- a/tests/update/update-external-metadata.test.ts +++ b/tests/update/update-external-metadata.test.ts @@ -57,6 +57,19 @@ describe("external signed update metadata", () => { expect(Object.isFrozen(receiptEvidence)).toBe(true); expect(Object.isFrozen(treeEvidence)).toBe(true); expect(Object.isFrozen(capabilityEvidence)).toBe(true); + const artifactEvidence = fixture.verifyArtifactEvidence(candidate, artifact, basis, now); + expect(fixture.snapshotEvidence(artifactEvidence).kind).toBe("artifact"); + expect(fixture.snapshotEvidence(candidate).candidateId).toBe(candidate.candidateId); + const receiptSnapshot = fixture.snapshotEvidence(receiptEvidence); + expect(Buffer.from(receiptSnapshot.receiptBytes)).toEqual(receipt); + receiptSnapshot.receiptBytes.fill(0); + expect(Buffer.from(fixture.snapshotEvidence(receiptEvidence).receiptBytes)).toEqual(receipt); + const alternateReceipt = fixture.verifyExternalMetadataEvidence(candidate, { kind: "receipt", bytes: receipt }, basis, now); + expect(() => fixture.verifyExternalMetadataEvidence(candidate, { kind: "tree", bytes: tree, signatureEnvelopeBytes: treeEnvelope, receiptEvidence: alternateReceipt }, basis, now)).not.toThrow(); + const equalTarget = fixture.selectTargetEvidence(releaseEvidence, selection); + expect(equalTarget.candidateId).toBe(candidate.candidateId); + expect(() => fixture.verifyExternalMetadataEvidence(equalTarget, { kind: "tree", bytes: tree, signatureEnvelopeBytes: treeEnvelope, receiptEvidence }, basis, now)).toThrow(/Receipt evidence mismatch/); + expect(() => fixture.snapshotEvidence(receiptSnapshot)).toThrow(/Invalid update evidence/); const longVersion = `1.2.3+${"a".repeat(58)}`; const longTarget = "linux-x64-standalone-guardian"; const longAsset = `ocx-update-${longVersion}-latest-${longTarget}`; diff --git a/tests/update/update-signed-supply.test.ts b/tests/update/update-signed-supply.test.ts index aba2c2691e7..5447039bc3c 100644 --- a/tests/update/update-signed-supply.test.ts +++ b/tests/update/update-signed-supply.test.ts @@ -5,7 +5,7 @@ import { tmpdir } from "node:os"; import { join } from "node:path"; import { pathToFileURL } from "node:url"; import { repoPath } from "../helpers/repo-root"; -import { bootstrapEmbeddedRoot, selectTargetEvidence, verifyArtifactEvidence, verifyReleaseEvidence, verifyRootTransition } from "../../src/update/signed-supply.mjs"; +import { bootstrapEmbeddedRoot, selectTargetEvidence, snapshotEvidence, verifyArtifactEvidence, verifyReleaseEvidence, verifyRootTransition } from "../../src/update/signed-supply.mjs"; import { deriveCandidateId } from "../../src/update/update-candidate-id.mjs"; describe("embedded update trust root", () => { @@ -16,6 +16,12 @@ describe("embedded update trust root", () => { const trusted = bootstrapEmbeddedRoot(root, expiry - 1); expect(Object.isFrozen(trusted)).toBe(true); expect(Object.keys(trusted)).toEqual([]); + const diagnostic = snapshotEvidence(trusted); + expect(diagnostic.kind).toBe("root"); + if (false) { + // @ts-expect-error A diagnostic snapshot is not an opaque evidence handle. + snapshotEvidence(diagnostic); + } expect(() => bootstrapEmbeddedRoot(root, expiry)).toThrow(); expect(() => bootstrapEmbeddedRoot(root, expiry + 1)).toThrow(); }); From 19f8b8aa1e043134c771b3c9b119a68d898f34fd Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 19:17:36 +0900 Subject: [PATCH 39/42] Verify all evidence snapshot bindings --- tests/helpers/update-node-harness.mjs | 32 +++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index a255cd7d12c..823d4b6403a 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -286,6 +286,7 @@ try { if (kind !== "root" && kind !== "transition") { assert.equal(first.basisDigest, digest(after).sha256); assert.equal(first.basisRevision, 2); + assert.equal(first.releaseDigest, digest(release).sha256); } if (["target", "artifact", "receipt", "tree", "capability"].includes(kind)) { assert.equal(first.targetId, target); @@ -295,11 +296,30 @@ try { const targetSnapshot = supply.snapshotEvidence(candidate); assert.deepEqual({ ...targetSnapshot.selection }, selection); assert.ok(Object.isFrozen(targetSnapshot.selection)); + assert.throws(() => { targetSnapshot.selection.arch = "arm64"; }, TypeError); + assert.equal(supply.snapshotEvidence(candidate).selection.arch, "x64"); + assert.equal(supply.snapshotEvidence(basis).rootDigest, digest(before).sha256); + assert.equal(supply.snapshotEvidence(basis).rootRevision, 1); assert.equal(supply.snapshotEvidence(basis).anchorDigest, digest(before).sha256); + assert.equal(supply.snapshotEvidence(successor).rootDigest, digest(after).sha256); + assert.equal(supply.snapshotEvidence(successor).rootRevision, 2); assert.equal(supply.snapshotEvidence(successor).predecessorDigest, digest(before).sha256); + assert.equal(supply.snapshotEvidence(successor).predecessorRevision, 1); + assert.equal(supply.snapshotEvidence(releaseEvidence).channel, "latest"); + assert.equal(supply.snapshotEvidence(treeEvidence).treeDigest, digest(tree).sha256); + assert.equal(supply.snapshotEvidence(treeEvidence).treeSize, tree.length); assert.equal(supply.snapshotEvidence(treeEvidence).envelopeDigest, digest(treeEnvelope).sha256); + assert.equal(supply.snapshotEvidence(treeEvidence).envelopeSize, treeEnvelope.length); + assert.equal(supply.snapshotEvidence(treeEvidence).receiptDigest, digest(receipt).sha256); assert.equal(supply.snapshotEvidence(receiptEvidence).receiptDigest, digest(receipt).sha256); + assert.equal(supply.snapshotEvidence(receiptEvidence).receiptSize, receipt.length); + assert.equal(supply.snapshotEvidence(capabilityEvidence).capabilityDigest, digest(capability).sha256); + assert.equal(supply.snapshotEvidence(capabilityEvidence).capabilitySize, capability.length); + assert.equal(supply.snapshotEvidence(capabilityEvidence).receiptDigest, digest(receipt).sha256); assert.equal(supply.snapshotEvidence(artifactEvidence).artifactDigest, digest(artifact).sha256); + assert.equal(supply.snapshotEvidence(artifactEvidence).artifactSize, artifact.length); + assert.equal(supply.snapshotEvidence(artifactEvidence).signatureBox, JSON.parse(release.toString()).targets[0].artifact.signatureBox); + assert.equal(supply.snapshotEvidence(artifactEvidence).signerFingerprint, keys[2].key.keyId); assert.equal("artifactBytes" in supply.snapshotEvidence(artifactEvidence), false); assert.throws(() => supply.snapshotEvidence({})); assert.throws(() => supply.snapshotEvidence({ ...candidate })); @@ -317,17 +337,29 @@ try { const sameReceipt = supply.verifyExternalMetadataEvidence(candidate, {kind: "receipt", bytes: receipt}, successor, now); assert.ok(supply.verifyExternalMetadataEvidence(candidate, {kind: "tree", bytes: tree, signatureEnvelopeBytes: treeEnvelope, receiptEvidence: sameReceipt}, successor, now)); assert.throws(() => supply.verifyExternalMetadataEvidence(sameTarget, {kind: "tree", bytes: tree, signatureEnvelopeBytes: treeEnvelope, receiptEvidence}, successor, now)); + const otherBasisRelease = supply.verifyReleaseEvidence(release, releaseEnvelope, sameSuccessor, "latest", now); + const otherBasisTarget = supply.selectTargetEvidence(otherBasisRelease, selection); + const otherBasisReceipt = supply.verifyExternalMetadataEvidence(otherBasisTarget, {kind: "receipt", bytes: receipt}, sameSuccessor, now); + assert.equal(supply.snapshotEvidence(otherBasisReceipt).receiptDigest, supply.snapshotEvidence(receiptEvidence).receiptDigest); + assert.throws(() => supply.verifyExternalMetadataEvidence(candidate, {kind: "tree", bytes: tree, signatureEnvelopeBytes: treeEnvelope, receiptEvidence: otherBasisReceipt}, successor, now)); const production = await import("../../src/update/signed-supply.mjs"); assert.throws(() => production.snapshotEvidence(candidate)); assert.throws(() => supply.snapshotEvidence(production.bootstrapEmbeddedRoot(readFileSync(new URL("../../src/update/trust-root.json", import.meta.url)), now))); assert.ok(supply.snapshotEvidence(successor)); assert.throws(() => supply.verifyReleaseEvidence(release, releaseEnvelope, successor, "latest", rootExpiry)); const saved = expected.map(([handle]) => supply.snapshotEvidence(handle)); + const artifactCopy = Buffer.from(artifact); for (const bytes of [before, after, transitionEnvelope, release, releaseEnvelope, receipt, tree, treeEnvelope, capability, artifact]) bytes.fill(0); expected.forEach(([handle], index) => { const again = supply.snapshotEvidence(handle); for (const field of Object.keys(again)) if (again[field] instanceof Uint8Array) assert.deepEqual(again[field], saved[index][field]); }); + assert.ok(supply.verifyRootTransition(basis, saved[1].rootBytes, saved[1].envelopeBytes, now)); + assert.ok(supply.verifyReleaseEvidence(saved[2].releaseBytes, saved[2].envelopeBytes, successor, "latest", now)); + assert.ok(supply.verifyArtifactEvidence(candidate, artifactCopy, successor, now)); + assert.ok(supply.verifyExternalMetadataEvidence(candidate, {kind: "receipt", bytes: saved[5].receiptBytes}, successor, now)); + assert.ok(supply.verifyExternalMetadataEvidence(candidate, {kind: "tree", bytes: saved[6].treeBytes, signatureEnvelopeBytes: saved[6].envelopeBytes, receiptEvidence}, successor, now)); + assert.ok(supply.verifyExternalMetadataEvidence(candidate, {kind: "capability", bytes: saved[7].capabilityBytes, receiptEvidence}, successor, now)); } finally { rmSync(dir, { recursive: true, force: true }); } From 5734a3d67d7ecd1a7a7d6a9b3f39553fa67a7638 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 19:47:42 +0900 Subject: [PATCH 40/42] Add unverified checkpoint payload codec --- scripts/test-layout/layout.json | 2 +- src/update/update-checkpoint-codec.d.mts | 33 +++ src/update/update-checkpoint-codec.mjs | 216 ++++++++++++++++++ structure/runtime.md | 2 +- tests/fixtures/test-layout-expected.json | 2 +- tests/fixtures/update-checkpoint/corpus.json | 43 ++++ .../update-checkpoint/history-limits.json | 1 + tests/fixtures/update-checkpoint/initial.bin | Bin 0 -> 1369 bytes tests/helpers/update-node-harness.mjs | 30 +++ tests/update/update-checkpoint-codec.test.ts | 92 ++++++++ 10 files changed, 418 insertions(+), 3 deletions(-) create mode 100644 src/update/update-checkpoint-codec.d.mts create mode 100644 src/update/update-checkpoint-codec.mjs create mode 100644 tests/fixtures/update-checkpoint/corpus.json create mode 100644 tests/fixtures/update-checkpoint/history-limits.json create mode 100644 tests/fixtures/update-checkpoint/initial.bin create mode 100644 tests/update/update-checkpoint-codec.test.ts diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json index 0447ee21143..b17f4359f13 100644 --- a/scripts/test-layout/layout.json +++ b/scripts/test-layout/layout.json @@ -1837,7 +1837,7 @@ "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", "update-async-routes.test.ts": "server", - "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-external-metadata.test.ts": "update", "update-minisign.test.ts": "update", "update-root-snapshot.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", + "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-checkpoint-codec.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-external-metadata.test.ts": "update", "update-minisign.test.ts": "update", "update-root-snapshot.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", "update-standalone.test.ts": "update", "update-worker-launch.test.ts": "update", "update-notify.test.ts": "update", "update-npm-cache-preflight.test.ts": "update", diff --git a/src/update/update-checkpoint-codec.d.mts b/src/update/update-checkpoint-codec.d.mts new file mode 100644 index 00000000000..2cedaa92349 --- /dev/null +++ b/src/update/update-checkpoint-codec.d.mts @@ -0,0 +1,33 @@ +/** Unauthenticated checkpoint data. These types do not grant update authority. */ +export type CheckpointChannel = "latest" | "preview" | "nightly"; +export interface CheckpointHistoryEntry { + previousRevision: number; + previousDigest: Uint8Array; + nextRevision: number; + nextDigest: Uint8Array; + acceptedAtMs: number; + rootBytes: Uint8Array; + envelopeBytes: Uint8Array; +} +export interface CheckpointFloor { sequence: number; releaseDigest: Uint8Array; version: string } +export interface CheckpointObservation { candidateDigest: Uint8Array; firstSeenMs: number } +export interface CheckpointPayload { + namespaceDigest: Uint8Array; + principalDigest: Uint8Array; + ownerKind: "desktop" | "npm" | "pnpm" | "bun" | "standalone" | "service"; + consentGeneration: number; + identityKind: "posix" | "windows"; + identityBytes: Uint8Array; + generation: number; + rootRevision: number; + rootDigest: Uint8Array; + rootBytes: Uint8Array; + history: CheckpointHistoryEntry[]; + channels: Record; + firstSeen: Record; + clockHighWaterMs: number; + securityEpoch: number; +} +export function encodeCheckpointPayload(record: CheckpointPayload): Uint8Array; +export function decodeCheckpointPayload(bytes: Uint8Array): CheckpointPayload; +export function checkpointPayloadDigest(bytes: Uint8Array): string; diff --git a/src/update/update-checkpoint-codec.mjs b/src/update/update-checkpoint-codec.mjs new file mode 100644 index 00000000000..028353d3ec0 --- /dev/null +++ b/src/update/update-checkpoint-codec.mjs @@ -0,0 +1,216 @@ +// Canonical checkpoint data only. This module never authenticates or grants update authority. +import { createHash } from "node:crypto"; +import { snapshotUpdateBytes } from "./update-bytes.mjs"; +import { parseRootTransitionEnvelope, parseUpdateDocument } from "./update-contracts.mjs"; +import { sameSignedVersion } from "./update-signed-version.mjs"; + +const PREFIX = Buffer.from("ocx.update.checkpoint/1\0", "ascii"); +const MAX_PAYLOAD = 64 * 1024 * 1024; +const MAX_ROOT = 65536, MAX_ENVELOPE = 262144; +const CHANNELS = ["latest", "preview", "nightly"]; +const OWNERS = ["desktop", "npm", "pnpm", "bun", "standalone", "service"]; +const KEYS = ["namespaceDigest", "principalDigest", "ownerKind", "consentGeneration", "identityKind", "identityBytes", "generation", "rootRevision", "rootDigest", "rootBytes", "history", "channels", "firstSeen", "clockHighWaterMs", "securityEpoch"]; +const HISTORY_KEYS = ["previousRevision", "previousDigest", "nextRevision", "nextDigest", "acceptedAtMs", "rootBytes", "envelopeBytes"]; +const FLOOR_KEYS = ["sequence", "releaseDigest", "version"]; +const SEEN_KEYS = ["candidateDigest", "firstSeenMs"]; +const fail = () => { throw new Error("Invalid checkpoint payload"); }; + +function record(value, keys) { + if (value === null || typeof value !== "object" || Array.isArray(value)) fail(); + const descriptors = Object.getOwnPropertyDescriptors(value); + const names = Reflect.ownKeys(descriptors); + if (names.length !== keys.length || names.some((key) => typeof key !== "string" || !keys.includes(key))) fail(); + const result = Object.create(null); + for (const key of keys) { + const descriptor = descriptors[key]; + if (!descriptor || !("value" in descriptor)) fail(); + result[key] = descriptor.value; + } + return result; +} +function list(value, max) { + if (!Array.isArray(value)) fail(); + const length = Object.getOwnPropertyDescriptor(value, "length")?.value; + if (!Number.isSafeInteger(length) || length < 0 || length > max) fail(); + const descriptors = Object.getOwnPropertyDescriptors(value); + if (descriptors.length?.value !== length || Reflect.ownKeys(descriptors).length !== length + 1) fail(); + const result = []; + for (let i = 0; i < length; i++) { + const descriptor = descriptors[String(i)]; + if (!descriptor || !("value" in descriptor)) fail(); + result.push(descriptor.value); + } + return result; +} +function number(value, positive = false) { + if (!Number.isSafeInteger(value) || value < (positive ? 1 : 0)) fail(); + return value; +} +function bytes(value, max, exact = false) { + const copy = snapshotUpdateBytes(value, max); + if (copy.length === 0 || (exact && copy.length !== max)) fail(); + return Buffer.from(copy); +} +const digest = (value) => bytes(value, 32, true); +const hash = (value) => createHash("sha256").update(value).digest(); +function root(bytesValue, revision, expectedDigest) { + if (!hash(bytesValue).equals(expectedDigest)) fail(); + const parsed = parseUpdateDocument(bytesValue, "ocx.update.root/1"); + if (parsed.revision !== revision) fail(); +} +function capture(input) { + const data = record(input, KEYS); + const owner = OWNERS.indexOf(data.ownerKind); + if (owner < 0 || (data.identityKind !== "posix" && data.identityKind !== "windows")) fail(); + const identitySize = data.identityKind === "posix" ? 16 : 24; + const result = { + namespaceDigest: digest(data.namespaceDigest), principalDigest: digest(data.principalDigest), + ownerKind: data.ownerKind, consentGeneration: number(data.consentGeneration), + identityKind: data.identityKind, identityBytes: bytes(data.identityBytes, identitySize, true), + generation: number(data.generation, true), rootRevision: number(data.rootRevision, true), + rootDigest: digest(data.rootDigest), rootBytes: bytes(data.rootBytes, MAX_ROOT), + history: [], channels: {}, firstSeen: {}, clockHighWaterMs: number(data.clockHighWaterMs), + securityEpoch: number(data.securityEpoch, true), + }; + root(result.rootBytes, result.rootRevision, result.rootDigest); + let previous = null; + for (const item of list(data.history, 128)) { + const h = record(item, HISTORY_KEYS); + const entry = { + previousRevision: number(h.previousRevision, true), previousDigest: digest(h.previousDigest), + nextRevision: number(h.nextRevision, true), nextDigest: digest(h.nextDigest), + acceptedAtMs: number(h.acceptedAtMs), rootBytes: bytes(h.rootBytes, MAX_ROOT), + envelopeBytes: bytes(h.envelopeBytes, MAX_ENVELOPE), + }; + if (entry.nextRevision <= entry.previousRevision || (previous && (entry.previousRevision !== previous.nextRevision || !entry.previousDigest.equals(previous.nextDigest) || entry.acceptedAtMs < previous.acceptedAtMs))) fail(); + root(entry.rootBytes, entry.nextRevision, entry.nextDigest); + parseRootTransitionEnvelope(entry.envelopeBytes); + result.history.push(entry); + previous = entry; + } + if (previous && (previous.nextRevision !== result.rootRevision || !previous.nextDigest.equals(result.rootDigest))) fail(); + const floors = record(data.channels, CHANNELS), observations = record(data.firstSeen, CHANNELS); + for (const channel of CHANNELS) { + const floor = floors[channel]; + if (floor === null) result.channels[channel] = null; + else { + const f = record(floor, FLOOR_KEYS); + if (typeof f.version !== "string" || !sameSignedVersion(f.version, f.version)) fail(); + result.channels[channel] = { sequence: number(f.sequence, true), releaseDigest: digest(f.releaseDigest), version: f.version }; + } + const entries = []; + for (const item of list(observations[channel], 4096)) { + const s = record(item, SEEN_KEYS); + const entry = { candidateDigest: digest(s.candidateDigest), firstSeenMs: number(s.firstSeenMs) }; + if (entry.firstSeenMs > result.clockHighWaterMs || (entries.length && Buffer.compare(entries[entries.length - 1].candidateDigest, entry.candidateDigest) >= 0)) fail(); + entries.push(entry); + } + result.firstSeen[channel] = entries; + } + return result; +} +const u8 = (value) => Buffer.from([value]); +function u16(value) { const out = Buffer.allocUnsafe(2); out.writeUInt16BE(value); return out; } +function u32(value) { const out = Buffer.allocUnsafe(4); out.writeUInt32BE(value); return out; } +function u64(value) { const out = Buffer.allocUnsafe(8); out.writeBigUInt64BE(BigInt(value)); return out; } +const lengthOf = (chunks) => chunks.reduce((total, chunk) => total + chunk.length, 0); +function sized(chunks) { return [u32(lengthOf(chunks)), ...chunks]; } +function encodeCaptured(data) { + const fields = [ + [data.namespaceDigest, data.principalDigest], + [u8(OWNERS.indexOf(data.ownerKind) + 1), u64(data.consentGeneration), u8(data.identityKind === "posix" ? 1 : 2), u16(data.identityBytes.length), data.identityBytes], + [u64(data.generation), u64(data.rootRevision), data.rootDigest], + [data.rootBytes], + [u32(data.history.length)], [], [], [u64(data.clockHighWaterMs), u64(data.securityEpoch)], + ]; + for (const item of data.history) { + fields[4].push(...sized([u64(item.previousRevision), item.previousDigest, u64(item.nextRevision), item.nextDigest, u64(item.acceptedAtMs), ...sized([item.rootBytes]), ...sized([item.envelopeBytes])])); + } + for (const channel of CHANNELS) { + const floor = data.channels[channel]; + if (!floor) fields[5].push(u8(0)); + else { const version = Buffer.from(floor.version, "ascii"); fields[5].push(u8(1), u64(floor.sequence), floor.releaseDigest, u8(version.length), version); } + const seen = data.firstSeen[channel]; + fields[6].push(u32(seen.length)); + for (const entry of seen) fields[6].push(entry.candidateDigest, u64(entry.firstSeenMs)); + } + const chunks = [PREFIX]; + for (let i = 0; i < fields.length; i++) chunks.push(u16(i + 1), ...sized(fields[i])); + const length = lengthOf(chunks); + if (length > MAX_PAYLOAD) fail(); + return new Uint8Array(Buffer.concat(chunks, length)); +} + +class Reader { + constructor(bytesValue) { this.data = bytesValue; this.offset = 0; } + take(length) { + if (!Number.isSafeInteger(length) || length < 0 || length > this.data.length - this.offset) fail(); + const value = this.data.subarray(this.offset, this.offset + length); this.offset += length; return value; + } + byte() { return this.take(1)[0]; } + short() { return this.take(2).readUInt16BE(); } + uint() { return this.take(4).readUInt32BE(); } + long() { const value = this.take(8).readBigUInt64BE(); if (value > BigInt(Number.MAX_SAFE_INTEGER)) fail(); return Number(value); } + end() { if (this.offset !== this.data.length) fail(); } + blob(max) { const length = this.uint(); if (length < 1 || length > max) fail(); return new Uint8Array(this.take(length)); } +} +function decodeSnapshot(snapshot) { + const input = new Reader(Buffer.from(snapshot)); + if (!input.take(PREFIX.length).equals(PREFIX)) fail(); + const fields = []; + for (let tag = 1; tag <= 8; tag++) { + if (input.short() !== tag) fail(); + fields.push(new Reader(input.take(input.uint()))); + } + input.end(); + const [a,b,c,d,e,f,g,h] = fields; + const namespaceDigest = new Uint8Array(a.take(32)), principalDigest = new Uint8Array(a.take(32)); a.end(); + const owner = b.byte(), consentGeneration = b.long(), identity = b.byte(), identityLength = b.short(); + if (!OWNERS[owner - 1] || ![1, 2].includes(identity) || identityLength !== (identity === 1 ? 16 : 24)) fail(); + const identityBytes = new Uint8Array(b.take(identityLength)); b.end(); + const generation = c.long(), rootRevision = c.long(), rootDigest = new Uint8Array(c.take(32)); c.end(); + if (d.data.length < 1 || d.data.length > MAX_ROOT) fail(); + const rootBytes = new Uint8Array(d.take(d.data.length)); d.end(); + const count = e.uint(); if (count > 128) fail(); + const history = []; + for (let i = 0; i < count; i++) { + const size = e.uint(); if (size > 88 + 4 + MAX_ROOT + 4 + MAX_ENVELOPE) fail(); + const item = new Reader(e.take(size)); + history.push({ previousRevision: item.long(), previousDigest: new Uint8Array(item.take(32)), nextRevision: item.long(), nextDigest: new Uint8Array(item.take(32)), acceptedAtMs: item.long(), rootBytes: item.blob(MAX_ROOT), envelopeBytes: item.blob(MAX_ENVELOPE) }); + item.end(); + } + e.end(); + const channels = {}, firstSeen = {}; + for (const channel of CHANNELS) { + const present = f.byte(); if (present > 1) fail(); + if (!present) channels[channel] = null; + else { + const sequence = f.long(), releaseDigest = new Uint8Array(f.take(32)), size = f.byte(); + if (!size || size > 64) fail(); + const version = f.take(size); if (version.some((byte) => byte > 127)) fail(); + channels[channel] = { sequence, releaseDigest, version: version.toString("ascii") }; + } + const seenCount = g.uint(); if (seenCount > 4096) fail(); + const seen = []; + for (let i = 0; i < seenCount; i++) seen.push({ candidateDigest: new Uint8Array(g.take(32)), firstSeenMs: g.long() }); + firstSeen[channel] = seen; + } + f.end(); g.end(); + const clockHighWaterMs = h.long(), securityEpoch = h.long(); h.end(); + const value = { namespaceDigest, principalDigest, ownerKind: OWNERS[owner - 1], consentGeneration, identityKind: identity === 1 ? "posix" : "windows", identityBytes, generation, rootRevision, rootDigest, rootBytes, history, channels, firstSeen, clockHighWaterMs, securityEpoch }; + // Re-encoding validates all semantic rules and the canonical representation. + const canonical = encodeCaptured(capture(value)); + if (!Buffer.from(canonical).equals(Buffer.from(snapshot))) fail(); + return value; +} + +/** Structurally encode unverified checkpoint data; no trust or installation authority is issued. */ +export function encodeCheckpointPayload(input) { return encodeCaptured(capture(input)); } +/** Decode and validate a private snapshot; returned buffers are detached from the input. */ +export function decodeCheckpointPayload(input) { return decodeSnapshot(snapshotUpdateBytes(input, MAX_PAYLOAD)); } +/** Hash exactly the private snapshot whose canonical structure was validated. */ +export function checkpointPayloadDigest(input) { + const snapshot = snapshotUpdateBytes(input, MAX_PAYLOAD); + decodeSnapshot(snapshot); + return hash(snapshot).toString("hex"); +} diff --git a/structure/runtime.md b/structure/runtime.md index 09e1e080cf2..6f79dc0a42f 100644 --- a/structure/runtime.md +++ b/structure/runtime.md @@ -144,7 +144,7 @@ there. Feature code is grouped by responsibility: | Codex integration | `src/codex/`, `src/combos/`, `src/providers/`, `src/oauth/`. Browser/device grants share unchanged credential helpers in the type-only-dependent `src/oauth/chatgpt-shared.ts` leaf; `src/oauth/chatgpt.ts` retains their exports and the bounded token-request logic. Management dispatch imports `src/codex/auth-api/routes.ts` directly, without an auth-api handler re-export; OAuth cache invalidation imports `src/codex/catalog/routed-gather.ts` directly. | | Surfaces | `src/server/`, `src/cli/`, `src/tray/`, `src/github/` | | Evidence and contracts | `src/compatibility/`, `src/lab/` | -| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity and a unique comment field. `signed-supply.mjs` snapshots input through `update-bytes.mjs` and returns opaque evidence for the embedded root, dual-threshold root transitions, signed releases, targets, artifact bytes and bound receipt/tree/capability metadata. Its read-only evidence snapshots return detached diagnostic data without retaining artifact payloads; they do not persist trust or grant install or activation authority), `src/generated/` | +| Support | `src/lib/`, `src/storage/` (Worker policy fixtures synchronize after loading the initial policy; `src/storage/policy.ts` bounds the test barrier at 10 seconds), `src/usage/`, `src/update/` (compiled executables report standalone update guidance rather than a source checkout; [package refresh](ops/service-and-sidecars.md#package-cache-refresh); `desktop-badge.ts` holds bounded process-local display state, never install authority; `minisign.mjs` and `update-signature-threshold.mjs` check supplied offline signatures and keys, `update-candidate-id.mjs` derives lookup identifiers, `update-bounded-json.mjs` parses bounded JSON, `update-contracts.mjs` checks unverified wire schemas, and `update-signed-version.mjs` compares full version identity and a unique comment field. `signed-supply.mjs` snapshots input through `update-bytes.mjs` and returns opaque evidence for the embedded root, dual-threshold root transitions, signed releases, targets, artifact bytes and bound receipt/tree/capability metadata. Its read-only evidence snapshots return detached diagnostic data without retaining artifact payloads; they do not persist trust or grant install or activation authority. `update-checkpoint-codec.mjs` encodes, validates and hashes canonical checkpoint data without authenticating an owner or granting authority), `src/generated/` | `src/generated/` is committed build output, not hand-edited; `scripts/generate-model-metadata.ts` derives `kimi-responses` → Moonshot metadata from the registry's `jawcodeBundle` while keeping its provider row distinct. The generated vendor priority supplies bundled fallback for the Azure modality/limit lookup described in [the shared catalog contract](catalog.md#shared-catalog); discovery can refresh public Azure metadata independently of a release, without generation-time network fetches or static-policy changes. Snapshot refreshes preserve the separate public OpenAI API and native Codex bundles. diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json index fd8a28e5fca..f8dd802d72b 100644 --- a/tests/fixtures/test-layout-expected.json +++ b/tests/fixtures/test-layout-expected.json @@ -1442,7 +1442,7 @@ "types-barrel-identity.test.ts": "config", "ultrafast-tier-honesty.test.ts": "codex-integration", "configured-ultrafast-picker.test.ts": "codex-integration", "ultrafast-live-catalog.test.ts": "codex-integration", "umans-provider.test.ts": "providers", "uninstall.test.ts": "cli", - "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-external-metadata.test.ts": "update", "update-minisign.test.ts": "update", "update-root-snapshot.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", + "update-async-routes.test.ts": "server", "update-badge.test.ts": "update", "update-bounded-json.test.ts": "update", "update-checkpoint-codec.test.ts": "update", "update-contracts.test.ts": "update", "update-candidate-id.test.ts": "update", "update-external-metadata.test.ts": "update", "update-minisign.test.ts": "update", "update-root-snapshot.test.ts": "update", "update-signed-supply.test.ts": "update", "update-signed-version.test.ts": "update", "update-trust-root.test.ts": "update", "update-bun-ownership-lease.test.ts": "update", "update-desktop-badge.test.ts": "update", "update-desktop-owner.test.ts": "update", "update-supervised-recovery.test.ts": "update", "update-job.test.ts": "update", "update-recovery-host-free.test.ts": "update", "update-job-supervised-restart.test.ts": "update", diff --git a/tests/fixtures/update-checkpoint/corpus.json b/tests/fixtures/update-checkpoint/corpus.json new file mode 100644 index 00000000000..33af5c108fb --- /dev/null +++ b/tests/fixtures/update-checkpoint/corpus.json @@ -0,0 +1,43 @@ +{ + "valid": { + "empty": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQ==", + "history": "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", + "windows-profile": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAJAEAAAAAAAAAAQIAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQADAAAAMAAAAAAAAAABAAAAAAAAAAEfQ+aOmNkQhk0ukqYrvgrW+dPA4L8w6m0xQshRvUvGCQAEAAAEYnsKICAic2NoZW1hIjogIm9jeC51cGRhdGUucm9vdC8xIiwKICAicmV2aXNpb24iOiAxLAogICJleHBpcmVzQXQiOiAiMjAyOC0xMS0wN1QwMDowMDowMFoiLAogICJyb290S2V5cyI6IFsKICAgIHsKICAgICAgImtleUlkIjogImVhZTRjMDE4MGU4Y2EzOWE4NDRiM2MwZTFlYzI4ODQyMjYxZTg1NjI4ZDZkZWU3N2NlZmY1ZGQwODE4NTM3OTkiLAogICAgICAiYWxnb3JpdGhtIjogIm1pbmlzaWduLWVkMjU1MTktYmxha2UyYjUxMi8xIiwKICAgICAgInB1YmxpY0tleSI6ICJkVzUwY25WemRHVmtJR052YlcxbGJuUTZJRzFwYm1semFXZHVJSEIxWW14cFl5QnJaWGs2SUVGRE56WkNNRGcwTmtWQ1JVSkdPREVLVWxkVFFuWTNOWFZvVEVJeWNraFJVWEpNT1hKUlVEUjBhSFEyTDNwTFZIVndlWEZTYzFselMyNHZXRE5pU1VKNU1YSklabXB5YjJzSyIKICAgIH0KICBdLAogICJyb290VGhyZXNob2xkIjogMSwKICAicmVsZWFzZUtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siLAogICAgICAiY2hhbm5lbHMiOiBbCiAgICAgICAgImxhdGVzdCIsCiAgICAgICAgInByZXZpZXciLAogICAgICAgICJuaWdodGx5IgogICAgICBdLAogICAgICAicm9sZXMiOiBbCiAgICAgICAgInJlbGVhc2UiLAogICAgICAgICJ0cmVlIiwKICAgICAgICAiZGVza3RvcC1hcnRpZmFjdCIsCiAgICAgICAgInN0YW5kYWxvbmUtYXJ0aWZhY3QiLAogICAgICAgICJndWFyZGlhbi1hcnRpZmFjdCIKICAgICAgXQogICAgfQogIF0sCiAgInJlbGVhc2VUaHJlc2hvbGQiOiAxLAogICJjaGFubmVscyI6IFsKICAgICJsYXRlc3QiLAogICAgInByZXZpZXciLAogICAgIm5pZ2h0bHkiCiAgXQp9CgAFAAAABAAAAAAABgAAAAMAAAAABwAAAAwAAAAAAAAAAAAAAAAACAAAABAAAAAAAAAAAAAAAAAAAAAB", + "semver-u64-max": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAABSAQAAAAAAAAABqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqomMTg0NDY3NDQwNzM3MDk1NTE2MTUuMC4wLXJjLjErQnVpbGQuMDEAAAAHAAAADAAAAAAAAAAAAAAAAAAIAAAAEAAAAAAAAAAAAAAAAAAAAAE=", + "same-preview-nightly": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAABzAAEAAAAAAAAAAaqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqDzEuMi4zLXByZXZpZXcuNwEAAAAAAAAAAaqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqDzEuMi4zLXByZXZpZXcuNwAHAAAADAAAAAAAAAAAAAAAAAAIAAAAEAAAAAAAAAAAAAAAAAAAAAE=", + "expired-root": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABgzhPDY3RRU+9K+EKQ41mXwIIHkyuoF3oZRLcUSmxQ1cABAAAA357InNjaGVtYSI6Im9jeC51cGRhdGUucm9vdC8xIiwicmV2aXNpb24iOjEsImV4cGlyZXNBdCI6IjIwMjAtMDEtMDFUMDA6MDA6MDBaIiwicm9vdEtleXMiOlt7ImtleUlkIjoiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsImFsZ29yaXRobSI6Im1pbmlzaWduLWVkMjU1MTktYmxha2UyYjUxMi8xIiwicHVibGljS2V5IjoiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0sifV0sInJvb3RUaHJlc2hvbGQiOjEsInJlbGVhc2VLZXlzIjpbeyJrZXlJZCI6ImVhZTRjMDE4MGU4Y2EzOWE4NDRiM2MwZTFlYzI4ODQyMjYxZTg1NjI4ZDZkZWU3N2NlZmY1ZGQwODE4NTM3OTkiLCJhbGdvcml0aG0iOiJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsInB1YmxpY0tleSI6ImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwiY2hhbm5lbHMiOlsibGF0ZXN0IiwicHJldmlldyIsIm5pZ2h0bHkiXSwicm9sZXMiOlsicmVsZWFzZSIsInRyZWUiLCJkZXNrdG9wLWFydGlmYWN0Iiwic3RhbmRhbG9uZS1hcnRpZmFjdCIsImd1YXJkaWFuLWFydGlmYWN0Il19XSwicmVsZWFzZVRocmVzaG9sZCI6MSwiY2hhbm5lbHMiOlsibGF0ZXN0IiwicHJldmlldyIsIm5pZ2h0bHkiXX0ABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQ==", + "retained-removed-channel-floor": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABNyRbZGU1txKGkCgeWDRKy+xPizN2jB/TOwB4vxkS8RcABAAAA1Z7InNjaGVtYSI6Im9jeC51cGRhdGUucm9vdC8xIiwicmV2aXNpb24iOjEsImV4cGlyZXNBdCI6IjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwicm9vdEtleXMiOlt7ImtleUlkIjoiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsImFsZ29yaXRobSI6Im1pbmlzaWduLWVkMjU1MTktYmxha2UyYjUxMi8xIiwicHVibGljS2V5IjoiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0sifV0sInJvb3RUaHJlc2hvbGQiOjEsInJlbGVhc2VLZXlzIjpbeyJrZXlJZCI6ImVhZTRjMDE4MGU4Y2EzOWE4NDRiM2MwZTFlYzI4ODQyMjYxZTg1NjI4ZDZkZWU3N2NlZmY1ZGQwODE4NTM3OTkiLCJhbGdvcml0aG0iOiJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsInB1YmxpY0tleSI6ImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwiY2hhbm5lbHMiOlsibGF0ZXN0Il0sInJvbGVzIjpbInJlbGVhc2UiLCJ0cmVlIiwiZGVza3RvcC1hcnRpZmFjdCIsInN0YW5kYWxvbmUtYXJ0aWZhY3QiLCJndWFyZGlhbi1hcnRpZmFjdCJdfV0sInJlbGVhc2VUaHJlc2hvbGQiOjEsImNoYW5uZWxzIjpbImxhdGVzdCJdfQAFAAAABAAAAAAABgAAAHMAAQAAAAAAAAABqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqoPMS4yLjMtcHJldmlldy43AQAAAAAAAAABqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqoPMS4yLjMtcHJldmlldy43AAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQ==", + "observations-limit": "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", + "history-equal-time-revision-jump": "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" + }, + "invalid": { + "bad-domain": "WGN4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQ==", + "truncated-domain": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzE=", + "trailing-byte": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQA=", + "missing-final-tag": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAA", + "duplicate-first-tag": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQABAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAERERERERERERERERERERERERERERERERERERERERERE=", + "unknown-tag": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEACQAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQ==", + "length-overflow": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABP////97CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQ==", + "invalid-owner-kind": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHP8AAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQ==", + "identity-length-mismatch": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAFwAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQ==", + "unsafe-generation": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADD//////////wAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQ==", + "wrong-root-digest": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAAB/0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQ==", + "wrong-root-revision": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAACH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQ==", + "invalid-channel-marker": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAgAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQ==", + "zero-present-sequence": "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", + "invalid-version": "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", + "future-first-seen": "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", + "history-record-overflow": "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", + "history-next-digest-mismatch": "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", + "duplicate-interior-tag": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAgAAABwBAAAAAAAAAAEBABAAAAAAAAAAAAAAAAAAAAABAAMAAAAwAAAAAAAAAAEAAAAAAAAAAR9D5o6Y2RCGTS6Spiu+Ctb508DgvzDqbTFCyFG9S8YJAAQAAARiewogICJzY2hlbWEiOiAib2N4LnVwZGF0ZS5yb290LzEiLAogICJyZXZpc2lvbiI6IDEsCiAgImV4cGlyZXNBdCI6ICIyMDI4LTExLTA3VDAwOjAwOjAwWiIsCiAgInJvb3RLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIgogICAgfQogIF0sCiAgInJvb3RUaHJlc2hvbGQiOiAxLAogICJyZWxlYXNlS2V5cyI6IFsKICAgIHsKICAgICAgImtleUlkIjogImVhZTRjMDE4MGU4Y2EzOWE4NDRiM2MwZTFlYzI4ODQyMjYxZTg1NjI4ZDZkZWU3N2NlZmY1ZGQwODE4NTM3OTkiLAogICAgICAiYWxnb3JpdGhtIjogIm1pbmlzaWduLWVkMjU1MTktYmxha2UyYjUxMi8xIiwKICAgICAgInB1YmxpY0tleSI6ICJkVzUwY25WemRHVmtJR052YlcxbGJuUTZJRzFwYm1semFXZHVJSEIxWW14cFl5QnJaWGs2SUVGRE56WkNNRGcwTmtWQ1JVSkdPREVLVWxkVFFuWTNOWFZvVEVJeWNraFJVWEpNT1hKUlVEUjBhSFEyTDNwTFZIVndlWEZTYzFselMyNHZXRE5pU1VKNU1YSklabXB5YjJzSyIsCiAgICAgICJjaGFubmVscyI6IFsKICAgICAgICAibGF0ZXN0IiwKICAgICAgICAicHJldmlldyIsCiAgICAgICAgIm5pZ2h0bHkiCiAgICAgIF0sCiAgICAgICJyb2xlcyI6IFsKICAgICAgICAicmVsZWFzZSIsCiAgICAgICAgInRyZWUiLAogICAgICAgICJkZXNrdG9wLWFydGlmYWN0IiwKICAgICAgICAic3RhbmRhbG9uZS1hcnRpZmFjdCIsCiAgICAgICAgImd1YXJkaWFuLWFydGlmYWN0IgogICAgICBdCiAgICB9CiAgXSwKICAicmVsZWFzZVRocmVzaG9sZCI6IDEsCiAgImNoYW5uZWxzIjogWwogICAgImxhdGVzdCIsCiAgICAicHJldmlldyIsCiAgICAibmlnaHRseSIKICBdCn0KAAUAAAAEAAAAAAAGAAAAAwAAAAAHAAAADAAAAAAAAAAAAAAAAAAIAAAAEAAAAAAAAAAAAAAAAAAAAAE=", + "out-of-order-tags": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAIAAAAcAQAAAAAAAAABAQAQAAAAAAAAAAAAAAAAAAAAAQABAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEREREREREREREREREREREREREREREREREREREREREREAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAAAMAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAAAAAQ==", + "semver-core-overflow": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAABEAQAAAAAAAAABqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqoYMTg0NDY3NDQwNzM3MDk1NTE2MTYuMC4wAAAABwAAAAwAAAAAAAAAAAAAAAAACAAAABAAAAAAAAAAAAAAAAAAAAAB", + "semver-leading-v": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAAyAQAAAAAAAAABqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqoGdjEuMi4zAAAABwAAAAwAAAAAAAAAAAAAAAAACAAAABAAAAAAAAAAAAAAAAAAAAAB", + "semver-numeric-prerelease-zero": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAA0AQAAAAAAAAABqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqoIMS4yLjMtMDEAAAAHAAAADAAAAAAAAAAAAAAAAAAIAAAAEAAAAAAAAAAAAAAAAAAAAAE=", + "observations-over-limit": "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", + "observations-duplicate": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAABcAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABAAAAAAAAAAAAAAAAAAAAAB", + "observations-unsorted": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAQAAAAAAAAABH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogMSwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAAAAQAAAAAAAYAAAADAAAAAAcAAABcAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABAAAAAAAAAAAAAAAAAAAAAB", + "history-decreasing-time": "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", + "history-zero-predecessor": "b2N4LnVwZGF0ZS5jaGVja3BvaW50LzEAAAEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREREREREREREREREREREREREREREREREREREREREREQACAAAAHAEAAAAAAAAAAQEAEAAAAAAAAAAAAAAAAAAAAAEAAwAAADAAAAAAAAAAAwAAAAAAAAAETGP3UJvCsFqna2v+u1RkJiwvbAKVBSUFon0/mOxmHg0ABAAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogNCwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoABQAADe4AAAACAAAG8QAAAAAAAAAAH0PmjpjZEIZNLpKmK74K1vnTwOC/MOptMULIUb1LxgkAAAAAAAAAAjUbFVEUm/5RryXsRSefoEiwTE48fcmo6Cgqk17+Fu3GAAAAAAAAAAEAAARiewogICJzY2hlbWEiOiAib2N4LnVwZGF0ZS5yb290LzEiLAogICJyZXZpc2lvbiI6IDIsCiAgImV4cGlyZXNBdCI6ICIyMDI4LTExLTA3VDAwOjAwOjAwWiIsCiAgInJvb3RLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIgogICAgfQogIF0sCiAgInJvb3RUaHJlc2hvbGQiOiAxLAogICJyZWxlYXNlS2V5cyI6IFsKICAgIHsKICAgICAgImtleUlkIjogImVhZTRjMDE4MGU4Y2EzOWE4NDRiM2MwZTFlYzI4ODQyMjYxZTg1NjI4ZDZkZWU3N2NlZmY1ZGQwODE4NTM3OTkiLAogICAgICAiYWxnb3JpdGhtIjogIm1pbmlzaWduLWVkMjU1MTktYmxha2UyYjUxMi8xIiwKICAgICAgInB1YmxpY0tleSI6ICJkVzUwY25WemRHVmtJR052YlcxbGJuUTZJRzFwYm1semFXZHVJSEIxWW14cFl5QnJaWGs2SUVGRE56WkNNRGcwTmtWQ1JVSkdPREVLVWxkVFFuWTNOWFZvVEVJeWNraFJVWEpNT1hKUlVEUjBhSFEyTDNwTFZIVndlWEZTYzFselMyNHZXRE5pU1VKNU1YSklabXB5YjJzSyIsCiAgICAgICJjaGFubmVscyI6IFsKICAgICAgICAibGF0ZXN0IiwKICAgICAgICAicHJldmlldyIsCiAgICAgICAgIm5pZ2h0bHkiCiAgICAgIF0sCiAgICAgICJyb2xlcyI6IFsKICAgICAgICAicmVsZWFzZSIsCiAgICAgICAgInRyZWUiLAogICAgICAgICJkZXNrdG9wLWFydGlmYWN0IiwKICAgICAgICAic3RhbmRhbG9uZS1hcnRpZmFjdCIsCiAgICAgICAgImd1YXJkaWFuLWFydGlmYWN0IgogICAgICBdCiAgICB9CiAgXSwKICAicmVsZWFzZVRocmVzaG9sZCI6IDEsCiAgImNoYW5uZWxzIjogWwogICAgImxhdGVzdCIsCiAgICAicHJldmlldyIsCiAgICAibmlnaHRseSIKICBdCn0KAAACL3sic2NoZW1hIjoib2N4LnVwZGF0ZS5yb290LXRyYW5zaXRpb24tc2lnbmF0dXJlcy8xIiwic2lnbmF0dXJlcyI6W3sia2V5RmluZ2VycHJpbnQiOiJhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhIiwic2lnbmF0dXJlQm94IjoiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUhOcFoyNWhkSFZ5WlNCbWNtOXRJRzFwYm1semFXZHVJSE5sWTNKbGRDQnJaWGtLVWxWUlpqWk1Va05IUVRscE5UVTVjak5uTjFZeGNVNTVTa1JCY0VkcGNEaE5abkZqWVdSSloxUTVRM1ZvVmpORlRXaEliMDR4YlVkVWExVnBaRVl2ZWpkVGNteFJaMWhrZVRodlptcGlOMkpPU2twNWJFUlBiMk55UTI4NFMweDZXbmR2UFFwMGNuVnpkR1ZrSUdOdmJXMWxiblE2SUhScGJXVnpkR0Z0Y0RveE5UVTJNVGt6TXpNMUNXWnBiR1U2ZEdWemRBcDVMM0pWZHpKNU9DOW9UMVZaYWxwVk56RmxTSEF2VjI4eFMxbzBNR1pIZVRKV1NrVkViRE0wV0UxS1RTdFVXRFE0VTNNdk1UZDFNMGwyU1daaVZsSXhSbXRhV2xOT1EybHpVV0oxVVZrcllraDNhRVZDWnowOSJ9XX0AAAbxAAAAAAAAAAI1GxVRFJv+Ua8l7EUnn6BIsExOPH3JqOgoKpNe/hbtxgAAAAAAAAAETGP3UJvCsFqna2v+u1RkJiwvbAKVBSUFon0/mOxmHg0AAAAAAAAAAQAABGJ7CiAgInNjaGVtYSI6ICJvY3gudXBkYXRlLnJvb3QvMSIsCiAgInJldmlzaW9uIjogNCwKICAiZXhwaXJlc0F0IjogIjIwMjgtMTEtMDdUMDA6MDA6MDBaIiwKICAicm9vdEtleXMiOiBbCiAgICB7CiAgICAgICJrZXlJZCI6ICJlYWU0YzAxODBlOGNhMzlhODQ0YjNjMGUxZWMyODg0MjI2MWU4NTYyOGQ2ZGVlNzdjZWZmNWRkMDgxODUzNzk5IiwKICAgICAgImFsZ29yaXRobSI6ICJtaW5pc2lnbi1lZDI1NTE5LWJsYWtlMmI1MTIvMSIsCiAgICAgICJwdWJsaWNLZXkiOiAiZFc1MGNuVnpkR1ZrSUdOdmJXMWxiblE2SUcxcGJtbHphV2R1SUhCMVlteHBZeUJyWlhrNklFRkROelpDTURnME5rVkNSVUpHT0RFS1VsZFRRblkzTlhWb1RFSXlja2hSVVhKTU9YSlJVRFIwYUhRMkwzcExWSFZ3ZVhGU2MxbHpTMjR2V0ROaVNVSjVNWEpJWm1weWIyc0siCiAgICB9CiAgXSwKICAicm9vdFRocmVzaG9sZCI6IDEsCiAgInJlbGVhc2VLZXlzIjogWwogICAgewogICAgICAia2V5SWQiOiAiZWFlNGMwMTgwZThjYTM5YTg0NGIzYzBlMWVjMjg4NDIyNjFlODU2MjhkNmRlZTc3Y2VmZjVkZDA4MTg1Mzc5OSIsCiAgICAgICJhbGdvcml0aG0iOiAibWluaXNpZ24tZWQyNTUxOS1ibGFrZTJiNTEyLzEiLAogICAgICAicHVibGljS2V5IjogImRXNTBjblZ6ZEdWa0lHTnZiVzFsYm5RNklHMXBibWx6YVdkdUlIQjFZbXhwWXlCclpYazZJRUZETnpaQ01EZzBOa1ZDUlVKR09ERUtVbGRUUW5ZM05YVm9URUl5Y2toUlVYSk1PWEpSVURSMGFIUTJMM3BMVkhWd2VYRlNjMWx6UzI0dldETmlTVUo1TVhKSVptcHliMnNLIiwKICAgICAgImNoYW5uZWxzIjogWwogICAgICAgICJsYXRlc3QiLAogICAgICAgICJwcmV2aWV3IiwKICAgICAgICAibmlnaHRseSIKICAgICAgXSwKICAgICAgInJvbGVzIjogWwogICAgICAgICJyZWxlYXNlIiwKICAgICAgICAidHJlZSIsCiAgICAgICAgImRlc2t0b3AtYXJ0aWZhY3QiLAogICAgICAgICJzdGFuZGFsb25lLWFydGlmYWN0IiwKICAgICAgICAiZ3VhcmRpYW4tYXJ0aWZhY3QiCiAgICAgIF0KICAgIH0KICBdLAogICJyZWxlYXNlVGhyZXNob2xkIjogMSwKICAiY2hhbm5lbHMiOiBbCiAgICAibGF0ZXN0IiwKICAgICJwcmV2aWV3IiwKICAgICJuaWdodGx5IgogIF0KfQoAAAIveyJzY2hlbWEiOiJvY3gudXBkYXRlLnJvb3QtdHJhbnNpdGlvbi1zaWduYXR1cmVzLzEiLCJzaWduYXR1cmVzIjpbeyJrZXlGaW5nZXJwcmludCI6ImFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWEiLCJzaWduYXR1cmVCb3giOiJkVzUwY25WemRHVmtJR052YlcxbGJuUTZJSE5wWjI1aGRIVnlaU0JtY205dElHMXBibWx6YVdkdUlITmxZM0psZENCclpYa0tVbFZSWmpaTVVrTkhRVGxwTlRVNWNqTm5OMVl4Y1U1NVNrUkJjRWRwY0RoTlpuRmpZV1JKWjFRNVEzVm9Wak5GVFdoSWIwNHhiVWRVYTFWcFpFWXZlamRUY214UloxaGtlVGh2Wm1waU4ySk9Ta3A1YkVSUGIyTnlRMjg0UzB4NlduZHZQUXAwY25WemRHVmtJR052YlcxbGJuUTZJSFJwYldWemRHRnRjRG94TlRVMk1Ua3pNek0xQ1dacGJHVTZkR1Z6ZEFwNUwzSlZkeko1T0M5b1QxVlphbHBWTnpGbFNIQXZWMjh4UzFvME1HWkhlVEpXU2tWRWJETTBXRTFLVFN0VVdEUTRVM012TVRkMU0wbDJTV1ppVmxJeFJtdGFXbE5PUTJselVXSjFVVmtyWWtoM2FFVkNaejA5In1dfQAGAAAAMQEAAAAAAAAAKqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqBTEuMi4zAAAABwAAADQAAAABu7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7sAAAAAAAAAAQAAAAAAAAAAAAgAAAAQAAAAAAAAAAIAAAAAAAAAAQ==" + } +} diff --git a/tests/fixtures/update-checkpoint/history-limits.json b/tests/fixtures/update-checkpoint/history-limits.json new file mode 100644 index 00000000000..6422ef5a84b --- /dev/null +++ b/tests/fixtures/update-checkpoint/history-limits.json @@ -0,0 +1 @@ +{"proposed_valid_history_128":{"bytes":200163,"sha256":"252e815bdfb7a6c2fb44254db6947f752787f8afa4b9e3916e4fd3f510716053","base64":"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"},"proposed_invalid_history_129":{"bytes":201718,"sha256":"bb8aa4b221a177873f28acdb1415831268cfa9e071529d00fea52f9e4e116369","base64":"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"}} diff --git a/tests/fixtures/update-checkpoint/initial.bin b/tests/fixtures/update-checkpoint/initial.bin new file mode 100644 index 0000000000000000000000000000000000000000..e5a59e029b63be8ad302cc3f41bd8ea6c4c77afc GIT binary patch literal 1369 zcmeHHOK;Oa5O$!vA`az_MC2=^c%3+LdV(ft>ZD1PG_MBru-=`&n zegXf2#|d#qLgL1W1OI>7t5O&**^~@^nD(L{74vtaBN4m?{O29 zEWl}ChY&rD1xQs?J&RCQDRvcQGxfl6LAnAu z!MPIF^LaBz6hJ^!UC*m(0fDX+RGk(mK(R>R=t!ef(UGp@iltI=P~sA^u^-y8o1*3)n z(`7R}pc7+f3mv$p!NGJZ91Wd9e$SgLfw0Yq;FxL-Z=?79V$o MvXt9gyVBTx0g$0qMgRZ+ literal 0 HcmV?d00001 diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index 823d4b6403a..eabe68e92e6 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -13,6 +13,7 @@ import { deriveCandidateId } from "../../src/update/update-candidate-id.mjs"; import { sameSignedVersion, trustedCommentMatchesVersion } from "../../src/update/update-signed-version.mjs"; import { bootstrapEmbeddedRoot } from "../../src/update/signed-supply.mjs"; import { parseSignatureEnvelope, parseUpdateDocument } from "../../src/update/update-contracts.mjs"; +import { checkpointPayloadDigest, decodeCheckpointPayload, encodeCheckpointPayload } from "../../src/update/update-checkpoint-codec.mjs"; const args = process.argv.slice(2); assert.ok(args.length === 0 || (args.length === 1 && args[0] === "--require-node18"), "unsupported arguments"); @@ -365,6 +366,35 @@ try { } const root = readFileSync(fileURLToPath(new URL("../../src/update/trust-root.json", import.meta.url))); +const checkpointCorpus = JSON.parse(readFileSync(fileURLToPath(new URL("../fixtures/update-checkpoint/corpus.json", import.meta.url)), "utf8")); +for (const [name, base64] of Object.entries(checkpointCorpus.valid)) { + const payload = Buffer.from(base64, "base64"), copy = Buffer.from(payload); + const decoded = decodeCheckpointPayload(payload); + assert.deepEqual(Buffer.from(encodeCheckpointPayload(decoded)), copy, name); + assert.equal(checkpointPayloadDigest(payload), createHash("sha256").update(copy).digest("hex"), name); + payload.fill(0); + assert.deepEqual(Buffer.from(encodeCheckpointPayload(decoded)), copy, name); +} +for (const [name, base64] of Object.entries(checkpointCorpus.invalid)) { + const payload = Buffer.from(base64, "base64"); + assert.throws(() => decodeCheckpointPayload(payload), name); + assert.throws(() => checkpointPayloadDigest(payload), name); +} +const checkpointLimits = JSON.parse(readFileSync(fileURLToPath(new URL("../fixtures/update-checkpoint/history-limits.json", import.meta.url)), "utf8")); +const limitPayload = Buffer.from(checkpointLimits.proposed_valid_history_128.base64, "base64"); +assert.equal(decodeCheckpointPayload(limitPayload).history.length, 128); +assert.equal(checkpointPayloadDigest(limitPayload), checkpointLimits.proposed_valid_history_128.sha256); +assert.throws(() => decodeCheckpointPayload(Buffer.from(checkpointLimits.proposed_invalid_history_129.base64, "base64"))); +const checkpointData = decodeCheckpointPayload(Buffer.from(checkpointCorpus.valid.empty, "base64")); +const maximumObservations = decodeCheckpointPayload(Buffer.from(checkpointCorpus.valid["observations-limit"], "base64")); +maximumObservations.firstSeen.preview = maximumObservations.firstSeen.latest.slice(); +maximumObservations.firstSeen.nightly = maximumObservations.firstSeen.latest.slice(); +const maximumRoundtrip = decodeCheckpointPayload(encodeCheckpointPayload(maximumObservations)); +assert.deepEqual(Object.values(maximumRoundtrip.firstSeen).map((value) => value.length), [4096, 4096, 4096]); +const checkpointAgain = decodeCheckpointPayload(Buffer.from(checkpointCorpus.valid.empty, "base64")); +const checkpointBuffers = [checkpointData.namespaceDigest, checkpointData.principalDigest, checkpointData.identityBytes, checkpointData.rootDigest, checkpointData.rootBytes, checkpointAgain.rootDigest]; +assert.equal(new Set(checkpointBuffers.map((value) => value.buffer)).size, checkpointBuffers.length); +assert.throws(() => encodeCheckpointPayload({ ...checkpointData, get generation() { throw new Error("accessor invoked"); } }), /Invalid checkpoint payload/); const expiry = Date.parse("2028-11-07T00:00:00Z"); assert.ok(Object.isFrozen(bootstrapEmbeddedRoot(root, expiry - 1))); assert.throws(() => bootstrapEmbeddedRoot(root, expiry)); diff --git a/tests/update/update-checkpoint-codec.test.ts b/tests/update/update-checkpoint-codec.test.ts new file mode 100644 index 00000000000..4f08314e944 --- /dev/null +++ b/tests/update/update-checkpoint-codec.test.ts @@ -0,0 +1,92 @@ +import { describe, expect, test } from "bun:test"; +import { createHash } from "node:crypto"; +import { readFileSync } from "node:fs"; +import { fixturePath } from "../helpers/repo-root"; +import { checkpointPayloadDigest, decodeCheckpointPayload, encodeCheckpointPayload, type CheckpointPayload } from "../../src/update/update-checkpoint-codec.mjs"; + +describe("unverified checkpoint payload codec", () => { + const golden = readFileSync(fixturePath("update-checkpoint", "initial.bin")); + + test("decodes and reproduces the independently generated golden bytes", () => { + expect(golden.byteLength).toBe(1369); + expect(createHash("sha256").update(golden).digest("hex")).toBe("9b2d3f7c39c2456cf3f28439de1f80be8af006c4705d5e621ea9abb723077546"); + const data = decodeCheckpointPayload(golden); + expect(data.rootRevision).toBe(1); + expect(data.generation).toBe(1); + expect(data.channels).toEqual({ latest: null, preview: null, nightly: null }); + expect(Buffer.from(encodeCheckpointPayload(data))).toEqual(golden); + expect(checkpointPayloadDigest(golden)).toBe("9b2d3f7c39c2456cf3f28439de1f80be8af006c4705d5e621ea9abb723077546"); + }); + + test("accepts independent canonical vectors and rejects malformed corpus", () => { + const corpus = JSON.parse(readFileSync(fixturePath("update-checkpoint", "corpus.json"), "utf8")) as { valid: Record; invalid: Record }; + for (const [name, base64] of Object.entries(corpus.valid)) { + const source = Buffer.from(base64, "base64"); + const decoded = decodeCheckpointPayload(source); + expect(Buffer.from(encodeCheckpointPayload(decoded)), name).toEqual(source); + expect(checkpointPayloadDigest(source), name).toBe(createHash("sha256").update(source).digest("hex")); + } + for (const [name, base64] of Object.entries(corpus.invalid)) { + const source = Buffer.from(base64, "base64"); + expect(() => decodeCheckpointPayload(source), name).toThrow(); + expect(() => checkpointPayloadDigest(source), name).toThrow(); + } + }); + + test("enforces history count at the actual boundary", () => { + const fixtures = JSON.parse(readFileSync(fixturePath("update-checkpoint", "history-limits.json"), "utf8")) as Record; + const valid = Buffer.from(fixtures.proposed_valid_history_128.base64, "base64"); + const invalid = Buffer.from(fixtures.proposed_invalid_history_129.base64, "base64"); + expect(checkpointPayloadDigest(valid)).toBe(fixtures.proposed_valid_history_128.sha256); + expect(decodeCheckpointPayload(valid).history).toHaveLength(128); + expect(() => decodeCheckpointPayload(invalid)).toThrow(); + expect(() => checkpointPayloadDigest(invalid)).toThrow(); + }); + + test("supports the simultaneous observation limit in all three channels", () => { + const corpus = JSON.parse(readFileSync(fixturePath("update-checkpoint", "corpus.json"), "utf8")) as { valid: Record }; + const data = decodeCheckpointPayload(Buffer.from(corpus.valid["observations-limit"], "base64")); + data.firstSeen.preview = data.firstSeen.latest.slice(); + data.firstSeen.nightly = data.firstSeen.latest.slice(); + const decoded = decodeCheckpointPayload(encodeCheckpointPayload(data)); + expect(decoded.firstSeen.latest).toHaveLength(4096); + expect(decoded.firstSeen.preview).toHaveLength(4096); + expect(decoded.firstSeen.nightly).toHaveLength(4096); + data.firstSeen.preview.push(data.firstSeen.preview[4095]); + expect(() => encodeCheckpointPayload(data)).toThrow(); + }); + + test("captures bytes and fields without accepting accessors or caller mutation", () => { + const source = Buffer.from(golden); + const decoded = decodeCheckpointPayload(source); + const encoded = encodeCheckpointPayload(decoded); + source.fill(0); + decoded.rootBytes.fill(0); + expect(Buffer.from(encoded)).toEqual(golden); + const original = decodeCheckpointPayload(golden); + const other = decodeCheckpointPayload(golden); + const fields = [original.namespaceDigest, original.principalDigest, original.identityBytes, original.rootDigest, original.rootBytes, other.rootDigest]; + expect(new Set(fields.map((field) => field.buffer)).size).toBe(fields.length); + original.rootDigest.fill(0); + expect(other.rootDigest).toEqual(decodeCheckpointPayload(golden).rootDigest); + const valid = decodeCheckpointPayload(golden); + const hostile = { ...valid, get generation() { throw new Error("getter invoked"); } }; + expect(() => encodeCheckpointPayload(hostile)).toThrow("Invalid checkpoint payload"); + const extra = { ...valid, extra: true }; + expect(() => encodeCheckpointPayload(extra)).toThrow(); + const sparse = { ...valid, history: new Array(1) }; + expect(() => encodeCheckpointPayload(sparse as CheckpointPayload)).toThrow(); + const shadowed = Buffer.from(golden); + Object.defineProperty(shadowed, "byteLength", { value: 0 }); + expect(checkpointPayloadDigest(shadowed)).toBe("9b2d3f7c39c2456cf3f28439de1f80be8af006c4705d5e621ea9abb723077546"); + }); + + test("checks raw-byte cap before structural decoding", () => { + const atLimit = new Uint8Array(64 * 1024 * 1024); + const tooLarge = new Uint8Array(atLimit.length + 1); + for (const operation of [decodeCheckpointPayload, checkpointPayloadDigest]) { + expect(() => operation(atLimit)).toThrow("Invalid checkpoint payload"); + expect(() => operation(tooLarge)).toThrow("Invalid update bytes"); + } + }); +}); From a07c771eed8039c1327e0c959922b1b17028bf92 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 19:52:29 +0900 Subject: [PATCH 41/42] Bound checkpoint descriptor capture --- src/update/update-checkpoint-codec.mjs | 13 +++++++------ tests/helpers/update-node-harness.mjs | 12 ++++++++++++ tests/update/update-checkpoint-codec.test.ts | 17 +++++++++++++++++ 3 files changed, 36 insertions(+), 6 deletions(-) diff --git a/src/update/update-checkpoint-codec.mjs b/src/update/update-checkpoint-codec.mjs index 028353d3ec0..d822c19768b 100644 --- a/src/update/update-checkpoint-codec.mjs +++ b/src/update/update-checkpoint-codec.mjs @@ -17,12 +17,13 @@ const fail = () => { throw new Error("Invalid checkpoint payload"); }; function record(value, keys) { if (value === null || typeof value !== "object" || Array.isArray(value)) fail(); - const descriptors = Object.getOwnPropertyDescriptors(value); - const names = Reflect.ownKeys(descriptors); + // JavaScript must enumerate own keys to reject extras; executable proxies can + // still make that enumeration expensive. Do not materialize extra descriptors. + const names = Reflect.ownKeys(value); if (names.length !== keys.length || names.some((key) => typeof key !== "string" || !keys.includes(key))) fail(); const result = Object.create(null); for (const key of keys) { - const descriptor = descriptors[key]; + const descriptor = Object.getOwnPropertyDescriptor(value, key); if (!descriptor || !("value" in descriptor)) fail(); result[key] = descriptor.value; } @@ -32,11 +33,11 @@ function list(value, max) { if (!Array.isArray(value)) fail(); const length = Object.getOwnPropertyDescriptor(value, "length")?.value; if (!Number.isSafeInteger(length) || length < 0 || length > max) fail(); - const descriptors = Object.getOwnPropertyDescriptors(value); - if (descriptors.length?.value !== length || Reflect.ownKeys(descriptors).length !== length + 1) fail(); + const names = Reflect.ownKeys(value); + if (names.length !== length + 1 || names.some((key) => key !== "length" && (typeof key !== "string" || !/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= length))) fail(); const result = []; for (let i = 0; i < length; i++) { - const descriptor = descriptors[String(i)]; + const descriptor = Object.getOwnPropertyDescriptor(value, String(i)); if (!descriptor || !("value" in descriptor)) fail(); result.push(descriptor.value); } diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index eabe68e92e6..f0380b76a7b 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -395,6 +395,18 @@ const checkpointAgain = decodeCheckpointPayload(Buffer.from(checkpointCorpus.val const checkpointBuffers = [checkpointData.namespaceDigest, checkpointData.principalDigest, checkpointData.identityBytes, checkpointData.rootDigest, checkpointData.rootBytes, checkpointAgain.rootDigest]; assert.equal(new Set(checkpointBuffers.map((value) => value.buffer)).size, checkpointBuffers.length); assert.throws(() => encodeCheckpointPayload({ ...checkpointData, get generation() { throw new Error("accessor invoked"); } }), /Invalid checkpoint payload/); +const oversizedRecord = { ...checkpointData }, oversizedArray = []; +for (let i = 0; i < 1000; i++) { + Object.defineProperty(oversizedRecord, `extra${i}`, { value: i }); + Object.defineProperty(oversizedArray, `extra${i}`, { value: i }); +} +let recordDescriptorReads = 0, arrayDescriptorReads = 0; +const trappedRecord = new Proxy(oversizedRecord, { getOwnPropertyDescriptor(target, key) { recordDescriptorReads++; return Reflect.getOwnPropertyDescriptor(target, key); } }); +const trappedArray = new Proxy(oversizedArray, { getOwnPropertyDescriptor(target, key) { arrayDescriptorReads++; return Reflect.getOwnPropertyDescriptor(target, key); } }); +assert.throws(() => encodeCheckpointPayload(trappedRecord)); +assert.throws(() => encodeCheckpointPayload({ ...checkpointData, history: trappedArray })); +assert.equal(recordDescriptorReads, 0); +assert.equal(arrayDescriptorReads, 1); const expiry = Date.parse("2028-11-07T00:00:00Z"); assert.ok(Object.isFrozen(bootstrapEmbeddedRoot(root, expiry - 1))); assert.throws(() => bootstrapEmbeddedRoot(root, expiry)); diff --git a/tests/update/update-checkpoint-codec.test.ts b/tests/update/update-checkpoint-codec.test.ts index 4f08314e944..493a6759ffa 100644 --- a/tests/update/update-checkpoint-codec.test.ts +++ b/tests/update/update-checkpoint-codec.test.ts @@ -81,6 +81,23 @@ describe("unverified checkpoint payload codec", () => { expect(checkpointPayloadDigest(shadowed)).toBe("9b2d3f7c39c2456cf3f28439de1f80be8af006c4705d5e621ea9abb723077546"); }); + test("rejects extra properties before fetching every descriptor", () => { + const original = decodeCheckpointPayload(golden); + const record = { ...original } as Record; + const array: unknown[] = []; + for (let i = 0; i < 1000; i++) { + Object.defineProperty(record, `extra${i}`, { value: i }); + Object.defineProperty(array, `extra${i}`, { value: i }); + } + let recordLookups = 0, arrayLookups = 0; + const recordProxy = new Proxy(record, { getOwnPropertyDescriptor(target, key) { recordLookups++; return Reflect.getOwnPropertyDescriptor(target, key); } }); + const arrayProxy = new Proxy(array, { getOwnPropertyDescriptor(target, key) { arrayLookups++; return Reflect.getOwnPropertyDescriptor(target, key); } }); + expect(() => encodeCheckpointPayload(recordProxy as unknown as CheckpointPayload)).toThrow(); + expect(() => encodeCheckpointPayload({ ...original, history: arrayProxy as CheckpointPayload["history"] })).toThrow(); + expect(recordLookups).toBe(0); + expect(arrayLookups).toBe(1); // The bounded array length is captured before checking its keys. + }); + test("checks raw-byte cap before structural decoding", () => { const atLimit = new Uint8Array(64 * 1024 * 1024); const tooLarge = new Uint8Array(atLimit.length + 1); From c13fa19e9fd341f096e5c27f5bf610b7bb887d98 Mon Sep 17 00:00:00 2001 From: JUN Date: Sat, 7 Nov 2026 20:00:34 +0900 Subject: [PATCH 42/42] Protect checkpoint encoder collection limits --- tests/helpers/update-node-harness.mjs | 16 ++++++++++++++++ tests/update/update-checkpoint-codec.test.ts | 18 ++++++++++++++++-- 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/tests/helpers/update-node-harness.mjs b/tests/helpers/update-node-harness.mjs index f0380b76a7b..92b3d2308ac 100644 --- a/tests/helpers/update-node-harness.mjs +++ b/tests/helpers/update-node-harness.mjs @@ -385,12 +385,28 @@ const limitPayload = Buffer.from(checkpointLimits.proposed_valid_history_128.bas assert.equal(decodeCheckpointPayload(limitPayload).history.length, 128); assert.equal(checkpointPayloadDigest(limitPayload), checkpointLimits.proposed_valid_history_128.sha256); assert.throws(() => decodeCheckpointPayload(Buffer.from(checkpointLimits.proposed_invalid_history_129.base64, "base64"))); +const oversizedHistory = decodeCheckpointPayload(limitPayload); +const nextRootValue = JSON.parse(Buffer.from(oversizedHistory.rootBytes).toString("utf8")); +nextRootValue.revision = oversizedHistory.rootRevision + 1; +const nextRootBytes = Buffer.from(JSON.stringify(nextRootValue)); +const nextRootDigest = createHash("sha256").update(nextRootBytes).digest(); +oversizedHistory.history.push({ previousRevision: oversizedHistory.rootRevision, previousDigest: oversizedHistory.rootDigest, + nextRevision: nextRootValue.revision, nextDigest: nextRootDigest, acceptedAtMs: oversizedHistory.history[127].acceptedAtMs, + rootBytes: nextRootBytes, envelopeBytes: oversizedHistory.history[127].envelopeBytes }); +oversizedHistory.rootRevision = nextRootValue.revision; +oversizedHistory.rootDigest = nextRootDigest; +oversizedHistory.rootBytes = nextRootBytes; +assert.throws(() => encodeCheckpointPayload(oversizedHistory)); const checkpointData = decodeCheckpointPayload(Buffer.from(checkpointCorpus.valid.empty, "base64")); const maximumObservations = decodeCheckpointPayload(Buffer.from(checkpointCorpus.valid["observations-limit"], "base64")); maximumObservations.firstSeen.preview = maximumObservations.firstSeen.latest.slice(); maximumObservations.firstSeen.nightly = maximumObservations.firstSeen.latest.slice(); const maximumRoundtrip = decodeCheckpointPayload(encodeCheckpointPayload(maximumObservations)); assert.deepEqual(Object.values(maximumRoundtrip.firstSeen).map((value) => value.length), [4096, 4096, 4096]); +const overLimitDigest = Buffer.alloc(32); +overLimitDigest.writeUInt32BE(4096, 28); +maximumObservations.firstSeen.preview.push({ candidateDigest: overLimitDigest, firstSeenMs: 0 }); +assert.throws(() => encodeCheckpointPayload(maximumObservations)); const checkpointAgain = decodeCheckpointPayload(Buffer.from(checkpointCorpus.valid.empty, "base64")); const checkpointBuffers = [checkpointData.namespaceDigest, checkpointData.principalDigest, checkpointData.identityBytes, checkpointData.rootDigest, checkpointData.rootBytes, checkpointAgain.rootDigest]; assert.equal(new Set(checkpointBuffers.map((value) => value.buffer)).size, checkpointBuffers.length); diff --git a/tests/update/update-checkpoint-codec.test.ts b/tests/update/update-checkpoint-codec.test.ts index 493a6759ffa..95740678e6f 100644 --- a/tests/update/update-checkpoint-codec.test.ts +++ b/tests/update/update-checkpoint-codec.test.ts @@ -38,7 +38,19 @@ describe("unverified checkpoint payload codec", () => { const valid = Buffer.from(fixtures.proposed_valid_history_128.base64, "base64"); const invalid = Buffer.from(fixtures.proposed_invalid_history_129.base64, "base64"); expect(checkpointPayloadDigest(valid)).toBe(fixtures.proposed_valid_history_128.sha256); - expect(decodeCheckpointPayload(valid).history).toHaveLength(128); + const atLimit = decodeCheckpointPayload(valid); + expect(atLimit.history).toHaveLength(128); + const root = JSON.parse(Buffer.from(atLimit.rootBytes).toString("utf8")) as { revision: number }; + root.revision = atLimit.rootRevision + 1; + const nextRoot = Buffer.from(JSON.stringify(root)); + const nextDigest = createHash("sha256").update(nextRoot).digest(); + atLimit.history.push({ previousRevision: atLimit.rootRevision, previousDigest: atLimit.rootDigest, + nextRevision: root.revision, nextDigest, acceptedAtMs: atLimit.history[127].acceptedAtMs, + rootBytes: nextRoot, envelopeBytes: atLimit.history[127].envelopeBytes }); + atLimit.rootRevision = root.revision; + atLimit.rootDigest = nextDigest; + atLimit.rootBytes = nextRoot; + expect(() => encodeCheckpointPayload(atLimit)).toThrow(); expect(() => decodeCheckpointPayload(invalid)).toThrow(); expect(() => checkpointPayloadDigest(invalid)).toThrow(); }); @@ -52,7 +64,9 @@ describe("unverified checkpoint payload codec", () => { expect(decoded.firstSeen.latest).toHaveLength(4096); expect(decoded.firstSeen.preview).toHaveLength(4096); expect(decoded.firstSeen.nightly).toHaveLength(4096); - data.firstSeen.preview.push(data.firstSeen.preview[4095]); + const nextDigest = Buffer.alloc(32); + nextDigest.writeUInt32BE(4096, 28); + data.firstSeen.preview.push({ candidateDigest: nextDigest, firstSeenMs: 0 }); expect(() => encodeCheckpointPayload(data)).toThrow(); });