Skip to content

Verify the signed release runtime once per launch, as one verification of the whole runtime set (design for approval) #5515

Open

Description

@auser

Status: draft design v2, revised 2026-11-14 after code archaeology and maintainer review; not approved, no code yet. It touches ADR-001 claim 20 (release artifact verification) and claim 3, so the claim owner approves it before implementation. Any session or tool (Claude, Codex, Kimi, Delta) can implement it from this issue alone. Evidence is from origin/main at 96e484cdd9; statements are read from code unless marked INFERENCE or UNKNOWN.

1. Problem (measured)

A one-command signed-release launch verifies the release proof seven times. On an idle GCP VM (n2-standard-4, SSD, load 0.1 to 0.4, signed v0.28.0-rc.2, Firecracker, curl OCI image, five cold launches, stable to 1 percent, spans from #5508): six full verifications at about 641 ms each, about 4.5 s of a 5.6 s launch. Everything else in admission is small (sign_and_verify_plan 0.3 ms, audit_record 4.8 ms). Each verification reads and hashes the roughly 20 MB archive, verifies the checksum and archive signatures, copies the archive to a temp file and parses it. Data and discussion: #5487, #4391. Budgets (cold p99 300 ms, warm p99 50 ms, reference/performance.md) are not changed.

2. Findings from the code (what the earlier draft got wrong or missed)

All seven run in one process. There is no resident admission daemon: mvm-hostd is a library linked into mvmctl, and the supervisor and driver binaries contain no runtime-verification code (they receive the already bound config). So every one of the seven can share one result. The seven, by lap:

# lap caller chain (CLI run) class
1 attach_overlay.release_proof_lookup exec.rs:1322 to runtime_overlay.rs:123 cached_runtime_release_proof duplicate: mints the path-only proof every later check pins against
2 attach_overlay.release_proof_verify same function, runtime_overlay.rs:131 duplicate of #1 in the same function
3 attach_initramfs.release_proof_verify exec.rs:1339 to universal_initramfs.rs:154 duplicate; its own comment calls the digest check a pre-check and names bind the custody point
4 runtime_evidence.release_proof_verify plan_admission.rs:381 verify_runtime to assurance_runtime.rs:136 duplicate in the CLI process; an admission refusal gate
5 same lap plan_admission.rs:382 to the assurance probe verify_assurance_guest_protocol pure duplicate of #6 (result discarded)
6 same lap assurance_runtime.rs:131 AssuranceRuntimeBinding::verify eager pre-computation for a possible later assurance campaign, runs on every release launch
7 same lap runner.rs:342-347 RuntimeLifecycleLease::bind to runtime_evidence.rs:776 the custody point: snapshots the selected artifacts from the verified in-memory archive, hashes them against the declaration while copying, and boot then uses the retained generation paths

Why they exist. Sites 1 to 7 all came in with #4409 ("authenticate release runtime across launch and restore", 62f65b7231): authenticated selection plus a durable lifecycle binding. No commit, PR or issue says any launch-path site closes a time-of-check/time-of-use window, and none was added to fix a standalone security finding. The closest statements of intent: universal_initramfs.rs:226 ("the digest check here is a pre-check; RuntimeLifecycleLease::bind is the custody point") and registry_pack.rs:38 ("recheck the actual selection immediately before dispatch", built registry packs only, with an audit failure entry). Layered artifact re-hashing was previously called out in #4648 and partly mitigated by the process-local digest registry in #4697.

The verify-to-use gap is smaller than the first draft implied. bind already builds the retained generation from the verified archive snapshot and boots from those paths. What stays path-based before bind is the proof (a set of paths plus a digest), which admission, assurance and attach each re-read; the digest pin (evidence.rs, "runtime proof archive digest changed") is what makes those agree and must be kept.

Other facts that change the design:

  • Threat model. The existing code and ADR already exclude a same-user attacker ("the host account is trusted not to chmod or replace its private generations"; ~/.mvm is mode 0700). A launch-owned snapshot directory is writable by that same user, so it protects only against non-malicious races (interrupted or corrupt writes, a concurrent cache refresh) and a tampered release artifact, not a malicious same-user process. The first draft's wording was wrong and its tests would have asserted more than the design provides.
  • Claim numbering. ADR-001 row 9 is about published bundles; the runtime release proof is claim 20 (and claim 3 for the root hash). The first draft cited row 9 in error.
  • Verification is offline and deterministic. verify_release_archive embeds the Sigstore trust root, derives accepted identities from the tag, uses no network, no wall clock and no revocation list. So per-launch re-verification buys no more freshness than verifying once per process, which weakens the case that per-launch is required for Managed admission and mvmd HostInterface implementation (post-demo) #5124, and makes a later cross-process record safer than first assumed (still its own decision, section 7).
  • The audit chain does not record the runtime today. plan.admitted labels carry workload, signer, authorizer, retention and kernel_sha256; plan.launched carries workload and backend. The signed ExecutionPlan has no runtime field (environment: Option<EnvironmentRef> holds only kernel_sha256, and its doc says a runtime overlay can be added there). The runtime binding is recorded in launch.json and runtime_meta but not chain-signed.
  • Several launch assemblers, not one. The CLI (exec.rs::resolve_launch), the library path (hostd/run.rs::attach_guest_runtime), persistent start (persistent.rs), session boot (entrypoint/boot.rs) and the version-pinned fork (checkpoint.rs:1013) each call the attaches. LaunchRequest is not the CLI's type (the CLI uses none of it).
  • Retained generations are kept on purpose. bind keeps a full generation (archive copy, overlay, verity, initramfs) with no automatic deletion, because backends cannot prove stop. A new snapshot must be that generation, never a second copy.
  • No C ABI exposure of the functions this changes; the ABI exposes data types only (RuntimeReleaseProof, RuntimeLaunchBinding, runtime_overlay_version). mvmd and mvm-studio (two weeks stale) reference none of them. xtask check-test-home-isolation lists attach_runtime_overlay and attach_universal_initramfs as prefix anchors and must be updated with any rename.

3. Design

3.1 Principle

Verify the whole runtime set once per launch, per process, as one verification; every consumer in that process uses that one result. Nothing is verified independently by each consumer, and nothing is reused across processes or launches in this change.

3.2 One verification and one typed result

One function verifies together: the release proof (archive bytes, checksum entry, archive and checksum signatures, accepted identity and issuer for the version, version and architecture); the declaration and protocol compatibility; and the selected artifacts against the declaration (overlay and verity digests and root hash, initramfs digest). It returns VerifiedRuntimeSet, which:

  • has a private constructor, implements no Serialize, Deserialize or Default, and cannot be rebuilt from parts;
  • carries the verified archive digest, declaration, signer identity, and the verified archive snapshot (the existing VerifiedRuntimeManifest), and when the launch is bound is the retained generation, not a copy of it;
  • is held as an explicit Arc and passed beside VmStartConfig (precedent: PreparedBuiltPackRuntime is returned as _built_runtime in ResolvedLaunch); it is never inside VmStartConfig (that type is cloned and constructed in about 195 files), never thread-local, never process-global.

The existing VerifiedLaunchRuntime enum (release, source, legacy) is extended, not duplicated: the release variant becomes the set.

3.3 Who mints it and who consumes it

  • Minted once at the front of each assembler (exec.rs::resolve_launch, hostd/run.rs, persistent.rs, entrypoint/boot.rs, checkpoint.rs:1013) through the one verifier.
  • Consumed by: overlay attach and initramfs attach (laps 1 to 3 disappear), admission (laps 4 to 6 become uses of the set), and bind, which uses the set's archive snapshot instead of verifying again. bind keeps its artifact snapshot and hashing against the declaration; that is the custody and does not repeat the signature work.
  • Unchanged: the digest pin between admission and bind; the built registry pack's dispatch-time recheck (registry_pack.rs:38) stays as a stated requirement and still emits its audit failure entry; wasm and non-kernel backends still return early with no verification.

3.4 Assurance binding (decision needed)

Laps 5 and 6 (and an uncached sha256_file of every selected file) run for every release launch for the sake of a future assurance campaign. Threading the set alone still leaves that eager hashing. Decide: make the assurance binding lazy (computed only when a campaign is requested), or keep it and have it share the set. Recommendation: lazy, because an ordinary launch should not pay for it; the "cannot later be promoted into a campaign" property is then enforced when a campaign is requested.

3.5 Retained verification (continuity, restore, fork, warm claim)

These verify a different runtime: the one a checkpoint or standby parent was made with, possibly another CLI version. They cannot take the launch's set. They go through the same verifier via a second entry, verify_retained(binding), once per operation. Open and to be specified before code: how a warm claim (which has no bind; today verify_checkpoint_runtime plus verify_runtime_for_claim, an INFERENCE of 9 or more verifications) verifies the parent's retained generation once, and where the proof is stored.

3.6 Audit evidence (mandatory)

Signed, chain-linked audit records are a core property. Add a serializable RuntimeIdentity (archive digest, version, architecture, declaration digests, signer identity and issuer) to the signed ExecutionPlan (home: EnvironmentRef, #[serde(default, skip_serializing_if = "Option::is_none")], so old fixtures stay byte-identical; no schema-version ceremony per repo policy, no backcompat; update the 46 plan literals) and emit it as labels on plan.admitted, durable before the command is released. Admission checks that the plan's RuntimeIdentity equals the set's (a comparison, not a repeat of the signature work). Tests: tampering with the evidence breaks verify_audit_chain; every launch that used a release runtime has an entry naming the exact set verified. Nothing makes an audit write asynchronous. Update the claim-20 row (and claim 3 where the root hash is named) and its witnesses; check-claim-catalog and check-witness-citations apply.

3.7 Cross-host (#5124)

RuntimeIdentity is plain data that can sit in a launch request, plan or audit record and be compared by a coordinator. VerifiedRuntimeSet is never serialized or sent: each host verifies for itself and checks the result against the identity it was sent. A coordinator cannot hand a host "verified".

3.8 Boundaries and rules

  • Measured boundary. The verification stays inside the measured launch window (invocation to guest ready, admission included). It must never be hoisted to bootstrap or any step outside the window to meet a budget.
  • Errors are a contract. One typed RuntimeVerificationError with a variant per failing component (archive digest, checksum, archive signature, checksum signature, release identity, version or architecture, declaration, protocol, selected-artifact mismatch). Existing stable codes and messages are kept; a golden test pins each.
  • No compatibility shims. No embedder is in flight; public signatures change freely and old functions are deleted after migration.

3.9 Threat model

In scope: a tampered release artifact; a mismatch between what is checked and what is used within one launch; corrupt, interrupted or concurrently refreshed cache writes. Out of scope, as in ADR-001 and runtime_evidence.rs: a malicious or same-user host account. The guest's dm-verity still checks the overlay root hash at boot.

4. Not in this change

  • No cross-process or persisted verification record (section 7). No change to accepted identities, versions or architectures, the signature or checksum code, the source-build runtime semantics, the legacy runtimes (legacy_portable_runtime.rs, legacy_bundle_runtime.rs), builder VM and Stage 0 (they do not use this machinery), or any budget.
  • The single launch entry point with an enum source (fresh, bundle, restore, fork, warm claim) is a separate follow-up. LaunchRequest is not the CLI's type and there are at least five assemblers, so unifying them is its own refactor and must not block the launch-time win.

5. Tests (each fails before the change, passes after)

  • Count: one verification per process per launch on the CLI path, using a test-only counter (so it does not depend on tracing) and the perf(trace): span the runtime-proof verification, the lifecycle bind and its flushes #5506/perf(hvf): record where driver_boot and attach_overlay spend their time (#4839) #5508 span count as a second witness; the library and persistent paths measured separately.
  • Refusals unchanged: tampered archive; wrong version or architecture; wrong identity; checksum mismatch; missing signature; declaration or protocol incompatibility; selected artifact differing from the declaration; each with its golden error.
  • Check equals use (non-malicious race): a cache file refreshed after verification does not change what this launch boots (it boots the retained generation); the next launch verifies again. This test does not claim to stop a malicious same-user process.
  • No leakage: a set from one launch cannot be used by another; concurrent launches in one process each get their own; a consumer cannot construct one (visibility test); no consumer accepts a runtime path where a set is required.
  • Retained verification: restore, fork and warm claim verify the retained runtime once and refuse drift (existing tests stay green).
  • Audit: section 3.6 tests; the registry-pack dispatch audit failure still fires.
  • wasm and non-kernel backends unchanged.

6. Acceptance

  • Release-proof verification count is 1 per process on the CLI path on the idle Firecracker VM and the macOS HVF path, measured with the perf(hvf): record where driver_boot and attach_overlay spend their time (#4839) #5508 spans; counts for the library, persistent and warm-claim paths recorded.
  • Launch time drops by about 4 s on a signed release (about 5.6 s to about 1.5 s on the GCP VM), before and after on the same host and command. This is an estimate until measured.
  • Claim-20 (and claim-3) rows and witnesses updated; fmt, clippy -D warnings, full nextest of every touched crate, just check::gated, check-rust-footprint, check-file-size, check-test-home-isolation pass. No budget or verification is loosened.

7. After this change: the 640 ms and a cache

One verification at about 640 ms still misses the 300 ms cold budget. Next: measure what the 640 ms consists of (read and hash, signature verification, temp-file copy, parse; the inner split is being built on #5506) and fix the cheap parts. Only then decide on a cross-process record. Because verification is offline and deterministic, a record keyed on the archive digest, the trust-root version and the accepted-identity set would be as safe as the existing sealed digest sidecar, but it is a cached authorization under AGENTS.md and needs its own decision and a claim-20 note; its key must include the trust-root version, and any revocation epoch introduced by #5124.

8. Plan

  1. Measure per-process attribution and the other paths: add a process id to the spans, record counts for the library path (LocalBackend), persistent start and warm claim, and check whether sha256_file_verified hits on the first launch after install.
  2. Design review of this issue by the claim-20 owner (decisions: 3.4 lazy assurance, 3.5 warm-claim shape, 3.6 plan field).
  3. Implement the verifier and VerifiedRuntimeSet, then migrate the assemblers and consumers one per PR where it stays reviewable, deleting the old functions.
  4. Audit evidence and the claim note in the same series.
  5. Measure and post before and after here, on HVF on a developer Mac: a launch spends 2 to 4 s in admission, overlay attach, initramfs attach and VMM creation before the guest starts (warm and cold) #5487 and HVF warm claims take ~3.2 s on the macOS CI runner, so every warm launch is refused #4391.

9. Open questions

  • The HVF resident-handoff path (cold_hvf_channel) was not traced.
  • How a standby parent stores the proof for later claims (3.5).
  • Whether lazy assurance binding is acceptable to the assurance owner.
  • Per-process attribution of the laps (all appear to be the mvmctl process; not yet tagged).

10. Coordination

11. For whoever picks this up

Read AGENTS.md, CLAUDE.md and .agents/skills/secure-execution-review/SKILL.md first. Work in a new git worktree from origin/main. Open pull requests with Refs or See and never a closing keyword. Do not queue or merge a pull request without the maintainer's explicit go-ahead. Do not loosen a check or a budget to pass a gate.

Refs #4839 (the cleanup umbrella; this issue does not close it). See #4391, #5487, #5124.

Activity

  1. auser commented on Nov 15, 2026

    @auser
    CollaboratorAuthor

    Answer to step 1 (which verifications run where), from the idle GCP VM runs; the mapping is derived from span nesting and phase arithmetic, not traced per process.

    Same process or not. All seven verify_release_archive calls appear in one span table, the one written by the launching mvmctl process (MVM_SPAN_TIMINGS_OUT), and the phase timing totals add up inside that process (arithmetic below). A system-call trace (strace -f) of a one-command launch showed only two child processes, both started at the very end of backend start (the VMM and the per-VM endpoint), and no outbound connection. So on a one-command mvmctl run of a signed release, all seven run in the mvmctl process: there is no separate admission daemon in that path. What I did not do is tag each lap with its PID, so "same process" is established by absence from any other process's report, not by a PID on each lap. For a launch through the library (mvm-client, mvm-hostlib) or a persistent host daemon the answer may differ and I have not measured it.

    Which caller each one is (each is about 640 ms; five cold launches agreed to within 1%):

    # where span / lap what the arithmetic says
    1 inside admit_plan_for_run, overlay attach attach_overlay.release_proof_lookup (659 ms), via verify_selected_runtime (1 call, 640 ms) the lookup of the cached proof re-verifies it
    2 inside admit_plan_for_run, overlay attach attach_overlay.release_proof_verify (648 ms), verify_runtime_release_proof acquire_runtime_overlay_for_launch = 1.30 s = #1 + #2
    3 inside admit_plan_for_run, initramfs attach attach_initramfs.release_proof_verify (638 ms) attach_universal_initramfs_if_cached = 648 ms
    4, 5 admit phase, outside admit_plan_for_run verify_assurance_guest_protocol (2 calls, 1.28 s), each reaching verify_runtime_for_launch_at assurance checks
    6 admit phase, outside admit_plan_for_run one more verify_runtime_for_launch_at (the 4 calls total 2.56 s) admission re-check
    7 backend start runtime_lifecycle.bind (966 ms) = one verify_runtime_for_launch_at + about 320 ms of snapshot copies and syncs (snapshot_file x4, sync_snapshot) lifecycle bind at dispatch

    The arithmetic that places them: the admit phase is about 4.2 s but the admit_plan_for_run span is 2.25 s, and 2.25 s = overlay 1.30 s + initramfs 0.65 s + about 0.32 s (grants_budget_and_host_interface). The remaining 1.95 s of the admit phase is three verifications (3 x 640 = 1.92 s), which are #4 to #6. The backend-start phase is about 1.3 s = driver_boot about 0.3 s + runtime_lifecycle.bind 0.97 s, which is #7. Counts: verify_release_archive 7 = verify_runtime_release_proof 6 (overlay 1, initramfs 1, verify_runtime_for_launch_at 4) + verify_selected_runtime 1. So: 3 inside admit_plan_for_run, 3 elsewhere in the admit phase, 1 in backend start.

    Where I am unsure: the split of the four verify_runtime_for_launch_at calls between admission and dispatch (I place three in admit and one in the bind; the arithmetic supports it but I did not name each call site), and whether #4 and #5 are two distinct assurance checks or one check called twice. The spans from #5506 name verify_assurance_guest_protocol and runtime_lifecycle.bind but not their callers; adding the caller as a span field, and the PID as a field on every lap, would settle both in one run.

    Inner split of one verification (from #5506's spans): verify_guest_bins_archive own time 422 ms (66%), read_and_digest_archive 107 ms, the two signature checks 105 ms, write_archive_snapshot 8 ms. Full tables are in #5487 and in ADR-112 (PR #5514).

  2. auser commented on Nov 15, 2026

    @auser
    CollaboratorAuthor

    Not started by me; findings from reading the code that should save the implementer time. I looked at the call graph before stopping (Ari redirected me to the demo), and made no code changes.

    • Every one of the seven verifications funnels through evidence::verify_release_archive (crates/mvm-build/src/guest_runtime/evidence.rs); verify_runtime_release_proof and cached_runtime_release_proof (guest_runtime.rs) call it.
    • The per-launch caller that matters most is mvm_runtime::runtime_evidence::verify_runtime_for_launch(config, minimum_protocol) (crates/mvm-runtime/src/runtime_evidence.rs): it verifies whatever config.runtime_release_proof claims, and it is called from crates/mvm-client/src/launch/{runtime_source,bundle_runtime}.rs, crates/mvm-hostd/src/{run.rs,operator_admitted_trial_booter.rs,plan_admission/assurance_runtime.rs} and crates/mvm-cli/src/commands/vm/checkpoint/fork_vm_full.rs. The overlay attach (launch/runtime_overlay.rs) and the initramfs attach (mvm-runtime/src/universal_initramfs.rs) verify directly.
    • Layering constraint for the launch-scoped result: the per-launch object that already reaches all of those is VmStartConfig, which lives in mvm-core. VerifiedRuntimeManifest lives in mvm-build, which is higher in the graph, so a field on VmStartConfig cannot name it directly (it would need an opaque handle, or the type has to move down).
    • Reuse hazard: VmStartConfig is cloned widely (config.clone() and ..config.clone() in the launch and hostd paths, and it is built in about 195 files), and fork_vm_full.rs verifies an inherited config for a child launch. A result stored in the config and shared by clones could leak into a second launch from the same template, which is exactly what this design forbids. Any cell on the config needs a launch identity, or the launch builder has to create a fresh one at every launch entry point, including forks.
    • The explicit-threading option in the design (a VerifiedRuntimeSet passed from the launch builder) avoids that hazard at the cost of about ten signatures; I would take it.
  3. auser commented on Nov 15, 2026

    @auser
    CollaboratorAuthor

    Design v2 posted (edited into the issue body). What changed from the first draft, from a read-only archaeology of every call site: all seven verifications run in the one mvmctl process (mvm-hostd is a library, not a daemon), so one shared result is feasible; two of the seven are an eager assurance-campaign pre-computation, not launch needs; no call site was added to close a TOCTOU window (the lifecycle bind is the custody point and stays); the threat model excludes a same-user attacker, so the draft's wording and one test were wrong; the claim is 20 (and 3), not row 9; the audit chain does not record the runtime today, so RuntimeIdentity goes into the signed plan; warm claim, restore and fork verify a different runtime and need a second entry; and a snapshot must be the existing retained generation, not a copy.

  4. auser commented on Nov 15, 2026

    @auser
    CollaboratorAuthor

    The single launch entry point (the follow-up named in the section on the entry point) now has its own design issue: #5520. It is sequenced after this verification series, since both change the same launch assemblers.

  5. auser commented on Nov 15, 2026

    @auser
    CollaboratorAuthor

    Implementation coordination: an isolated feat/5515-runtime-set worktree has been prepared from origin/main at 4c48ce2a9f3c15970ca93910d255e3e927a66b97. The intended design for owner review is #5515 v2 with these clarifications: (1) a launch-scoped, privately constructed whole-set verification travels explicitly to attach/admission/bind; verified archive bytes are the authority for that launch, bind retains and rehashes the selected generation, and the admission-to-bind digest pin and built-pack dispatch recheck stay; a subsequent launch re-verifies changed cache bytes; (2) restore, fork and warm claim separately verify their own retained generation, with the standby parent's proof owned by its lifecycle binding, never substituted with a fresh child launch's result; (3) ordinary launch checks required protocol compatibility, while assurance-campaign binding is computed only on campaign request; (4) RuntimeIdentity is signed in the plan, compared at admission, and included in durable chain-signed admission evidence before workload authority. ADR-112's Proposed conditions 3 and tests 2–3 that demand re-verification of changed mutable paths within the same launch conflict with snapshot-authoritative #5515 v2 and need explicit reconciliation in the implementation/ADR amendment. This comment records the proposed choices and remaining review, not claim-owner or assurance approval. No security claim is promoted or acceptance measurement asserted here; no VM/HVF benchmarks are authorized.

  6. auser commented on Nov 15, 2026

    @auser
    CollaboratorAuthor

    Design decision update from the maintainer: use an optional, skip-serialized top-level ExecutionPlan.runtime_identity, not a field of EnvironmentRef. A checkpoint fork resumes an existing VM with no new kernel path, so its plan must be able to name the verified retained runtime without inventing a kernel pin. The implementation direction remains one launch-scoped whole-set verification passed explicitly to attachment, admission and lifecycle custody; the digest pin and selected-artifact hashing at bind remain; warm claim, restore and fork authenticate their retained generation; campaign-only assurance binding is lazy; plan.admitted names the signed runtime identity and must be durable before workload authority. ADR-112's same-launch mutable-path reverify conditions are reconciled in favor of the immutable verified snapshot, with a later launch verifying its own selection. This records the chosen design, not a shipped claim or a live performance witness. No VM/HVF benchmark has been run; the work is still being validated and is not ready to merge.

  7. auser commented on Nov 15, 2026

    @auser
    CollaboratorAuthor

    Implementation is ready for review in #5557. The branch is rebased on current main; serial workspace tests and touched-crate nextest passed (14,304 passed, 49 skipped), as did workspace check, Clippy, gated build, format and conformance/witness checks. The published signed v0.28.0-rc.2 verifier fixture passed before final rebase. Live Firecracker/HVF launches, span-count and latency measurements have not been run, so the hardware budget remains unverified. Keeping this issue open pending review and those measurements.

  8. auser commented on Nov 15, 2026

    @auser
    CollaboratorAuthor

    CI (main) went red on the #5557 merge commit (7eb0157): the Test eBPF telemetry load/attach lane fails one test, plan_admission::assurance_runtime::tests::campaign_binding_checks_selected_bytes_and_vm_before_promotion (crates/mvm-hostd/src/plan_admission/assurance_runtime.rs:222), with verifying assurance guest runtime: bundle verification failed: trust store has no entry for key_id f993bf26…. The same test passes in the other lanes (Test workspace doctests and feature suites, Test workspace aarch64, Test Linux and conformance), so it looks environment-dependent: that lane's hostd test run has a trust store without the fixture key. Run: https://github.com/tinylabscom/mvm/actions/runs/43719832408. Not investigated further from here; the Test (main) aggregate is red because of this one lane, which blocks a clean release candidate.

  9. auser commented on Nov 15, 2026

    @auser
    CollaboratorAuthor

    Live #5515 follow-up on m1-runner (macOS 27.0.1, Apple Silicon/HVF), 2026-11-15:

    • The published v0.28.0-rc.5 tag points to 7fe252a5, before feat(runtime): retain verified release runtime evidence per launch #5557 merged at 7eb01574. I compared its published optimized CLI with an optimized --features release-channel build of exact merge commit 7eb015747545051fb5e26ae2c6d5fa4c86e4de00, ad-hoc signed for macOS execution. The latter used a supervisor built from the same commit and the genuine published signed rc.5 guest-runtime quartet. These are different distribution artifacts, not a claim that the published rc.5 executable includes Verify the signed release runtime once per launch, as one verification of the whole runtime set (design for approval) #5515.
    • Both arms used isolated MVM_HOME, the same alpine:3.21 OCI workload, MVM_RESIDENCY=cold, --hypervisor hvf, --no-detect, /bin/true, a prepared cache, and MVM_SPAN_TIMINGS=json. Two warm-ups preceded 20 successful cold launches per arm. Every measured launch had image_pull=false, image_build=false, and mount_materialize=false.
    • Before: verify_release_archive was 7 calls on every one of 20 launches; total p50 2,291.5 ms, p95 2,401.4 ms. Admission p50 1,537.0 ms; backend-start p50 584.8 ms.
    • After: verify_release_archive was 1 call on every one of 20 launches; total p50 722.6 ms, p95 835.8 ms. Admission p50 232.0 ms; backend-start p50 334.2 ms. Median improvement on this runner is 1,568.9 ms (~68%). This does not meet the 300 ms cold-launch gate; this change alone was not expected to do so.
    • One command from an empty state, with no mvmctl bootstrap, did boot successfully using the merged release-channel build in a packaged layout. It automatically prepared/acquired artifacts (image_pull=true) but took 7.14 s wall time. Its in-launch total_ms=770.3 excludes most first-use preparation; startup_ms=5,725.5 includes more of it. Do not present the prepared-cache numbers as first-use single-command latency.
    • The isolated live audit's plan.admitted entries carried archive, version, arch, verified signer identity/issuer, and declared/selected overlay, verity, root-hash, and initramfs labels. This is an observation of the emitted fields, not a separate cryptographic audit-chain verification.
    • mvmctl bench --lane prepared-cold refused the warm-up: it forbids artifact_hash, whereas the merged security path hashes 1,341,266 selected-artifact bytes per prepared launch. I did not loosen the gate; the statistics above are computed from 20 direct schema-v4 launch samples and 20 span reports, not an accepted official benchmark report. This lane mismatch needs a separately reviewed measurement definition.
    • Linux/Firecracker was not measured: on the amd64 runner root is refused by policy, and the existing actions-runner account has no running systemd user bus. No running VM was left by the successful transient M1 launches. Raw samples and span reports remain under /tmp/mvm5515/{tag-baseline,release-measure} on m1-runner until that machine clears /tmp.

    #5515 should remain open for the unmet cold latency target, first-use speed, and any required Linux confirmation; the one-per-launch verification count is now evidenced on a real HVF launch.

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

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions