diff --git a/docs/AGENTIC-HARDENING.md b/docs/AGENTIC-HARDENING.md new file mode 100644 index 0000000..c7437f0 --- /dev/null +++ b/docs/AGENTIC-HARDENING.md @@ -0,0 +1,104 @@ +# Agentic boundary hardening — 2026-10-12 + +The implementation review identified seven concrete gaps. All seven have code +changes and regression coverage. Native package and sandbox acceptance passed on an installed-system overlay; +a fresh installer run remains pending. This is not a new ISO release. + +| Gap | Implemented change | Evidence | +| --- | --- | --- | +| Raw OpenCode provider credentials entered logs before catalog parsing | Sensitive output suppresses both streaming sinks, logged bodies and attached command failure bodies; curl ignores user configuration | Unknown synthetic provider credential tested on success and failure; real HTTP fixture suite | +| Investigation evidence could carry registered secrets and service journals/argv | Shared evidence boundary redacts, removes private-path lines and bounds UTF-8 output; service evidence uses only enumerated state properties | Registered service token absent from the second scripted model request | +| Approval digest omitted execution context | Versioned envelope binds id, kind, creation/expiry, root, uid, privilege, source, application, full candidate and material effects; lifetime limited to 900 seconds | Context substitutions and expiry extensions refused after resealing, including recomputed digests against retained approvals | +| Developer jail exposed home and could unmask credentials | Synthetic home, clean environment, private PID/IPC/UTS namespaces, no capabilities, only a selected writable workspace; mask overlaps refused; workspace bound by an open descriptor | Real Bubblewrap denied synthetic private files, environment, host processes and offline network; a post-review workspace symlink swap still bound the original workspace | +| Target writes checked paths and later reopened them | Root and parent descriptors, no-follow component traversal, atomic temporary-file replacement and descriptor chmod; root symlinks refused, hardlinks cannot receive writes | Root replacement, hardlink and concurrent atomic directory/symlink exchange tests | +| Installation verification only proved presence | Portage exact atom/version with explicit source/binary mode; Flatpak ref/commit, Snap revision/version/channel, Nix active-profile store path, AppImage bytes/version checks | Wrong Portage identity/version and wrong Flatpak commit refused; mocked install success/failure transactions remain truthful | +| PID-based per-action locking raced and allowed plan interleaving | Persistent inode plus kernel flock; transaction-wide reentrant ownership through revalidation, execution, verification and outcome recording | Competing acquisition, nested guard lifetime, other-thread exclusion, killed-process recovery, and a worker lease that survives broker death | + +## Additional enforced limits + +The process runner drains stdout/stderr concurrently with nonblocking stdin, +limits capture per stream (16 MiB by default), bounds log emission, and applies +wall-clock deadlines. Streaming builds retain a bounded tail. Oversized query +responses fail. Provider limits/deadlines also apply to sandboxed calls, and the +systemd manager receives RuntimeMaxSec so the actual service worker is bounded. +Model units have MemoryMax=256M and TasksMax=64. Commands issued under a mutation +hold inherit a duplicate lock descriptor; broker death cannot release exclusion +while an inheriting worker still runs. A real-process crash regression proves +that ownership passes to the worker and ends when it exits. Long build commands +retain a 24-hour default; common catalogue, candidate and verification reads use 120 +seconds. Service evidence uses 30 seconds and 64 KiB. + +Actual negative testing exposed a further gap: the original systemd user unit +could read a synthetic file beneath home. The unprivileged model path now uses +explicit Bubblewrap filesystem/PID isolation inside the transient user unit. +Systemd retains process/syscall/address-family restrictions. Its user-manager +filesystem properties were removed because they implied a namespace that +prevented Bubblewrap creating its jail. Root model calls retain the hardened +DynamicUser system-unit path. Missing tools or namespace failures stop the +request; there is no unconfined fallback. Effective uid is read from the kernel, +and developer home comes from the account database, rather than PATH or HOME. + +## Artifact semantics + +Flatpak does not support an install --commit option. The reviewed flow downloads +without deployment, uses OSTree's native REF@COMMIT pull with the configured +remote's signature policy, then deploys with Flatpak --no-pull and checks the +active commit. Phoebus now installs dev-util/ostree with its Flatpak lane. +Snap installs with --revision. Nix evaluates from an immutable path flake and +verifies its active store path. These pins bind the selected application; +backend-managed runtime/dependency closures are not claimed to be completely +content-pinned. Portage exact-version selection is not an immutable repository +snapshot. Portage, Flatpak and Nix were exercised in a disposable installed-system VM; +native Snap revision acceptance remains pending. + +Primary command references: +[Flatpak](https://docs.flatpak.org/en/latest/flatpak-command-reference.html), +[OSTree pull](https://ostreedev.github.io/ostree/man/ostree-pull.html), +[Snap revisions](https://snapcraft.io/docs/revisions), +[Nix profile install](https://nix.dev/manual/nix/2.18/command-ref/new-cli/nix3-profile-install.html), +[Portage emerge](https://dev.gentoo.org/~zmedico/portage/doc/man/emerge.1.html). + +## Verification and remaining acceptance + +Real host denial tests are intentionally ignored by the portable suite and run +explicitly with: + +```sh +cd installer-rs +cargo test -p phoebus-executor --test isolation_acceptance -- --ignored --skip model_system_unit +# The system-manager probe is run separately as root only in the disposable VM. +``` + +Both user probes passed on the development host. The system-manager probe +also passed as root in the disposable Gentoo VM. They use only synthetic fixture files, +never account credentials. Their fixtures are deleted at test completion. +Portable gates pass: 981 Rust tests, 22 VM-harness safety tests, strict Clippy, +fmt, repository checks and staged secret scan. Dynamic and static release +builds passed. No physical disk was touched. + +The native run `serial-boot-20261012T105530Z-9c09094e` passed all 14 driver cases: +detached generic boot/login, running systemd, developer/user/root isolation, +deterministic history, descriptor-backed Btrfs snapshot, exact Portage install +and removal, persistent lock permissions, Flatpak commit install and removal, +Nix active store-path install, and clean poweroff. It used a separate qcow2 +backing overlay; the source-build base image and local ISO are unchanged. +Two preceding attempts exposed fixture errors (password mapping and the KVM +virtualization identifier); neither is claimed as a product acceptance pass. + +Initially doctor found 6 GiB free. Compiler-cache cleanup restored sufficient +space and host doctor passed with a tight-space warning. A fresh installation +was not repeated. Native pins/isolation/snapshot behavior were exercised on the +installed Gentoo overlay. The subsequent lock-lease addition has its own real +crash-process regression. Final static binary smoke +`serial-boot-20261012T112454Z-47d3cfae` passed 8/8 with clean poweroff, +repeating sandbox denials and executing history and a Btrfs snapshot in an +explicitly network-free namespace. Its SHA-256 was +`1ea91f6f0ac82d88e9a8c400f510819aefaf73251778b248ef2443fdf18e2b62`. + +Remaining acceptance: a fresh encrypted installation with descriptor I/O; native +Snap revision installation and adversarial metadata drift across the lanes; +interrupted native package-worker recovery and broader network-free repair/undo +acceptance beyond the verified history/snapshot commands. Older staged approvals +must be reviewed again because the envelope digest has changed. Developer +tools/auth state outside the selected workspace are intentionally hidden; narrowly scoped explicit grants are future +work, rather than silently exposing the whole home directory. diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 6423cc5..bfc04ef 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -133,8 +133,12 @@ The only crate that runs privileged commands. any logging. They never enter the config. - The AI cannot execute; it can only propose typed changes that the backend validates and the user approves. The assistant's model call additionally runs - inside an unprivileged, hardened `systemd-run` unit (`sandbox`), so the - boundary is enforced by the OS and not only by the schema. + inside a hardened `systemd-run` unit (`sandbox`); normal-user calls also + require an explicit Bubblewrap filesystem/PID jail. Both environment and + output are constrained. See ADR 0015 and `AGENTIC-HARDENING.md`. +- Approval binds a versioned execution envelope (id, kind, lifetime, root, + uid, privilege, source, application and full candidate) and material effects. + A persistent kernel lock covers the whole mutation transaction. - Approval is bound to the reviewed resolved plan: the reviewed per-step effects are carried into execution, package effects are resolved again only as evidence to compare against them, and a material change aborts. Privileged diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index 8c43656..aaaa2fd 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -5,6 +5,26 @@ this file is the curated, human-readable summary. ## Unreleased — Fast defaults with user-controlled source builds +- **Agentic boundary hardening (2026-10-12).** Addressed seven implementation + review findings: suppress credential-bearing transport logs/errors; minimize + model evidence; bind approvals to their execution context; restrict developer + workspace/home/environment/process visibility; anchor target I/O to descriptors; + pin and verify installed application identities; and serialize complete mutation + plans using a persistent kernel lock. Added process output/deadline bounds and + kernel uid lookup. Real host denial tests found and fixed ineffective user-unit + home protection by adding mandatory Bubblewrap isolation. Both host denial + probes pass. Gentoo overlay acceptance passed 14/14, including all three + denied-operation sandboxes, descriptor snapshot, Portage exact version, + Flatpak commit and Nix store-path installation. Native Snap/fresh installer + acceptance remains pending. Added an inherited command lock lease so a + surviving worker keeps exclusion after broker death; its real-process + regression passes. Final static VM smoke passed 8/8, including network-free + history/snapshot and repeated sandbox denials. All 981 Rust tests, 22 VM + harness tests, strict Clippy, fmt and dynamic/static builds pass. Host space + was restored through compiler-cache cleanup. See `AGENTIC-HARDENING.md` + and ADR 0015. Existing ISO and source-build acceptance were not replaced. + + - **Mozilla source-codec build fix (2026-10-08).** Firefox ESR 153.4.0 failed after 7852 seconds: libgkcodecs exported missing system-libaom symbols (Mozilla bug 2063808, fixed upstream in branch 156). diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 2b36a2d..cd028c7 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -3,6 +3,23 @@ Rolling note between work sessions. **Update this file before you finish**, then commit it. It should be short and current; use `git log` for detail. +- **Agentic hardening (2026-10-12):** All seven findings have fixes and + regressions; see `AGENTIC-HARDENING.md` / ADR 0015. Native Gentoo run + `serial-boot-20261012T105530Z-9c09094e` passed 14/14 with clean poweroff: + developer/user/root isolation, descriptor snapshot, Portage exact install/ + removal, Flatpak commit install/removal, Nix store-path verification and + persistent kernel lock. Two earlier runs had fixture errors and are not + product acceptance passes. A later command lock lease closes broker-death + exclusion loss; its real-process regression passes. Final static smoke + `serial-boot-20261012T112454Z-47d3cfae` passed 8/8, including + network-free history/snapshot and repeated sandbox denials. Gates passed: + 981 Rust tests, 22 harness safety tests, strict Clippy, fmt, secret scan, and + dynamic/static release builds. QEMU base image and ISO unchanged. + Initial space failure was resolved by generated compiler-cache cleanup. + Next acceptance: fresh installation, native Snap revision/drift, interrupted + native worker and broader offline repair/undo. Old staged approval digests require + fresh review. Preserve the sole source-build evidence image below. + - **Post-install acceptance in progress (2026-10-09 16:01 UTC):** Finish all five real application conversions/native windows and both source-kernel compile/install/boot/fallback tests, then deliver the updated local ISO, diff --git a/docs/STATUS.md b/docs/STATUS.md index 410ecd6..d281984 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -8,6 +8,30 @@ Truthful implementation/verification matrix. Vocabulary: - **Hardware verified** — exercised on real hardware. - **Not verified** — do not claim it works. +## Agentic hardening — 2026-10-12 + +- **Implemented and regression tested:** all seven findings and process bounds + described in [AGENTIC-HARDENING.md](AGENTIC-HARDENING.md), including approval + context, immutable application pins, privacy, descriptor I/O and whole-plan + kernel locking. Portage source/binary selections are enforced during execution. +- **Host verified:** real developer/user-model negative probes pass, including + a replaced workspace pathname. Earlier model reachability smoke tests did + not prove denied filesystem operations. +- **VM verified:** `serial-boot-20261012T105530Z-9c09094e`, PASS=14: generic boot, + three sandbox denial probes (developer, user model, DynamicUser system model), + deterministic history, descriptor snapshot, exact Portage install/removal, + persistent lock permissions, Flatpak commit install/removal, active Nix + store-path install, clean poweroff. The base image and ISO are unchanged. +- **Final static VM smoke:** `serial-boot-20261012T112454Z-47d3cfae`, PASS=8, + repeated sandbox denials and history/snapshot with networking explicitly + disabled, followed by clean poweroff. Final gates: 981 Rust tests, 22 VM + harness tests, strict Clippy, fmt, secret scan and dynamic/static release builds. +- **Remaining acceptance:** fresh installer run, native Snap revision/drift, + interrupted native worker recovery and broader offline repair/undo. + Backend dependency closures are not fully content-pinned. The later command + lock lease is covered by a real broker-kill/worker-lifetime regression. + Initial disk-space failure was resolved by generated compiler-cache cleanup. + ## Post-install source choices — acceptance in progress (2026-10-09) - **VM verified:** fresh encrypted installation and generic kernel boots; @@ -499,7 +523,7 @@ A fresh install with these defaults is not yet verified. | OpenCode transport parity (sandbox + network endpoint) | yes | yes (`CurlHttpClient::sandboxed` inlines the body under `PrivateTmp`; `--opencode-insecure-http` opt-in for remote plain http; endpoint-policy test) | yes (`serial-boot-20260929T114319Z-c43c2a92`: real host agent, OpenCode sandboxed by default, driver PASS=8) | n/a | | Read-only host-root probes never block on a prompt | yes | yes (`CommandSpec::detached` runs host-root Flatpak in a new session via `setsid --wait`, no controlling terminal; field-preserving unit test) | yes (VM: real-agent `sys ask "search for firefox"` completed with zero auth prompts, `serial-boot-20260929T111941Z-2be30b89`) | n/a | | Privilege derived only from the process identity | yes | yes (an environment variable cannot forge uid 0; the removed `PHOEBUS_ALLOW_UNPRIVILEGED_EXEC` regression test) | no | n/a | -| AI OS sandbox (systemd hardened unit) | yes | yes (argv + sandboxed-send; system properties for root, user-manager subset for non-root) | yes (`serial-boot-20260929T092147Z-6f88907a`: `AI_ROOT_RC=0` system sandbox, `AI_USER_RC=0` `--user` sandbox; previously the user path hung on a polkit `manage-units` prompt) | no | +| AI OS sandbox (systemd + explicit user Bubblewrap jail) | yes | yes (argv, bounded sensitive transport, real host negative probes) | previous systemd reachability smoke only; changed isolation pending VM acceptance (`serial-boot-20260929T092147Z-6f88907a`: `AI_ROOT_RC=0` system sandbox, `AI_USER_RC=0` `--user` sandbox; previously the user path hung on a polkit `manage-units` prompt) | no | | Unprivileged read-only AI plan completes | yes | yes (transaction recording best-effort for non-root; mandatory for privileged mutations) | yes (`serial-boot-20260929T092147Z-6f88907a`: `AI_NOSANDBOX_RC=0` as `phoebus`) | n/a | | Installed assistant (`sys ask`) | yes | yes | yes (live call 2026-09-28: `sys ask "list installed packages"` via `--ai-backend opencode` to host `opencode serve` through a guest loopback tunnel, model `opencode-go/muse-spark-1.3-contributor`, valid Assistant Plan + approval digest, `AI_LIVE_RC=0`; the `show system status` phrasing elicits schema-noncompliant JSON from this model and is fail-closed rejected) | n/a | | Resolved package effects + approval binding (carried through execution) | yes | yes (empty vs unestablished; drift + prior-step allowance) | no | n/a | @@ -798,7 +822,10 @@ A fresh install with these defaults is not yet verified. includes bounded seat socket wait. Graphical desktop seat verification under headless wlroots is proven; graphical verification under a physical seat remains an open hardware gate. -- **AI sandbox** is implemented (`systemd-run` hardening properties) and is now +- **AI sandbox:** the 2026-10-12 user path now requires explicit Bubblewrap + containment plus systemd process restrictions. Real host denial probes pass; + the changed path requires Gentoo VM acceptance. Previous reachability evidence + below does not establish negative filesystem isolation. The earlier path was exercised in a disposable VM: the **system** sandbox (full property set) for a root caller and the **user** sandbox (`systemd-run --user`, with `DynamicUser`/`PrivateDevices`/`ProtectKernelModules` omitted because the user diff --git a/docs/SYS.md b/docs/SYS.md index 6f6afb4..775612a 100644 --- a/docs/SYS.md +++ b/docs/SYS.md @@ -580,7 +580,9 @@ inside the privileged broker (`sys --broker --execute-plan --plan-uid --approval-digest --root `). The broker: - **independently recomputes the canonical approval digest** from the exact - executable actions, candidate and reviewed material effects, and requires it + executable actions, full candidate and reviewed material effects, plus the + versioned execution envelope (id, kind, creation/expiry, root, initiating uid, + privilege, source and application), and requires it to equal both the digest stored in the plan and the independently supplied `--approval-digest`. Retaining an approved digest while swapping an action and resealing is therefore rejected for every plan kind (Install, LegacyInstall, @@ -589,7 +591,10 @@ inside the privileged broker (`sys --broker --execute-plan --plan-uid independently of the plan file, so a replacement plan under the same identifier is rejected even when it is resealed with a valid, self-consistent checksum; -- rejects expired, modified, malformed, wrong-root or wrong-uid plans; +- rejects expired, modified, malformed, wrong-root or wrong-uid plans and + approval lifetimes longer than 900 seconds; old staged plans require review; +- holds a persistent kernel flock across authoritative revalidation, all + mutations, verification and terminal recording; - derives the initiating identity from the authenticated caller context (`PKEXEC_UID`), treating `--plan-uid` as untrusted input; - revalidates the current package/removal state after authentication, and again diff --git a/docs/VM-BOOT-VERIFICATION.md b/docs/VM-BOOT-VERIFICATION.md index 0072cf9..4a2bf59 100644 --- a/docs/VM-BOOT-VERIFICATION.md +++ b/docs/VM-BOOT-VERIFICATION.md @@ -3,6 +3,28 @@ This records the first successful end-to-end install and boot of Phoebus OS against a disposable qcow2 disk. No physical disk was ever touched. +## 2026-10-12 Agentic hardening — native overlay acceptance + +Run `serial-boot-20261012T105530Z-9c09094e` passed 14/14 checks with clean +poweroff. A separate backing overlay booted the preserved installed Gentoo +image; neither the base image nor the existing ISO was changed. Verified real +developer/user/root sandbox denials, deterministic history, descriptor-backed +Btrfs snapshot, exact Portage install/removal, Flatpak commit install/removal, +active Nix store-path install and persistent kernel lock permissions. + +The static `sys` used for that run had SHA-256 +`1cf2f0346c3c517923c517bffb81a283eaa4da4972495170322ff587f4dbfb24`. +A subsequent worker-lock lease is covered by a real broker-kill regression; +final static smoke `serial-boot-20261012T112454Z-47d3cfae` passed 8/8 +with clean poweroff, repeated sandbox denials and history/snapshot in an +explicitly network-free namespace. The final binary SHA-256 was +`1ea91f6f0ac82d88e9a8c400f510819aefaf73251778b248ef2443fdf18e2b62`. Two earlier attempts were +fixture failures (separate login/LUKS password mapping, then KVM identifier); +they are not claimed as product acceptance. Fresh installation, native Snap +revision/drift and interrupted native package recovery remain pending. See +[AGENTIC-HARDENING.md](AGENTIC-HARDENING.md) and +[the guest fixture](../installer/tests/vm/agentic-hardening-guest.sh). + ## 2026-10-07/08 Installed post-install acceptance — ongoing Fresh encrypted Gentoo installation `serial-install-20261007T122805Z-da765f3d` diff --git a/docs/adr/0015-agent-execution-boundaries.md b/docs/adr/0015-agent-execution-boundaries.md new file mode 100644 index 0000000..173b461 --- /dev/null +++ b/docs/adr/0015-agent-execution-boundaries.md @@ -0,0 +1,40 @@ +# ADR 0015 — Explicit agent execution boundaries + +## Context + +Implementation review found that material-effect digests omitted execution +context, path checks preceded pathname I/O, and per-action PID locks did not +serialize a complete transaction. Real negative testing also found that the +systemd user model unit could read home files despite its configured properties. + +## Decision + +Bind independent approval to a versioned execution envelope. Hold a persistent +kernel flock through revalidation, mutation, verification and terminal recording. +Use descriptor-relative no-follow target I/O and atomic file replacement. Pin +application install identities with native backend mechanisms and verify the +installed identity. Keep model transport output out of logs and funnel evidence +through a minimized, redacted boundary. Bound process output and deadlines. + +Use an explicit Bubblewrap filesystem/PID boundary for unprivileged model calls +and developer agents. Developer workspace binds consume a pinned directory fd; +synthetic home and clean environment are defaults. Never fall back unconfined. +Systemd provides process/resource restrictions; root model calls use DynamicUser. + +## Consequences + +Old staged plans require fresh review. Bubblewrap is required for normal-user +model calls, and OSTree is shipped with Flatpak. Missing containment support +fails closed. Developer home tools and credential state need future explicit, +narrow grants. Backend dependency closures and repository snapshots are not +claimed fully immutable. Fresh installer and remaining native acceptance are +still required. + +See [implementation and evidence](../AGENTIC-HARDENING.md). + +## Status + +Accepted, 2026-10-12. Implemented and regression tested; host negative isolation +tests passed. Gentoo overlay acceptance passed 14/14 for sandbox denials, +descriptor snapshots and Portage/Flatpak/Nix pins. Fresh installation and native +Snap/drift/interrupted-worker acceptance remain pending. diff --git a/docs/adr/README.md b/docs/adr/README.md index 47050f7..16adcfc 100644 --- a/docs/adr/README.md +++ b/docs/adr/README.md @@ -20,4 +20,7 @@ and link it here. | [0012](0012-nvidia-driver-policy.md) | NVIDIA accelerated-driver policy and payload | Accepted | | [0013](0013-ai-first-installation.md) | AI-first package installation workflow | Accepted | +| [0014](0014-privileged-approval-ledger.md) | Privileged approval ledger | Accepted | +| [0015](0015-agent-execution-boundaries.md) | Explicit agent execution boundaries | Accepted | + Format: Context / Decision / Consequences / Status. diff --git a/installer-rs/Cargo.lock b/installer-rs/Cargo.lock index 3720937..cb5e717 100644 --- a/installer-rs/Cargo.lock +++ b/installer-rs/Cargo.lock @@ -495,6 +495,7 @@ dependencies = [ name = "phoebus-core" version = "0.1.0" dependencies = [ + "rustix 1.1.5", "serde", "serde_json", "sha2", @@ -511,6 +512,7 @@ dependencies = [ "phoebus-ai", "phoebus-core", "roxmltree", + "rustix 1.1.5", "serde", "serde_json", "sha2", diff --git a/installer-rs/Cargo.toml b/installer-rs/Cargo.toml index a0365e5..bef4dc0 100644 --- a/installer-rs/Cargo.toml +++ b/installer-rs/Cargo.toml @@ -21,6 +21,7 @@ clap = { version = "4", features = ["derive"] } thiserror = "2" zeroize = { version = "1", features = ["derive"] } tempfile = "3" +rustix = { version = "1.1", features = ["fs", "process"] } [profile.release] lto = "thin" diff --git a/installer-rs/crates/phoebus-ai/src/assistant.rs b/installer-rs/crates/phoebus-ai/src/assistant.rs index c642663..e61a8ff 100644 --- a/installer-rs/crates/phoebus-ai/src/assistant.rs +++ b/installer-rs/crates/phoebus-ai/src/assistant.rs @@ -453,7 +453,11 @@ pub fn run_assistant( } } if payload.len() > limits.max_evidence_bytes { - payload.truncate(limits.max_evidence_bytes); + let mut end = limits.max_evidence_bytes; + while !payload.is_char_boundary(end) { + end -= 1; + } + payload.truncate(end); payload.push_str("\n[evidence truncated]"); } if requested_count > requests.len() { diff --git a/installer-rs/crates/phoebus-core/Cargo.toml b/installer-rs/crates/phoebus-core/Cargo.toml index c923cce..d8bd67d 100644 --- a/installer-rs/crates/phoebus-core/Cargo.toml +++ b/installer-rs/crates/phoebus-core/Cargo.toml @@ -12,6 +12,7 @@ serde_json.workspace = true thiserror.workspace = true zeroize.workspace = true sha2 = "0.10" +rustix.workspace = true [dev-dependencies] tempfile.workspace = true diff --git a/installer-rs/crates/phoebus-core/src/secret.rs b/installer-rs/crates/phoebus-core/src/secret.rs index 44a2d69..327e23c 100644 --- a/installer-rs/crates/phoebus-core/src/secret.rs +++ b/installer-rs/crates/phoebus-core/src/secret.rs @@ -68,6 +68,7 @@ impl Redactor { // Avoid storing duplicates. if !values.iter().any(|v| v.expose() == secret.expose()) { values.push(secret.clone()); + values.sort_by_key(|value| std::cmp::Reverse(value.expose().len())); } } } @@ -79,7 +80,7 @@ impl Redactor { /// Replace every registered secret in `text` with ``. pub fn redact(&self, text: &str) -> String { let Ok(values) = self.inner.lock() else { - return text.to_string(); + return "[redaction unavailable]".to_string(); }; let mut out = text.to_string(); for secret in values.iter() { diff --git a/installer-rs/crates/phoebus-core/src/selection.rs b/installer-rs/crates/phoebus-core/src/selection.rs index b520b4c..ee7a987 100644 --- a/installer-rs/crates/phoebus-core/src/selection.rs +++ b/installer-rs/crates/phoebus-core/src/selection.rs @@ -381,6 +381,65 @@ impl Need { } /// One concrete, backend-resolved candidate. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "backend", rename_all = "kebab-case", deny_unknown_fields)] +pub enum InstallArtifact { + Flatpak { reference: String, commit: String }, + Snap { revision: String, channel: String }, + Nix { flake: String, store_path: String }, +} + +impl InstallArtifact { + pub fn validate(&self) -> bool { + let hash = |s: &str| { + s.len() == 64 + && s.bytes().all(|b| b.is_ascii_hexdigit()) + && s.bytes().any(|b| b != b'0') + }; + let store = |s: &str| { + s.strip_prefix("/nix/store/").is_some_and(|name| { + name.len() > 33 + && name.as_bytes()[32] == b'-' + && name.bytes().all(|b| { + b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'.' | b'+') + }) + }) + }; + match self { + Self::Flatpak { reference, commit } => { + let parts: Vec<_> = reference.split('/').collect(); + parts.len() == 4 + && parts[0] == "app" + && crate::action::valid_flatpak_app_id(parts[1]) + && parts[2..].iter().all(|p| { + !p.is_empty() + && p.bytes().all(|b| { + b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'.') + }) + }) + && hash(commit) + } + Self::Snap { revision, channel } => { + !revision.is_empty() + && revision.bytes().all(|b| b.is_ascii_digit()) + && !channel.is_empty() + && channel.bytes().all(|b| { + b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'/' | b'.') + }) + } + Self::Nix { flake, store_path } => { + flake + .strip_prefix("path:") + .and_then(|p| p.split_once('#')) + .is_some_and(|(path, attr)| { + store(path) && crate::action::valid_nix_attribute(attr) + }) + && store(store_path) + } + } + } +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub struct Candidate { pub backend: Backend, @@ -388,6 +447,10 @@ pub struct Candidate { /// attribute, installed AppImage id, or custom-ebuild atom). pub id: String, pub version: Option, + /// Immutable backend identity selected before human review. Missing pins + /// cannot be treated as exact artifact approval. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub artifact: Option, /// Where the artifact actually comes from (repo, URL, overlay). pub provenance: String, /// Whether provenance/integrity can be verified (signature or hash). @@ -424,6 +487,7 @@ impl Candidate { backend, id: id.into(), version: None, + artifact: None, provenance: provenance.into(), verified: false, available: true, diff --git a/installer-rs/crates/phoebus-core/src/target.rs b/installer-rs/crates/phoebus-core/src/target.rs index afbdb33..793b7d0 100644 --- a/installer-rs/crates/phoebus-core/src/target.rs +++ b/installer-rs/crates/phoebus-core/src/target.rs @@ -1,152 +1,301 @@ -//! The installation target root. -//! -//! Host-versus-target path bugs are treated as HIGH SEVERITY. `TargetRoot` -//! makes it impossible to accidentally write to the host through the normal -//! APIs: every path is relative, must not be absolute, must not contain `..`, -//! and is joined to the root. - -use std::path::{Component, Path, PathBuf}; +//! Descriptor-relative target I/O. Lexical paths are for display/commands only; +//! writes never reopen a previously checked pathname. Symlinks are refused in +//! the root and every component. Atomic replacement also avoids hardlink writes. use crate::error::{CoreError, Result}; +use rustix::fs::{self, AtFlags, Mode, OFlags}; +use std::fs::File; +use std::io::{Read, Write}; +use std::path::{Component, Path, PathBuf}; +use std::sync::atomic::{AtomicU64, Ordering}; +use std::sync::{Arc, OnceLock}; -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Debug, Clone)] pub struct TargetRoot { root: PathBuf, + anchor: Arc>, +} +impl PartialEq for TargetRoot { + fn eq(&self, other: &Self) -> bool { + self.root == other.root + } +} +impl Eq for TargetRoot {} + +fn io(path: &Path, err: rustix::io::Errno) -> CoreError { + CoreError::io(path, err.into()) +} + +/// Each directory is opened relative to the previous pinned descriptor. +fn descend(mut dir: File, path: &Path, create: bool) -> Result { + for component in path.components() { + match component { + Component::Normal(name) => { + if create { + match fs::mkdirat(&dir, name, Mode::from_bits_truncate(0o755)) { + Ok(()) | Err(rustix::io::Errno::EXIST) => {} + Err(e) => return Err(io(path, e)), + } + } + dir = fs::openat( + &dir, + name, + OFlags::RDONLY | OFlags::DIRECTORY | OFlags::NOFOLLOW | OFlags::CLOEXEC, + Mode::empty(), + ) + .map(File::from) + .map_err(|e| { + if e == rustix::io::Errno::NOTDIR || e == rustix::io::Errno::LOOP { + CoreError::Validation(format!( + "target directory is a symlink or non-directory: {}", + path.display() + )) + } else { + io(path, e) + } + })?; + } + Component::RootDir | Component::CurDir => {} + _ => { + return Err(CoreError::Validation( + "target path must not contain parent traversal".into(), + )) + } + } + } + Ok(dir) +} +fn open_root(root: &Path, create: bool) -> Result { + let base = if root.is_absolute() { + Path::new("/") + } else { + Path::new(".") + }; + let dir = fs::open( + base, + OFlags::RDONLY | OFlags::DIRECTORY | OFlags::NOFOLLOW | OFlags::CLOEXEC, + Mode::empty(), + ) + .map(File::from) + .map_err(|e| io(root, e))?; + descend(dir, root, create) } impl TargetRoot { pub fn new(root: impl Into) -> Self { - Self { root: root.into() } + let root = root.into(); + let anchor = OnceLock::new(); + if let Ok(dir) = open_root(&root, false) { + let _ = anchor.set(dir); + } + Self { + root, + anchor: Arc::new(anchor), + } } - pub fn path(&self) -> &Path { &self.root } - - /// Resolve a relative path beneath the target root. - /// - /// Rejects absolute paths, `..` traversal and `~`-style components. An - /// empty relative path resolves to the root itself. + fn root_handle(&self, create: bool) -> Result<&File> { + if self.anchor.get().is_none() { + let dir = open_root(&self.root, create)?; + let _ = self.anchor.set(dir); + } + self.anchor + .get() + .ok_or_else(|| CoreError::Validation("target root could not be anchored".into())) + } pub fn resolve(&self, relative: &str) -> Result { let rel = Path::new(relative.trim_start_matches('/')); - for component in rel.components() { - match component { - Component::ParentDir => { - return Err(CoreError::Validation(format!( - "target path must not contain `..`: {relative}" - ))); - } - Component::RootDir | Component::Prefix(_) => { - return Err(CoreError::Validation(format!( - "target path must be relative: {relative}" - ))); - } - _ => {} - } + if rel.components().any(|c| { + matches!( + c, + Component::ParentDir | Component::Prefix(_) | Component::RootDir + ) + }) { + return Err(CoreError::Validation(format!( + "target path must not contain parent traversal: {relative}" + ))); } Ok(self.root.join(rel)) } - - /// Shorthand for an absolute target path, e.g. `target.path_for("/etc/fstab")`. pub fn path_for(&self, absolute: &str) -> Result { self.resolve(absolute) } - - pub fn etc(&self, relative: &str) -> Result { - self.resolve(&format!("etc/{relative}")) + pub fn etc(&self, rel: &str) -> Result { + self.resolve(&format!("etc/{rel}")) } - - pub fn var(&self, relative: &str) -> Result { - self.resolve(&format!("var/{relative}")) + pub fn var(&self, rel: &str) -> Result { + self.resolve(&format!("var/{rel}")) } - - pub fn boot(&self, relative: &str) -> Result { - self.resolve(&format!("boot/{relative}")) + pub fn boot(&self, rel: &str) -> Result { + self.resolve(&format!("boot/{rel}")) } - - pub fn home(&self, relative: &str) -> Result { - self.resolve(&format!("home/{relative}")) + pub fn home(&self, rel: &str) -> Result { + self.resolve(&format!("home/{rel}")) } - - /// Refuse to traverse a symlink while writing beneath the target root. - /// - /// A freshly installed target is created by the installer, but a stage3 - /// archive (or a later, less careful writer) could leave a symlink whose - /// target lies outside the root. Following it would write to the host. The - /// write path therefore rejects symlinked components instead of resolving - /// them. - fn reject_symlink_components(&self, relative: &str) -> Result<()> { + fn directory(&self, relative: &str, create: bool) -> Result { + self.resolve(relative)?; + let root = self + .root_handle(create)? + .try_clone() + .map_err(|e| CoreError::io(&self.root, e))?; + descend(root, Path::new(relative.trim_start_matches('/')), create) + } + fn parent(&self, relative: &str, create: bool) -> Result<(File, std::ffi::OsString)> { + self.resolve(relative)?; let rel = Path::new(relative.trim_start_matches('/')); - let mut current = self.root.clone(); - for component in rel.components() { - if let Component::Normal(part) = component { - current.push(part); - if let Ok(meta) = std::fs::symlink_metadata(¤t) { - if meta.file_type().is_symlink() { - return Err(CoreError::Validation(format!( - "refusing to write through a symlink inside the target: {}", - current.display() - ))); - } - } - } - } - Ok(()) + let name = rel + .file_name() + .ok_or_else(|| CoreError::Validation("target file path is empty".into()))? + .to_os_string(); + let parent = rel.parent().unwrap_or(Path::new("")); + Ok((self.directory(&parent.to_string_lossy(), create)?, name)) + } + /// Pin an existing directory for descriptor-based consumers such as a jail. + pub fn open_directory(&self, relative: &str) -> Result { + self.directory(relative, false) } - pub fn ensure_dir(&self, relative: &str) -> Result { - self.reject_symlink_components(relative)?; - let path = self.resolve(relative)?; - std::fs::create_dir_all(&path).map_err(|e| CoreError::io(path.clone(), e))?; - Ok(path) + self.directory(relative, true)?; + self.resolve(relative) } - - /// Create a directory with an explicit mode (on Unix). pub fn ensure_dir_mode(&self, relative: &str, mode: u32) -> Result { - use std::os::unix::fs::PermissionsExt; - let path = self.ensure_dir(relative)?; - let perms = std::fs::Permissions::from_mode(mode); - std::fs::set_permissions(&path, perms).map_err(|e| CoreError::io(path.clone(), e))?; - Ok(path) + let dir = self.directory(relative, true)?; + fs::fchmod(&dir, Mode::from_bits_truncate(mode)).map_err(|e| io(&self.root, e))?; + self.resolve(relative) } - - pub fn write(&self, relative: &str, contents: impl AsRef<[u8]>) -> Result { - self.reject_symlink_components(relative)?; + fn write_mode(&self, relative: &str, bytes: &[u8], mode: Option) -> Result { let path = self.resolve(relative)?; - if let Some(parent) = path.parent() { - std::fs::create_dir_all(parent).map_err(|e| CoreError::io(parent.to_path_buf(), e))?; + let (parent, name) = self.parent(relative, true)?; + let existing = match fs::statat(&parent, &name, AtFlags::SYMLINK_NOFOLLOW) { + Ok(stat) => { + if fs::FileType::from_raw_mode(stat.st_mode) != fs::FileType::RegularFile { + return Err(CoreError::Validation(format!( + "target leaf is not a regular file: {}", + path.display() + ))); + } + Some((stat.st_mode & 0o777, stat.st_uid, stat.st_gid)) + } + Err(rustix::io::Errno::NOENT) => None, + Err(e) => return Err(io(&path, e)), + }; + static SEQ: AtomicU64 = AtomicU64::new(0); + let tmp = format!( + ".phoebus-write-{}-{}", + std::process::id(), + SEQ.fetch_add(1, Ordering::Relaxed) + ); + let mut file = fs::openat( + &parent, + &tmp, + OFlags::WRONLY | OFlags::CREATE | OFlags::EXCL | OFlags::NOFOLLOW | OFlags::CLOEXEC, + Mode::from_bits_truncate(0o600), + ) + .map(File::from) + .map_err(|e| io(&path, e))?; + let result = (|| { + file.write_all(bytes).map_err(|e| CoreError::io(&path, e))?; + if let Some((_, uid, gid)) = existing { + fs::fchown( + &file, + Some(rustix::process::Uid::from_raw(uid)), + Some(rustix::process::Gid::from_raw(gid)), + ) + .map_err(|e| io(&path, e))?; + } + fs::fchmod( + &file, + Mode::from_bits_truncate( + mode.or(existing.map(|(mode, _, _)| mode)).unwrap_or(0o644), + ), + ) + .map_err(|e| io(&path, e))?; + file.sync_all().map_err(|e| CoreError::io(&path, e))?; + fs::renameat(&parent, &tmp, &parent, &name).map_err(|e| io(&path, e))?; + parent.sync_all().map_err(|e| CoreError::io(&path, e))?; + Ok(path.clone()) + })(); + if result.is_err() { + let _ = fs::unlinkat(&parent, &tmp, AtFlags::empty()); } - std::fs::write(&path, contents).map_err(|e| CoreError::io(path.clone(), e))?; - Ok(path) + result + } + pub fn write(&self, relative: &str, contents: impl AsRef<[u8]>) -> Result { + self.write_mode(relative, contents.as_ref(), None) + } + /// Open a persistent lock inode. Never unlink it: kernel locking requires + /// every contender to refer to this same file, including after a crash. + pub fn open_lock_file(&self, relative: &str) -> Result { + let path = self.resolve(relative)?; + let (parent, name) = self.parent(relative, true)?; + let file = fs::openat( + &parent, + &name, + OFlags::RDWR | OFlags::CREATE | OFlags::NOFOLLOW | OFlags::CLOEXEC | OFlags::NONBLOCK, + Mode::from_bits_truncate(0o600), + ) + .map(File::from) + .map_err(|e| io(&path, e))?; + let meta = file.metadata().map_err(|e| CoreError::io(&path, e))?; + use std::os::unix::fs::MetadataExt; + if !meta.is_file() || meta.nlink() != 1 || meta.uid() != rustix::process::geteuid().as_raw() + { + return Err(CoreError::Validation( + "lock is not a private regular inode".into(), + )); + } + fs::fchmod(&file, Mode::from_bits_truncate(0o600)).map_err(|e| io(&path, e))?; + Ok(file) } - pub fn read_to_string(&self, relative: &str) -> Result { let path = self.resolve(relative)?; - std::fs::read_to_string(&path).map_err(|e| CoreError::io(path, e)) - } - - /// Remove a target file without following symlink components. - pub fn remove_file(&self, relative: &str) -> Result<()> { - self.reject_symlink_components(relative)?; - let path = self.resolve(relative)?; - std::fs::remove_file(&path).map_err(|e| CoreError::io(path, e)) - } - - pub fn copy_file(&self, relative: &str, src: &Path, mode: u32) -> Result { - use std::os::unix::fs::PermissionsExt; - self.reject_symlink_components(relative)?; - let path = self.resolve(relative)?; - if let Some(parent) = path.parent() { - std::fs::create_dir_all(parent).map_err(|e| CoreError::io(parent.to_path_buf(), e))?; + let (parent, name) = self.parent(relative, false)?; + let mut file = fs::openat( + &parent, + &name, + OFlags::RDONLY | OFlags::NOFOLLOW | OFlags::CLOEXEC | OFlags::NONBLOCK, + Mode::empty(), + ) + .map(File::from) + .map_err(|e| io(&path, e))?; + if !file + .metadata() + .map_err(|e| CoreError::io(&path, e))? + .is_file() + { + return Err(CoreError::Validation( + "target read is not a regular file".into(), + )); } - std::fs::copy(src, &path).map_err(|e| CoreError::io(path.clone(), e))?; - std::fs::set_permissions(&path, std::fs::Permissions::from_mode(mode)) - .map_err(|e| CoreError::io(path.clone(), e))?; - Ok(path) + let mut text = String::new(); + file.read_to_string(&mut text) + .map_err(|e| CoreError::io(&path, e))?; + Ok(text) + } + pub fn remove_file(&self, relative: &str) -> Result<()> { + let path = self.resolve(relative)?; + let (parent, name) = self.parent(relative, false)?; + let stat = + fs::statat(&parent, &name, AtFlags::SYMLINK_NOFOLLOW).map_err(|e| io(&path, e))?; + if fs::FileType::from_raw_mode(stat.st_mode) != fs::FileType::RegularFile { + return Err(CoreError::Validation( + "target removal is not a regular file".into(), + )); + } + fs::unlinkat(&parent, &name, AtFlags::empty()).map_err(|e| io(&path, e))?; + parent.sync_all().map_err(|e| CoreError::io(&path, e)) + } + pub fn copy_file(&self, relative: &str, src: &Path, mode: u32) -> Result { + let bytes = std::fs::read(src).map_err(|e| CoreError::io(src, e))?; + self.write_mode(relative, &bytes, Some(mode)) } - pub fn exists(&self, relative: &str) -> bool { - self.resolve(relative).map(|p| p.exists()).unwrap_or(false) + self.parent(relative, false) + .ok() + .and_then(|(parent, name)| fs::statat(&parent, name, AtFlags::SYMLINK_NOFOLLOW).ok()) + .is_some() } } @@ -239,4 +388,77 @@ mod tests { "original" ); } + #[test] + fn root_symlinks_are_refused_and_replaced_roots_stay_anchored() { + let dir = tempfile::tempdir().unwrap(); + let outside = tempfile::tempdir().unwrap(); + let root = dir.path().join("root"); + std::os::unix::fs::symlink(outside.path(), &root).unwrap(); + assert!(TargetRoot::new(&root).write("escape", "x").is_err()); + std::fs::remove_file(&root).unwrap(); + std::fs::create_dir(&root).unwrap(); + let target = TargetRoot::new(&root); + let moved = dir.path().join("original"); + std::fs::rename(&root, &moved).unwrap(); + std::os::unix::fs::symlink(outside.path(), &root).unwrap(); + target.write("anchored", "safe").unwrap(); + assert_eq!( + std::fs::read_to_string(moved.join("anchored")).unwrap(), + "safe" + ); + assert!(!outside.path().join("anchored").exists()); + } + + #[test] + fn atomic_replacement_never_writes_a_hardlink_target() { + let dir = tempfile::tempdir().unwrap(); + let outside = dir.path().join("outside"); + std::fs::write(&outside, "protected").unwrap(); + let root = dir.path().join("root"); + std::fs::create_dir(&root).unwrap(); + std::fs::hard_link(&outside, root.join("linked")).unwrap(); + TargetRoot::new(&root) + .write("linked", "new contents") + .unwrap(); + assert_eq!(std::fs::read_to_string(&outside).unwrap(), "protected"); + } + #[test] + fn concurrent_directory_symlink_swaps_cannot_escape_descriptor_writes() { + let dir = tempfile::tempdir().unwrap(); + let outside = tempfile::tempdir().unwrap(); + let root = dir.path().to_path_buf(); + std::fs::create_dir(root.join("etc")).unwrap(); + let target = TargetRoot::new(&root); + std::os::unix::fs::symlink(outside.path(), root.join("swapped")).unwrap(); + let stop = std::sync::atomic::AtomicBool::new(false); + std::thread::scope(|scope| { + let worker = scope.spawn(|| { + while !stop.load(Ordering::Relaxed) { + fs::renameat_with( + fs::CWD, + root.join("etc"), + fs::CWD, + root.join("swapped"), + fs::RenameFlags::EXCHANGE, + ) + .unwrap(); + std::thread::yield_now(); + fs::renameat_with( + fs::CWD, + root.join("etc"), + fs::CWD, + root.join("swapped"), + fs::RenameFlags::EXCHANGE, + ) + .unwrap(); + } + }); + for _ in 0..100 { + let _ = target.write("etc/probe", "fixture"); + } + stop.store(true, Ordering::Relaxed); + worker.join().unwrap(); + }); + assert!(!outside.path().join("probe").exists()); + } } diff --git a/installer-rs/crates/phoebus-executor/Cargo.toml b/installer-rs/crates/phoebus-executor/Cargo.toml index f088f23..8051b2b 100644 --- a/installer-rs/crates/phoebus-executor/Cargo.toml +++ b/installer-rs/crates/phoebus-executor/Cargo.toml @@ -16,6 +16,7 @@ toml.workspace = true tempfile.workspace = true sha2 = "0.10" roxmltree = "0.20" +rustix.workspace = true [dev-dependencies] tempfile.workspace = true diff --git a/installer-rs/crates/phoebus-executor/src/actions.rs b/installer-rs/crates/phoebus-executor/src/actions.rs index b17a108..45d484c 100644 --- a/installer-rs/crates/phoebus-executor/src/actions.rs +++ b/installer-rs/crates/phoebus-executor/src/actions.rs @@ -199,7 +199,9 @@ fn pretend_args(action: &SystemAction) -> Option> { let mut args = vec!["--pretend".into(), "--color=n".into()]; if *binary == Some(true) { args.push("--getbinpkg=y".into()); - args.push("--usepkg=y".into()); + args.push("--usepkgonly".into()); + } else if *binary == Some(false) { + args.push("--usepkg=n".into()); } args.push("--".into()); args.push(atom.clone()); @@ -1337,6 +1339,14 @@ pub fn execute_checked( root: &Path, approved: Option<&ResolvedPlan>, ) -> Result { + if action.requires_root() && auth.is_none() { + return Err(ExecError::NotAuthorized(action.describe())); + } + let _lock = if action.requires_root() && exec.is_real() && !exec.dry_run { + Some(exec.lock_mutation(root, &action.describe())?) + } else { + None + }; let current = if let Some(approved) = approved { let current = resolve_effects(exec, action, root)?; if changed_materially(approved, ¤t) { @@ -1383,6 +1393,23 @@ pub fn execute_plan( root: &Path, ) -> PlanOutcome { let mut outcome = PlanOutcome::default(); + let lock = if steps.iter().any(|(a, _)| a.requires_root()) && exec.is_real() && !exec.dry_run { + exec.lock_mutation(root, "execute reviewed plan").map(Some) + } else { + Ok(None) + }; + let _lock = match lock { + Ok(lock) => lock, + Err(e) => { + for (action, _) in steps { + outcome + .outcomes + .push(TransactionOutcome::unattempted(action.describe())); + } + outcome.failure = Some(("acquire mutation lock".into(), e.to_string())); + return outcome; + } + }; for (action, resolved) in steps { let described = action.describe(); if outcome.failure.is_some() { @@ -1485,6 +1512,18 @@ pub fn execute_inner( auth: Option<&DestructiveAuthorization>, root: &Path, resolved: Option<&ResolvedPlan>, +) -> Result { + execute_inner_with_candidate(exec, action, auth, root, resolved, None) +} + +/// Dedicated install execution consumes the candidate's immutable artifact. +pub fn execute_inner_with_candidate( + exec: &Exec, + action: &SystemAction, + auth: Option<&DestructiveAuthorization>, + root: &Path, + resolved: Option<&ResolvedPlan>, + candidate: Option<&phoebus_core::selection::Candidate>, ) -> Result { // The execution boundary validates every action regardless of its source // (manual phrase, JSON, or AI plan), so an invalid value can never reach a @@ -1493,6 +1532,17 @@ pub fn execute_inner( .validate() .map_err(|e| ExecError::operation("sys", "validate action", e))?; + if let Some(candidate) = candidate { + let expected = crate::install::action_for(exec, root, candidate)?; + if &expected != action { + return Err(ExecError::operation( + "install", + "validate candidate action", + "action does not match the reviewed candidate", + )); + } + } + if action.requires_root() && auth.is_none() { return Err(ExecError::NotAuthorized(action.describe())); } @@ -1500,11 +1550,7 @@ pub fn execute_inner( // The global mutation lock is root-owned. Personal preferences are an // atomic user-file write and must remain usable by an unprivileged account. let _lock = if action.requires_root() && exec.is_real() && !exec.dry_run { - Some(crate::system_lock::SystemLock::acquire( - exec, - root, - &action.describe(), - )?) + Some(exec.lock_mutation(root, &action.describe())?) } else { None }; @@ -1616,7 +1662,9 @@ pub fn execute_inner( let mut args = vec!["--ask=n".into()]; if *binary == Some(true) { args.push("--getbinpkg=y".into()); - args.push("--usepkg=y".into()); + args.push("--usepkgonly".into()); + } else if *binary == Some(false) { + args.push("--usepkg=n".into()); } args.push("--".into()); args.push(atom.clone()); @@ -1664,23 +1712,34 @@ pub fn execute_inner( ), )); } - run_in_target( - exec, - root, - "sys", - "install flatpak", - "flatpak", - &[ - "install".into(), - "--system".into(), - "--noninteractive".into(), - "-y".into(), - "--".into(), - "flathub".into(), - app_id.clone(), - ], - )?; - format!("installed Flatpak app {app_id}") + if let Some(candidate) = candidate { + if candidate.id != *app_id || source.candidate.artifact != candidate.artifact { + return Err(ExecError::operation( + "install", + "revalidate artifact", + "Flatpak artifact changed before execution", + )); + } + crate::artifact::install_flatpak(exec, root, candidate)? + } else { + run_in_target( + exec, + root, + "sys", + "install flatpak", + "flatpak", + &[ + "install".into(), + "--system".into(), + "--noninteractive".into(), + "-y".into(), + "--".into(), + "flathub".into(), + app_id.clone(), + ], + )?; + format!("installed Flatpak app {app_id}") + } } SystemAction::FlatpakRemove { app_id } => { run_in_target( @@ -1838,7 +1897,20 @@ pub fn execute_inner( classic, } => { require_host_root(root, "install snap")?; - let out = snap::install(exec, name, channel.as_deref(), *classic)?; + let out = if let Some(candidate) = candidate { + let phoebus_core::selection::InstallArtifact::Snap { revision, channel } = + crate::artifact::require(candidate)? + else { + return Err(ExecError::operation( + "install", + "artifact", + "wrong Snap artifact type", + )); + }; + snap::install_revision(exec, name, Some(channel), *classic, Some(revision))? + } else { + snap::install(exec, name, channel.as_deref(), *classic)? + }; let confinement = snap::status(exec) .map(|s| s.confinement.as_str().to_string()) .unwrap_or_else(|_| "unknown".to_string()); @@ -1994,7 +2066,32 @@ pub fn execute_inner( format!("realised Nix development packages: {}", prepared.join(", ")) } SystemAction::NixInstall { packages } => { - let installed = crate::nix::install_profile_packages(exec, root, packages)?; + let installed = if let Some(candidate) = candidate { + let phoebus_core::selection::InstallArtifact::Nix { flake, .. } = + crate::artifact::require(candidate)? + else { + return Err(ExecError::operation( + "install", + "artifact", + "wrong Nix artifact type", + )); + }; + crate::portage::chroot( + exec, + root, + "/nix/var/nix/profiles/default/bin/nix", + &[ + "profile", + "install", + "--profile", + crate::nix::PHOEBUS_PROFILE, + flake, + ], + )?; + packages.clone() + } else { + crate::nix::install_profile_packages(exec, root, packages)? + }; format!("installed into the Nix profile: {}", installed.join(", ")) } SystemAction::UpdateSystem => { diff --git a/installer-rs/crates/phoebus-executor/src/agent_jail.rs b/installer-rs/crates/phoebus-executor/src/agent_jail.rs index 701bae5..b8a9e36 100644 --- a/installer-rs/crates/phoebus-executor/src/agent_jail.rs +++ b/installer-rs/crates/phoebus-executor/src/agent_jail.rs @@ -70,77 +70,153 @@ pub fn build_jail_argv( home: &Path, program: &str, args: &[String], -) -> Vec { - let mut out: Vec = vec![ - "--die-with-parent".into(), - "--dev".into(), - "/dev".into(), - "--proc".into(), - "/proc".into(), - "--tmpfs".into(), - "/tmp".into(), - ]; - - // Read-only system mounts +) -> Result> { + let valid_path = |path: &Path| { + path.is_absolute() + && !path + .components() + .any(|c| matches!(c, std::path::Component::ParentDir)) + }; + if !valid_path(home) + || !valid_path(&config.workspace) + || config.workspace == Path::new("/") + || home.starts_with(&config.workspace) + { + return Err(ExecError::operation("agent-jail", "validate workspace", "workspace must be absolute, contain no traversal, and must not expose home or the filesystem root")); + } + let mut masks: Vec = DEFAULT_SENSITIVE_SUBDIRS + .iter() + .map(|s| home.join(s)) + .collect(); + for subdir in &config.extra_masked_subdirs { + let rel = Path::new(subdir); + if rel.is_absolute() + || rel + .components() + .any(|c| !matches!(c, std::path::Component::Normal(_))) + || subdir.is_empty() + { + return Err(ExecError::operation( + "agent-jail", + "validate mask", + "mask must be a relative path without traversal", + )); + } + masks.push(home.join(rel)); + } + for mask in &masks { + if config.workspace.starts_with(mask) || mask.starts_with(&config.workspace) { + return Err(ExecError::operation( + "agent-jail", + "validate workspace", + "workspace overlaps a credential mask", + )); + } + } + // System trees are immutable, even when selected as a workspace. + if [ + "/usr", "/bin", "/sbin", "/lib", "/lib64", "/etc", "/proc", "/sys", "/dev", "/run", "/nix", + ] + .iter() + .any(|p| config.workspace.starts_with(p)) + { + return Err(ExecError::operation( + "agent-jail", + "validate workspace", + "workspace overlaps a protected system tree", + )); + } + let mut out: Vec = [ + "--die-with-parent", + "--unshare-user", + "--unshare-pid", + "--unshare-ipc", + "--unshare-uts", + "--new-session", + "--cap-drop", + "ALL", + "--clearenv", + "--dev", + "/dev", + "--proc", + "/proc", + "--tmpfs", + "/tmp", + ] + .iter() + .map(|s| s.to_string()) + .collect(); for sys_dir in ["/usr", "/bin", "/sbin", "/lib", "/lib64", "/etc"] { if Path::new(sys_dir).exists() { - out.push("--ro-bind".into()); - out.push(sys_dir.into()); - out.push(sys_dir.into()); + out.extend(["--ro-bind".into(), sys_dir.into(), sys_dir.into()]); } } - - // Read-only Nix store if enabled and present - if config.allow_nix_store && Path::new("/nix").exists() { - out.push("--ro-bind".into()); - out.push("/nix".into()); - out.push("/nix".into()); + if config.allow_nix_store && Path::new("/nix/store").exists() { + out.extend(["--ro-bind".into(), "/nix/store".into(), "/nix/store".into()]); } - - // Bind home directory let home_str = home.to_string_lossy().to_string(); - out.push("--bind".into()); - out.push(home_str.clone()); - out.push(home_str); - - // Mask sensitive subdirectories under home with private empty tmpfs - let mut masked_subdirs: Vec<&str> = DEFAULT_SENSITIVE_SUBDIRS.to_vec(); - let extra_refs: Vec<&str> = config - .extra_masked_subdirs - .iter() - .map(|s| s.as_str()) - .collect(); - masked_subdirs.extend(extra_refs); - - for sensitive in masked_subdirs { - let clean = sensitive.trim_start_matches('/'); - if clean.is_empty() || clean.split('/').any(|part| part == "..") { - continue; - } - let sensitive_path = home.join(clean); - let path_str = sensitive_path.to_string_lossy().to_string(); - out.push("--tmpfs".into()); - out.push(path_str); + out.extend(["--tmpfs".into(), home_str.clone()]); + out.extend(["--setenv".into(), "HOME".into(), home_str]); + out.extend([ + "--setenv".into(), + "PATH".into(), + "/usr/local/bin:/usr/bin:/bin".into(), + ]); + out.extend(["--setenv".into(), "LANG".into(), "C.UTF-8".into()]); + let ws = config.workspace.to_string_lossy().to_string(); + out.extend([ + "--bind".into(), + ws.clone(), + ws.clone(), + "--chdir".into(), + ws, + ]); + // Masks are last, so no writable bind can remount a credential store. + for mask in masks { + out.extend(["--tmpfs".into(), mask.to_string_lossy().to_string()]); } - - // Bind the workspace read-write and set working directory - let ws_str = config.workspace.to_string_lossy().to_string(); - out.push("--bind".into()); - out.push(ws_str.clone()); - out.push(ws_str.clone()); - out.push("--chdir".into()); - out.push(ws_str); - - // Network isolation if !config.allow_network { out.push("--unshare-net".into()); } - - // Target executable and arguments + out.push("--".into()); out.push(program.to_string()); out.extend(args.iter().cloned()); + Ok(out) +} - out +/// A validated workspace descriptor stays alive until Bubblewrap consumes it. +/// The bind never reopens the checked pathname, so a symlink swap cannot grant +/// the agent access to another directory. +pub struct PreparedJail { + pub argv: Vec, + _workspace: std::fs::File, +} + +pub fn prepare_jail( + config: &AgentJailConfig, + home: &Path, + program: &str, + args: &[String], +) -> Result { + use std::os::fd::AsRawFd; + let mut argv = build_jail_argv(config, home, program, args)?; + let workspace = phoebus_core::TargetRoot::new(&config.workspace).open_directory("")?; + rustix::io::fcntl_setfd(&workspace, rustix::io::FdFlags::empty()).map_err(|e| { + ExecError::operation("agent-jail", "inherit workspace descriptor", e.to_string()) + })?; + let ws = config.workspace.to_string_lossy(); + let index = argv + .windows(3) + .position(|w| w[0] == "--bind" && w[1] == ws && w[2] == ws) + .ok_or_else(|| { + ExecError::operation("agent-jail", "pin workspace", "workspace bind missing") + })?; + argv[index] = "--bind-fd".into(); + argv[index + 1] = workspace.as_raw_fd().to_string(); + Ok(PreparedJail { + argv, + _workspace: workspace, + }) } /// Run a program inside the Bubblewrap agent jail. @@ -157,8 +233,39 @@ pub fn run_jailed( )); } - let argv = build_jail_argv(config, home, program, args); - exec.run(CommandSpec::new("agent-jail", "run jailed user agent", "bwrap").args(argv)) + if exec.is_real() && crate::personal::effective_uid() == 0 { + return Err(ExecError::operation( + "agent-jail", + "validate account", + "developer agents must run as an unprivileged user", + )); + } + let home = if exec.is_real() { + crate::personal::home_for_uid(crate::personal::effective_uid()) + .and_then(|p| p.canonicalize().ok()) + .ok_or_else(|| { + ExecError::operation("agent-jail", "validate home", "account home is unavailable") + })? + } else { + home.to_path_buf() + }; + let mut canonical = config.clone(); + if exec.is_real() { + canonical.workspace = config + .workspace + .canonicalize() + .map_err(|e| ExecError::operation("agent-jail", "validate workspace", e.to_string()))?; + } + if exec.is_real() { + let jail = prepare_jail(&canonical, &home, program, args)?; + exec.run( + CommandSpec::new("agent-jail", "run jailed user agent", "bwrap") + .args(jail.argv.clone()), + ) + } else { + let argv = build_jail_argv(&canonical, &home, program, args)?; + exec.run(CommandSpec::new("agent-jail", "run jailed user agent", "bwrap").args(argv)) + } } #[cfg(test)] @@ -176,7 +283,7 @@ mod tests { extra_masked_subdirs: vec![".custom-secrets".into()], }; - let argv = build_jail_argv(&config, home, "cargo", &["build".into()]); + let argv = build_jail_argv(&config, home, "cargo", &["build".into()]).unwrap(); // Verify die-with-parent and dev/proc/tmp assert!(argv.contains(&"--die-with-parent".to_string())); @@ -185,7 +292,7 @@ mod tests { // Verify home directory is bound let home_idx = argv.iter().position(|a| a == "/home/developer").unwrap(); - assert_eq!(argv[home_idx - 1], "--bind"); + assert_eq!(argv[home_idx - 1], "--tmpfs"); // Verify sensitive paths are masked with tmpfs for sensitive in [ @@ -230,7 +337,7 @@ mod tests { extra_masked_subdirs: vec![], }; - let argv = build_jail_argv(&config, home, "python", &["-m".into(), "test".into()]); + let argv = build_jail_argv(&config, home, "python", &["-m".into(), "test".into()]).unwrap(); assert!(argv.contains(&"--unshare-net".to_string())); } @@ -249,10 +356,26 @@ mod tests { ], }; - let argv = build_jail_argv(&config, home, "echo", &["hi".into()]); - assert!(!argv.contains(&"/root".to_string())); - assert!(!argv.contains(&"/home/developer/../sensitive".to_string())); - assert!(!argv.contains(&"/home/developer/../../etc".to_string())); - assert!(argv.contains(&"/home/developer/valid-subdir".to_string())); + assert!(build_jail_argv(&config, home, "echo", &["hi".into()]).is_err()); + } + #[test] + fn credential_workspaces_and_home_are_refused() { + let home = Path::new("/home/developer"); + for path in [ + "/", + "/home", + "/home/developer", + "/home/developer/.ssh/project", + "/etc/project", + ] { + let config = AgentJailConfig { + workspace: path.into(), + ..Default::default() + }; + assert!( + build_jail_argv(&config, home, "true", &[]).is_err(), + "{path}" + ); + } } } diff --git a/installer-rs/crates/phoebus-executor/src/ai.rs b/installer-rs/crates/phoebus-executor/src/ai.rs index 5caeabb..05b8a69 100644 --- a/installer-rs/crates/phoebus-executor/src/ai.rs +++ b/installer-rs/crates/phoebus-executor/src/ai.rs @@ -109,8 +109,9 @@ impl ModelTransport for CurlTransport<'_> { // Fail closed on an unsafe scheme or a URL that could inject curl // config directives before anything is written. phoebus_ai::provider::validate_endpoint(url)?; + let body = self.exec.redactor().redact(body); if self.sandboxed { - return self.send_sandboxed(url, body); + return self.send_sandboxed(url, &body); } let mut request = tempfile::Builder::new() .prefix("phoebus-ai-request.") @@ -146,7 +147,12 @@ impl ModelTransport for CurlTransport<'_> { max = phoebus_ai::provider::MAX_RESPONSE_BYTES, ); let spec = CommandSpec::new("ai", "query model", "curl") - .args(["-sS", "-K", "-"]) + .args(["--disable", "-sS", "-K", "-"]) + .sensitive_output() + .output_limit(phoebus_ai::provider::MAX_RESPONSE_BYTES as usize) + .timeout(std::time::Duration::from_secs( + ai_timeout_secs().saturating_add(30), + )) .stdin(config.into_bytes()); let out = self .exec @@ -177,11 +183,13 @@ impl CurlTransport<'_> { timeout = ai_timeout_secs(), max = phoebus_ai::provider::MAX_RESPONSE_BYTES, ); - let out = crate::sandbox::run( + let out = crate::sandbox::run_bounded( self.exec, "curl", - &["-sS".into(), "-K".into(), "-".into()], + &["--disable".into(), "-sS".into(), "-K".into(), "-".into()], config.into_bytes(), + phoebus_ai::provider::MAX_RESPONSE_BYTES as usize, + std::time::Duration::from_secs(ai_timeout_secs().saturating_add(30)), ) .map_err(|e| AiError::Provider(e.to_string()))?; Ok(out.stdout_lossy()) @@ -319,7 +327,9 @@ mod tests { spec.args ); assert!( - spec.args.iter().any(|a| a.contains("ProtectHome=yes")), + spec.args + .iter() + .any(|a| a.contains("ProtectHome=yes") || a == "/usr/bin/bwrap"), "the sandbox properties must be present: {:?}", spec.args ); diff --git a/installer-rs/crates/phoebus-executor/src/artifact.rs b/installer-rs/crates/phoebus-executor/src/artifact.rs new file mode 100644 index 0000000..81e403f --- /dev/null +++ b/installer-rs/crates/phoebus-executor/src/artifact.rs @@ -0,0 +1,221 @@ +//! Immutable install identities. Resolution performs only metadata reads; +//! execution consumes a validated pin instead of following a mutable channel. + +use crate::{ + command::CommandSpec, + error::{ExecError, Result}, + exec::Exec, +}; +use phoebus_core::selection::{Backend, Candidate, InstallArtifact}; +use std::path::Path; + +fn read(exec: &Exec, root: &Path, program: &str, args: &[&str]) -> Option { + let spec = if root == Path::new("/") { + CommandSpec::new("artifact", "resolve install identity", program).args(args.iter().copied()) + } else { + CommandSpec::new("artifact", "resolve install identity", "chroot") + .arg(root.to_string_lossy()) + .arg(program) + .args(args.iter().copied()) + } + .sensitive_output() + .output_limit(1024 * 1024) + .timeout(std::time::Duration::from_secs(120)); + exec.run(spec) + .ok() + .map(|out| out.stdout_lossy().trim().to_string()) +} + +pub fn resolve(exec: &Exec, root: &Path, candidate: &mut Candidate) { + let pin = match candidate.backend { + Backend::Flatpak => { + let reference = read( + exec, + root, + "flatpak", + &[ + "remote-info", + "--system", + "--show-ref", + "--", + "flathub", + &candidate.id, + ], + ); + let commit = read( + exec, + root, + "flatpak", + &[ + "remote-info", + "--system", + "--show-commit", + "--", + "flathub", + &candidate.id, + ], + ); + reference + .zip(commit) + .map(|(reference, commit)| InstallArtifact::Flatpak { reference, commit }) + } + Backend::Snap => read( + exec, + root, + "snap", + &["info", "--color=never", &candidate.id], + ) + .and_then(|text| { + text.lines().find_map(|line| { + let words: Vec<_> = line.split_whitespace().collect(); + if !matches!( + words.first().copied(), + Some("latest/stable:") | Some("stable:") + ) { + return None; + } + let revision = words + .iter() + .find_map(|w| w.strip_prefix('(')?.strip_suffix(')'))?; + if words.len() > 1 { + candidate.version = Some(words[1].into()); + } + Some(InstallArtifact::Snap { + revision: revision.into(), + channel: "latest/stable".into(), + }) + }) + }), + Backend::Nix => read( + exec, + root, + "/nix/var/nix/profiles/default/bin/nix", + &["flake", "metadata", "--json", "nixpkgs"], + ) + .and_then(|text| { + let metadata: serde_json::Value = serde_json::from_str(&text).ok()?; + let source = metadata.get("path")?.as_str()?; + let flake = format!("path:{source}#{}", candidate.id); + let store_path = read( + exec, + root, + "/nix/var/nix/profiles/default/bin/nix", + &["eval", "--raw", &format!("{flake}.outPath")], + )?; + Some(InstallArtifact::Nix { flake, store_path }) + }), + _ => return, + }; + candidate.artifact = pin.filter(InstallArtifact::validate); + if candidate.artifact.is_none() { + candidate.available = false; + candidate.verified = false; + candidate.notes.push( + "immutable install identity could not be resolved; refusing an approximate approval" + .into(), + ); + } +} + +pub fn require(candidate: &Candidate) -> Result<&InstallArtifact> { + candidate + .artifact + .as_ref() + .filter(|pin| { + pin.validate() + && match (candidate.backend, pin) { + (Backend::Flatpak, InstallArtifact::Flatpak { reference, .. }) => { + reference.split('/').nth(1) == Some(candidate.id.as_str()) + } + (Backend::Snap, InstallArtifact::Snap { .. }) => true, + (Backend::Nix, InstallArtifact::Nix { flake, .. }) => flake + .split_once('#') + .is_some_and(|(_, attr)| attr == candidate.id), + _ => false, + } + }) + .ok_or_else(|| { + ExecError::operation( + "install", + "validate artifact", + "reviewed install artifact is missing or invalid; review a fresh plan", + ) + }) +} + +pub fn install_flatpak(exec: &Exec, root: &Path, candidate: &Candidate) -> Result { + let InstallArtifact::Flatpak { reference, commit } = require(candidate)? else { + return Err(ExecError::operation( + "install", + "artifact", + "wrong Flatpak artifact type", + )); + }; + // OSTree pulls the approved commit and verifies the configured remote's + // signatures. Flatpak then deploys the local ref without following HEAD. + crate::portage::chroot( + exec, + root, + "flatpak", + &[ + "install", + "--system", + "--noninteractive", + "-y", + "--no-deploy", + "--", + "flathub", + reference, + ], + )?; + crate::portage::chroot( + exec, + root, + "ostree", + &[ + "--repo=/var/lib/flatpak/repo", + "pull", + "flathub", + &format!("{reference}@{commit}"), + ], + )?; + crate::portage::chroot( + exec, + root, + "flatpak", + &[ + "install", + "--system", + "--noninteractive", + "-y", + "--no-pull", + "--", + "flathub", + reference, + ], + )?; + Ok(format!("installed {reference} at approved commit {commit}")) +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn malformed_artifacts_are_refused() { + assert!(!InstallArtifact::Flatpak { + reference: "app/org.example.App/x86_64/stable".into(), + commit: "0".repeat(64) + } + .validate()); + assert!(!InstallArtifact::Nix { + flake: "https://attacker.invalid#tool".into(), + store_path: "/nix/store/x".into() + } + .validate()); + assert!(!InstallArtifact::Snap { + revision: "--dangerous".into(), + channel: "stable".into() + } + .validate()); + } +} diff --git a/installer-rs/crates/phoebus-executor/src/chooser.rs b/installer-rs/crates/phoebus-executor/src/chooser.rs index 4a913b3..26e15d2 100644 --- a/installer-rs/crates/phoebus-executor/src/chooser.rs +++ b/installer-rs/crates/phoebus-executor/src/chooser.rs @@ -114,6 +114,7 @@ pub fn save_preferences(exec: &Exec, root: &Path, prefs: &Preferences) -> Result fn rooted(root: &Path, stage: &str, operation: &str, program: &str, args: &[&str]) -> CommandSpec { let owned: Vec = args.iter().map(|s| s.to_string()).collect(); crate::actions::target_spec(root, stage, operation, program, &owned) + .timeout(std::time::Duration::from_secs(120)) } /// Snap acts on the running daemon and cannot be redirected to a target. @@ -855,6 +856,9 @@ pub fn candidate_detail(exec: &Exec, root: &Path, backend: Backend, id: &str) -> if backend == Backend::Flatpak && candidate.available { inspect_flatpak_remote(exec, root, &mut candidate); } + if candidate.available && candidate.verified { + crate::artifact::resolve(exec, root, &mut candidate); + } let health = candidate_health(&candidate); CandidateDetail { diff --git a/installer-rs/crates/phoebus-executor/src/command.rs b/installer-rs/crates/phoebus-executor/src/command.rs index 19b8c18..2c69408 100644 --- a/installer-rs/crates/phoebus-executor/src/command.rs +++ b/installer-rs/crates/phoebus-executor/src/command.rs @@ -5,9 +5,12 @@ //! privileged logic be tested with a fake runner without touching the system. use std::collections::HashMap; -use std::io::{BufRead, Read, Write}; +use std::io::{Read, Write}; +use std::os::fd::AsFd; +use std::os::unix::process::CommandExt; use std::path::PathBuf; use std::process::{Command, Stdio}; +use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::{Arc, Mutex}; use std::time::{Duration, Instant}; @@ -27,6 +30,16 @@ pub struct CommandSpec { /// Forward this command's live output to the human-facing sink, when one /// is configured. The structured logger still receives every command. pub show_output: bool, + /// Suppress all output sinks and error-body logging (provider bodies may + /// contain credentials unknown to our secret registry). + pub sensitive_output: bool, + /// Bound captured output per stream; streaming builds retain only a tail. + pub max_output_bytes: usize, + /// Wall-clock bound including blocked stdin and inherited output pipes. + pub timeout: Duration, + /// An open mutation-lock lease inherited by the command. Its own lifetime + /// keeps exclusion intact if the approving broker crashes first. + pub(crate) mutation_lease: Option>, } impl CommandSpec { @@ -44,6 +57,10 @@ impl CommandSpec { stage: stage.into(), operation: operation.into(), show_output: false, + sensitive_output: false, + max_output_bytes: 16 * 1024 * 1024, + timeout: Duration::from_secs(24 * 60 * 60), + mutation_lease: None, } } @@ -100,6 +117,18 @@ impl CommandSpec { self } + pub fn sensitive_output(mut self) -> Self { + self.sensitive_output = true; + self + } + pub fn output_limit(mut self, bytes: usize) -> Self { + self.max_output_bytes = bytes.max(1); + self + } + pub fn timeout(mut self, timeout: Duration) -> Self { + self.timeout = timeout; + self + } pub fn show_output(mut self) -> Self { self.show_output = true; self @@ -197,6 +226,12 @@ impl ProcessRunner for RealRunner { let start = Instant::now(); let mut command = Command::new(&spec.program); command.args(&spec.args); + // setsid must start as a non-leader so it keeps the spawned PID as + // its session/process-group ID. Pre-grouping it would force a fork + // and leave its real worker outside our deadline kill group. + if !(spec.program == "setsid" && spec.args.first().is_some_and(|a| a == "--wait")) { + command.process_group(0); + } for (k, v) in &spec.env { command.env(k, v); } @@ -211,97 +246,199 @@ impl ProcessRunner for RealRunner { Stdio::null() }); - let mut child = command.spawn().map_err(|source| ExecError::Spawn { - program: spec.program.clone(), - source, - })?; - - if let Some(bytes) = &spec.stdin { - if let Some(mut stdin) = child.stdin.take() { - // Ignore broken-pipe style errors; the process exit status is - // the source of truth. - let _ = stdin.write_all(bytes); - let _ = stdin.flush(); - } + if let Some(lease) = &spec.mutation_lease { + rustix::io::fcntl_setfd(lease.as_ref(), rustix::io::FdFlags::empty()) + .map_err(|e| ExecError::operation(&spec.stage, &spec.operation, e.to_string()))?; } - - let mut stdout_pipe = child.stdout.take(); - let mut stderr_pipe = child.stderr.take(); - - let (stdout, stderr) = std::thread::scope(|s| { - let out_handle = s.spawn(|| { - stdout_pipe.take().map_or_else(Vec::new, |pipe| { - drain_output( - pipe, - self.sink.as_ref(), - spec.show_output - .then_some(&self.user_sink) - .and_then(Option::as_ref), - ) - }) - }); - - let err_handle = s.spawn(|| { - stderr_pipe.take().map_or_else(Vec::new, |pipe| { - drain_output( - pipe, - self.sink.as_ref(), - spec.show_output - .then_some(&self.user_sink) - .and_then(Option::as_ref), - ) - }) - }); - - let stdout = out_handle.join().map_err(|_| { - ExecError::operation(&spec.stage, &spec.operation, "stdout reader stopped") - })?; - let stderr = err_handle.join().map_err(|_| { - ExecError::operation(&spec.stage, &spec.operation, "stderr reader stopped") - })?; - Ok::<_, ExecError>((stdout, stderr)) - })?; - - let status = child.wait().map_err(|source| ExecError::Spawn { + let spawned = command.spawn(); + if let Some(lease) = &spec.mutation_lease { + // Descriptor flags are per process: restoring CLOEXEC here does + // not close or change the copy inherited by the worker. + rustix::io::fcntl_setfd(lease.as_ref(), rustix::io::FdFlags::CLOEXEC) + .map_err(|e| ExecError::operation(&spec.stage, &spec.operation, e.to_string()))?; + } + let mut child = spawned.map_err(|source| ExecError::Spawn { program: spec.program.clone(), source, })?; - let duration = start.elapsed(); - let code = status.code().unwrap_or(-1); + + // Drain output while writing stdin: a child may fill stdout before it + // consumes its request. Nonblocking pipes also bound cleanup when a + // descendant inherits a pipe and outlives its parent. + let stdout_pipe = child.stdout.take(); + let stderr_pipe = child.stderr.take(); + let stdin_pipe = child.stdin.take(); + let stop = AtomicBool::new(false); + let exceeded = AtomicBool::new(false); + let log = (!spec.sensitive_output) + .then_some(self.sink.as_ref()) + .flatten(); + let user = (spec.show_output && !spec.sensitive_output) + .then_some(self.user_sink.as_ref()) + .flatten(); + let (status, stdout, stderr, timed_out) = std::thread::scope(|scope| { + let out = scope.spawn(|| drain_output(stdout_pipe, log, user, spec, &stop, &exceeded)); + let err = scope.spawn(|| drain_output(stderr_pipe, log, user, spec, &stop, &exceeded)); + let input = scope.spawn(|| -> std::io::Result<()> { + if let (Some(mut pipe), Some(bytes)) = (stdin_pipe, spec.stdin.as_ref()) { + nonblocking(&pipe)?; + let mut written = 0; + while written < bytes.len() && !stop.load(Ordering::Relaxed) { + match pipe.write(&bytes[written..]) { + Ok(0) => break, + Ok(n) => written += n, + Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => { + std::thread::sleep(Duration::from_millis(10)) + } + Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue, + Err(e) if e.kind() == std::io::ErrorKind::BrokenPipe => break, + Err(e) => return Err(e), + } + } + } + Ok(()) + }); + let mut timed_out = false; + let status = loop { + if start.elapsed() >= spec.timeout || exceeded.load(Ordering::Relaxed) { + timed_out = start.elapsed() >= spec.timeout; + if let Some(pid) = rustix::process::Pid::from_raw(child.id() as i32) { + let _ = + rustix::process::kill_process_group(pid, rustix::process::Signal::KILL); + } + let _ = child.kill(); + break child.wait(); + } + match child.try_wait() { + Ok(Some(status)) => break Ok(status), + Ok(None) => std::thread::sleep(Duration::from_millis(10)), + Err(e) => { + let _ = child.kill(); + let _ = child.wait(); + break Err(e); + } + } + }; + // Commands are synchronous. Do not leave pipe-inheriting workers + // running after their leader exits, including on successful exit. + if let Some(pid) = rustix::process::Pid::from_raw(child.id() as i32) { + let _ = rustix::process::kill_process_group(pid, rustix::process::Signal::KILL); + } + stop.store(true, Ordering::Relaxed); + let join_err = || { + ExecError::operation(&spec.stage, &spec.operation, "command pipe worker stopped") + }; + input + .join() + .map_err(|_| join_err())? + .map_err(|e| ExecError::operation(&spec.stage, &spec.operation, e.to_string()))?; + let stdout = out.join().map_err(|_| join_err())??; + let stderr = err.join().map_err(|_| join_err())??; + Ok::<_, ExecError>((status, stdout, stderr, timed_out)) + })?; + let status = status.map_err(|source| ExecError::Spawn { + program: spec.program.clone(), + source, + })?; + if timed_out || exceeded.load(Ordering::Relaxed) { + return Err(ExecError::operation( + &spec.stage, + &spec.operation, + if timed_out { + "command exceeded its wall-clock deadline; process group stopped" + } else { + "command output exceeded its capture limit; process group stopped" + }, + )); + } Ok(CommandOutput { - status: code, + status: status.code().unwrap_or(-1), success: status.success(), stdout, stderr, - duration, + duration: start.elapsed(), }) } } -/// Preserve complete captured output while delivering newline and carriage -/// return updates as they arrive (Flatpak and curl use CR progress meters). -fn drain_output(pipe: impl Read, log: Option<&StreamSink>, user: Option<&StreamSink>) -> Vec { - let mut reader = std::io::BufReader::new(pipe); - let mut captured = Vec::new(); +fn nonblocking(pipe: &impl AsFd) -> std::io::Result<()> { + let flags = rustix::fs::fcntl_getfl(pipe)?; + rustix::fs::fcntl_setfl(pipe, flags | rustix::fs::OFlags::NONBLOCK)?; + Ok(()) +} + +fn drain_output( + pipe: Option

, + log: Option<&StreamSink>, + user: Option<&StreamSink>, + spec: &CommandSpec, + stop: &AtomicBool, + exceeded: &AtomicBool, +) -> Result> { + let Some(mut pipe) = pipe else { + return Ok(Vec::new()); + }; + nonblocking(&pipe) + .map_err(|e| ExecError::operation(&spec.stage, &spec.operation, e.to_string()))?; + let mut captured = std::collections::VecDeque::new(); let mut pending = Vec::new(); - while let Ok(bytes) = reader.fill_buf() { - if bytes.is_empty() { - break; + let mut skipping_line = false; + let mut logged = 0usize; + let mut chunk = [0u8; 8192]; + loop { + let count = match pipe.read(&mut chunk) { + Ok(0) => break, + Ok(n) => n, + Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => { + if stop.load(Ordering::Relaxed) { + break; + } + std::thread::sleep(Duration::from_millis(10)); + continue; + } + Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue, + Err(e) => { + return Err(ExecError::operation( + &spec.stage, + &spec.operation, + e.to_string(), + )) + } + }; + if !spec.show_output && captured.len().saturating_add(count) > spec.max_output_bytes { + exceeded.store(true, Ordering::Relaxed); + return Ok(Vec::new()); } - let boundary = bytes.iter().position(|b| *b == b'\n' || *b == b'\r'); - let count = boundary.map_or(bytes.len(), |index| index + 1); - captured.extend_from_slice(&bytes[..count]); - pending.extend_from_slice(&bytes[..count]); - reader.consume(count); - if boundary.is_some() { - emit_chunk(&pending, log, user); - pending.clear(); + captured.extend(&chunk[..count]); + if captured.len() > spec.max_output_bytes { + captured.drain(..captured.len() - spec.max_output_bytes); + } + if logged >= spec.max_output_bytes { + continue; + } + for byte in &chunk[..count] { + if !skipping_line { + pending.push(*byte); + } + if *byte == b'\n' || *byte == b'\r' { + if !skipping_line && logged.saturating_add(pending.len()) <= spec.max_output_bytes { + emit_chunk(&pending, log, user); + logged += pending.len(); + } + pending.clear(); + skipping_line = false; + } else if pending.len() >= 64 * 1024 { + // Do not split arbitrarily: that could split a registered secret + // across redaction calls. Discard an oversized log line instead. + pending.clear(); + skipping_line = true; + } } } - if !pending.is_empty() { + if !pending.is_empty() && logged.saturating_add(pending.len()) <= spec.max_output_bytes { emit_chunk(&pending, log, user); } - captured + Ok(captured.into_iter().collect()) } fn emit_chunk(bytes: &[u8], log: Option<&StreamSink>, user: Option<&StreamSink>) { @@ -475,4 +612,68 @@ mod tests { assert_eq!(result.stdout_lossy(), "building\rinstalled\n"); assert_eq!(*shown.lock().unwrap(), "building\rinstalled\n"); } + #[test] + fn sensitive_output_never_reaches_either_sink() { + let seen = Arc::new(Mutex::new(String::new())); + let sink = seen.clone(); + let runner = RealRunner::with_sinks( + Arc::new(move |s| sink.lock().unwrap().push_str(s)), + Arc::new(move |_| panic!("sensitive output forwarded")), + ); + let out = runner + .execute( + &CommandSpec::new("test", "secret", "printf") + .arg("unregistered-provider-credential\n") + .show_output() + .sensitive_output(), + ) + .unwrap(); + assert!(out + .stdout_lossy() + .contains("unregistered-provider-credential")); + assert!(seen.lock().unwrap().is_empty()); + } + + #[test] + fn output_limits_fail_queries_and_bound_streaming_tails() { + let runner = RealRunner::new(); + let spec = CommandSpec::new("test", "output", "python3") + .args(["-c", "import sys; sys.stdout.write('x'*100000)"]) + .output_limit(1024) + .timeout(Duration::from_secs(5)); + assert!(runner + .execute(&spec) + .unwrap_err() + .to_string() + .contains("capture limit")); + let out = runner.execute(&spec.show_output()).unwrap(); + assert_eq!(out.stdout.len(), 1024); + } + + #[test] + fn drains_output_before_large_stdin_and_bounds_blocked_input() { + let runner = RealRunner::new(); + let spec = CommandSpec::new("test", "duplex", "python3") + .args(["-c", "import sys; sys.stdout.write('x'*200000); sys.stdout.flush(); sys.stdin.buffer.read()"]) + .stdin(vec![b'y'; 200000]).timeout(Duration::from_secs(5)); + assert_eq!(runner.execute(&spec).unwrap().stdout.len(), 200000); + let blocked = CommandSpec::new("test", "deadline", "python3") + .args(["-c", "import time; time.sleep(30)"]) + .stdin(vec![b'y'; 200000]) + .timeout(Duration::from_millis(100)); + let start = Instant::now(); + assert!(runner + .execute(&blocked) + .unwrap_err() + .to_string() + .contains("deadline")); + assert!(start.elapsed() < Duration::from_secs(3)); + let start = Instant::now(); + assert!(runner + .execute(&blocked.detached()) + .unwrap_err() + .to_string() + .contains("deadline")); + assert!(start.elapsed() < Duration::from_secs(3)); + } } diff --git a/installer-rs/crates/phoebus-executor/src/desktop.rs b/installer-rs/crates/phoebus-executor/src/desktop.rs index 4331e91..b25c940 100644 --- a/installer-rs/crates/phoebus-executor/src/desktop.rs +++ b/installer-rs/crates/phoebus-executor/src/desktop.rs @@ -62,6 +62,7 @@ pub fn install( ); if config.desktop.flatpak { packages.push("sys-apps/flatpak".to_string()); + packages.push("dev-util/ostree".to_string()); } exec.logger.info(format!( "installing desktop profile '{}' ({} packages)", diff --git a/installer-rs/crates/phoebus-executor/src/evidence.rs b/installer-rs/crates/phoebus-executor/src/evidence.rs new file mode 100644 index 0000000..84b2e2b --- /dev/null +++ b/installer-rs/crates/phoebus-executor/src/evidence.rs @@ -0,0 +1,144 @@ +//! The sole model-facing evidence boundary. Command logs are not evidence; +//! service inspection uses enumerated properties and never journal/argv data. + +use crate::{actions, command::CommandSpec, exec::Exec}; +use phoebus_core::action::SystemAction; +use std::path::Path; + +pub const MAX_EVIDENCE_BYTES: usize = 64 * 1024; + +pub fn minimize(exec: &Exec, text: &str) -> String { + let redacted = exec.redactor().redact(text); + let mut output = String::new(); + for line in redacted.lines() { + if phoebus_ai::privacy::is_forbidden_path(line) + || line.contains("/home/") + || line.contains("/root/") + { + output.push_str("[private path omitted]\n"); + } else { + output.push_str(line); + output.push('\n'); + } + if output.len() >= MAX_EVIDENCE_BYTES { + break; + } + } + if output.len() > MAX_EVIDENCE_BYTES { + let mut end = MAX_EVIDENCE_BYTES; + while !output.is_char_boundary(end) { + end -= 1; + } + output.truncate(end); + output.push_str("\n[evidence truncated]"); + } + output +} + +pub fn investigate(exec: &Exec, action: &SystemAction, root: &Path) -> String { + if action.is_mutating() { + return "investigation refused: mutating action".into(); + } + if let Err(e) = action.validate() { + return format!("investigation refused: {e}"); + } + let result = if let SystemAction::InspectService { name } = action { + if root != Path::new("/") { + return "investigation refused: service state belongs to the running system".into(); + } + exec.run( + CommandSpec::new("evidence", "inspect service properties", "systemctl") + .args([ + "show", + "--no-pager", + "--property=LoadState,ActiveState,SubState,UnitFileState,Result", + "--", + name, + ]) + .sensitive_output() + .output_limit(MAX_EVIDENCE_BYTES) + .timeout(std::time::Duration::from_secs(30)), + ) + .map(|out| out.stdout_lossy()) + } else { + actions::execute(exec, action, None, root).map(|out| out.output) + }; + minimize( + exec, + &match result { + Ok(out) => out, + Err(e) => format!("investigation failed: {e}"), + }, + ) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{ + command::{CommandOutput, RecordingRunner}, + log::Logger, + }; + use phoebus_core::{Redactor, SecretString}; + + #[test] + fn registered_secrets_private_paths_and_unicode_are_filtered() { + let dir = tempfile::tempdir().unwrap(); + let exec = Exec::new( + Box::new(RecordingRunner::new()), + Logger::open(dir.path().join("log"), Redactor::new(), false), + false, + "/", + dir.path(), + ); + exec.register_secret(&SecretString::new("synthetic-token")); + let text = minimize( + &exec, + &format!( + "synthetic-token\n/home/test/private\n{}", + "é".repeat(MAX_EVIDENCE_BYTES) + ), + ); + assert!(!text.contains("synthetic-token")); + assert!(!text.contains("/home/test/private")); + assert!(text.len() <= MAX_EVIDENCE_BYTES + 32); + } + + #[test] + fn model_service_evidence_never_requests_journal_or_command_lines() { + let dir = tempfile::tempdir().unwrap(); + let runner = RecordingRunner::new(); + runner.set_response( + "systemctl", + CommandOutput { + status: 0, + success: true, + stdout: b"ActiveState=active\n".to_vec(), + stderr: vec![], + duration: std::time::Duration::ZERO, + }, + ); + let exec = Exec::new( + Box::new(runner.clone()), + Logger::open(dir.path().join("log"), Redactor::new(), false), + false, + "/", + dir.path(), + ); + assert!(investigate( + &exec, + &SystemAction::InspectService { + name: "sshd".into() + }, + Path::new("/") + ) + .contains("ActiveState=active")); + let spec = &runner.recorded()[0]; + assert_eq!(spec.args[0], "show"); + assert!(spec.sensitive_output); + assert!(!spec + .args + .iter() + .any(|a| a.contains("ExecStart") || a == "status")); + } +} diff --git a/installer-rs/crates/phoebus-executor/src/exec.rs b/installer-rs/crates/phoebus-executor/src/exec.rs index f3b7364..41617b2 100644 --- a/installer-rs/crates/phoebus-executor/src/exec.rs +++ b/installer-rs/crates/phoebus-executor/src/exec.rs @@ -1,7 +1,7 @@ //! Execution context: the single place commands are run and logged. use std::path::{Path, PathBuf}; -use std::sync::Arc; +use std::sync::{Arc, Mutex}; use std::time::{Duration, Instant}; use phoebus_core::{Redactor, SecretString, TargetRoot}; @@ -36,6 +36,19 @@ pub struct Exec { pub root: PathBuf, pub state_dir: PathBuf, progress: Option, + mutation_owner: Mutex< + Option<( + PathBuf, + std::thread::ThreadId, + std::sync::Weak, + )>, + >, +} + +pub struct MutationGuard { + _lock: Arc, + // Reentrancy is thread-scoped; ownership must not migrate to another thread. + _thread: std::marker::PhantomData>, } pub struct ProgressPhase<'a> { @@ -77,6 +90,7 @@ impl Exec { root: root.into(), state_dir: state_dir.into(), progress: None, + mutation_owner: Mutex::new(None), } } @@ -85,6 +99,39 @@ impl Exec { self } + /// A whole transaction holds this guard. Nested actions on the same thread + /// reuse its lock; another thread or process still has to acquire the inode. + pub fn lock_mutation(&self, root: &Path, operation: &str) -> Result { + let mut owner = self + .mutation_owner + .lock() + .map_err(|_| ExecError::operation("sys", "lock", "mutation owner state unavailable"))?; + let thread = std::thread::current().id(); + if let Some((path, id, weak)) = owner.as_ref() { + if let Some(lock) = weak.upgrade() { + if path != root || *id != thread { + return Err(ExecError::operation( + "sys", + "lock", + "another mutation already owns this executor", + )); + } + return Ok(MutationGuard { + _lock: lock, + _thread: std::marker::PhantomData, + }); + } + } + let lock = Arc::new(crate::system_lock::SystemLock::acquire( + self, root, operation, + )?); + *owner = Some((root.to_path_buf(), thread, Arc::downgrade(&lock))); + Ok(MutationGuard { + _lock: lock, + _thread: std::marker::PhantomData, + }) + } + fn report(&self, event: ProgressEvent) { if let Some(sink) = &self.progress { sink(event); @@ -126,12 +173,24 @@ impl Exec { } /// Run a command, honouring dry-run, and log it with its exit status. - pub fn run(&self, spec: CommandSpec) -> Result { + pub fn run(&self, mut spec: CommandSpec) -> Result { if self.dry_run { self.logger .dry_run(&spec.stage, &spec.operation, &spec.program, &spec.args); return Ok(CommandOutput::dry_run()); } + if self.is_real() { + let owner = self.mutation_owner.lock().map_err(|_| { + ExecError::operation("sys", "lease mutation", "mutation state unavailable") + })?; + if let Some((_, thread, weak)) = owner.as_ref() { + if *thread == std::thread::current().id() { + if let Some(lock) = weak.upgrade() { + spec.mutation_lease = Some(Arc::new(lock.worker_lease()?)); + } + } + } + } let stdin_hidden = spec.stdin.is_some(); self.logger.command_start( &spec.stage, @@ -167,7 +226,7 @@ impl Exec { duration: output.duration, stdin_hidden, }); - if !self.runner.is_streaming() { + if !self.runner.is_streaming() && !spec.sensitive_output { if !output.stdout.is_empty() { self.logger.output(&output.stdout); } @@ -181,8 +240,16 @@ impl Exec { operation: spec.operation.clone(), program: spec.program.clone(), status: output.status, - stdout: self.redactor().redact(&output.stdout_lossy()), - stderr: self.redactor().redact(&output.stderr_lossy()), + stdout: if spec.sensitive_output { + "[sensitive output withheld]".into() + } else { + self.redactor().redact(&output.stdout_lossy()) + }, + stderr: if spec.sensitive_output { + "[sensitive output withheld]".into() + } else { + self.redactor().redact(&output.stderr_lossy()) + }, })); } Ok(output) @@ -413,4 +480,21 @@ mod tests { assert!(find_in_path("true").is_some()); assert!(find_in_path("definitely-not-a-real-tool-xyz").is_none()); } + #[test] + fn nested_mutation_guards_retain_the_kernel_lock_until_the_last_drop() { + let dir = tempfile::tempdir().unwrap(); + let e = exec(RecordingRunner::new()); + let outer = e.lock_mutation(dir.path(), "whole plan").unwrap(); + let inner = e.lock_mutation(dir.path(), "nested action").unwrap(); + drop(outer); + assert!(crate::system_lock::SystemLock::acquire(&e, dir.path(), "competitor").is_err()); + std::thread::scope(|scope| { + scope + .spawn(|| assert!(e.lock_mutation(dir.path(), "other thread").is_err())) + .join() + .unwrap(); + }); + drop(inner); + assert!(e.lock_mutation(dir.path(), "next plan").is_ok()); + } } diff --git a/installer-rs/crates/phoebus-executor/src/install.rs b/installer-rs/crates/phoebus-executor/src/install.rs index c9adcdd..9433d34 100644 --- a/installer-rs/crates/phoebus-executor/src/install.rs +++ b/installer-rs/crates/phoebus-executor/src/install.rs @@ -212,7 +212,16 @@ pub fn action_for(_exec: &Exec, root: &Path, candidate: &Candidate) -> Result { Ok(SystemAction::InstallPackage { - atom: candidate.id.clone(), + atom: match candidate.version.as_deref() { + Some(version) => format!("={}-{}", candidate.id, version), + None => { + return Err(ExecError::operation( + "install", + "pin Portage version", + "reviewed package has no exact version", + )) + } + }, binary: Some(candidate.backend == Backend::PortageBinary), }) } @@ -315,6 +324,10 @@ pub fn approval_digest_for( hasher.update(candidate.provenance.as_bytes()); hasher.update(b"\0"); hasher.update([u8::from(candidate.verified)]); + if let Some(pin) = &candidate.artifact { + // Closed enum of strings; serialization cannot fail. + hasher.update(format!("{pin:?}").as_bytes()); + } hasher.update(b"\0"); hasher.update(serde_json::to_string(action).unwrap_or_default().as_bytes()); hasher.update(b"\0"); @@ -382,6 +395,7 @@ pub fn revalidate(exec: &Exec, root: &Path, resolved: &ResolvedInstall) -> Resul } if current.provenance != resolved.candidate.provenance || current.verified != resolved.candidate.verified + || current.artifact != resolved.candidate.artifact { return Err(ExecError::operation( "install", @@ -724,10 +738,7 @@ impl InstallSession for ExecutorSession<'_> { requests .iter() .map(|request| { - let output = match actions::execute(self.exec, request, None, self.root) { - Ok(outcome) => outcome.output, - Err(e) => format!("investigation failed: {e}"), - }; + let output = crate::evidence::investigate(self.exec, request, self.root); Evidence { request: request.describe(), output, @@ -924,11 +935,11 @@ pub fn verify_installed(exec: &Exec, root: &Path, resolved: &ResolvedInstall) -> match c.backend { Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => { let inspection = chooser::installed_copies(exec, root, &resolved.request.application); - if let Some(copy) = inspection - .copies - .iter() - .find(|x| x.backend == Backend::PortageSource.as_str()) - { + if let Some(copy) = inspection.copies.iter().find(|x| { + x.backend == Backend::PortageSource.as_str() + && x.id == c.id + && c.version.as_deref() == Some(x.version.as_str()) + }) { return Ok(format!( "verified: {} {} is in the Portage package database", copy.id, copy.version @@ -944,14 +955,49 @@ pub fn verify_installed(exec: &Exec, root: &Path, resolved: &ResolvedInstall) -> )) } Backend::Flatpak => { - let installed = exec.runner.execute(&phoebus_executor_command( - "flatpak", - &["list", "--app", "--columns=application"], - )); - if installed - .map(|o| o.stdout_lossy().lines().any(|l| l.trim() == c.id)) - .unwrap_or(false) - { + let phoebus_core::selection::InstallArtifact::Flatpak { reference, commit } = + crate::artifact::require(c)? + else { + return Err(ExecError::operation( + "install", + "verify", + "wrong Flatpak artifact type", + )); + }; + let spec = if root == Path::new("/") { + phoebus_executor_command( + "flatpak", + &[ + "info", + "--system", + "--show-ref", + "--show-commit", + "--", + &c.id, + ], + ) + } else { + phoebus_executor_command( + "chroot", + &[ + &root.to_string_lossy(), + "flatpak", + "info", + "--system", + "--show-ref", + "--show-commit", + "--", + &c.id, + ], + ) + }; + if exec.runner.execute(&spec).is_ok_and(|o| { + o.success && { + let output = o.stdout_lossy(); + let fields: Vec<_> = output.split_whitespace().collect(); + fields.contains(&reference.as_str()) && fields.contains(&commit.as_str()) + } + }) { Ok(format!("verified: Flatpak app {} is installed", c.id)) } else { Err(ExecError::operation( @@ -963,7 +1009,22 @@ pub fn verify_installed(exec: &Exec, root: &Path, resolved: &ResolvedInstall) -> } Backend::Snap => { let entries = crate::snap::list(exec)?; - if entries.iter().any(|e| e.name == c.id) { + let phoebus_core::selection::InstallArtifact::Snap { revision, channel } = + crate::artifact::require(c)? + else { + return Err(ExecError::operation( + "install", + "verify", + "wrong Snap artifact type", + )); + }; + if entries.iter().any(|e| { + e.name == c.id + && e.revision == *revision + && c.version.as_deref() == Some(e.version.as_str()) + && (e.channel == *channel + || e.channel == "stable" && channel == "latest/stable") + }) { Ok(format!("verified: snap {} is installed", c.id)) } else { Err(ExecError::operation( @@ -974,16 +1035,54 @@ pub fn verify_installed(exec: &Exec, root: &Path, resolved: &ResolvedInstall) -> } } Backend::AppImage => { - crate::appimage::info(root, &c.id)?; + let record = crate::appimage::info(root, &c.id)?; + let binary = root + .join(crate::appimage::APPIMAGE_DIR) + .join(record.binary_name()); + if c.version.as_deref() != Some(record.version.as_str()) + || !crate::opencode::checksum_ok(&binary, &record.sha256)? + { + return Err(ExecError::operation( + "install", + "verify", + "managed AppImage bytes or version differ from the reviewed record", + )); + } Ok(format!("verified: managed AppImage {} has a record", c.id)) } - Backend::Nix => crate::nix::verify_profile_install(root, &c.id), + Backend::Nix => { + let phoebus_core::selection::InstallArtifact::Nix { store_path, .. } = + crate::artifact::require(c)? + else { + return Err(ExecError::operation( + "install", + "verify", + "wrong Nix artifact type", + )); + }; + if !crate::nix::installed_packages(root) + .packages + .iter() + .any(|p| p.profile == "profile" && p.store_path == *store_path) + { + return Err(ExecError::operation( + "install", + "verify", + "active Nix profile does not contain the reviewed store path", + )); + } + crate::nix::verify_profile_install(root, &c.id) + } Backend::CustomEbuild => { if phoebus_core::action::valid_ebuild_atom(&c.id) && chooser::installed_copies(exec, root, &resolved.request.application) .copies .iter() - .any(|x| x.backend == Backend::PortageSource.as_str()) + .any(|x| { + x.backend == Backend::PortageSource.as_str() + && x.id == c.id + && c.version.as_deref() == Some(x.version.as_str()) + }) { Ok(format!("verified: custom ebuild {} is installed", c.id)) } else { @@ -999,18 +1098,20 @@ pub fn verify_installed(exec: &Exec, root: &Path, resolved: &ResolvedInstall) -> /// A small helper so verification can run a plain host command. fn phoebus_executor_command(program: &str, args: &[&str]) -> crate::command::CommandSpec { - crate::command::CommandSpec::new("install", "verify", program).args(args.iter().copied()) + crate::command::CommandSpec::new("install", "verify", program) + .args(args.iter().copied()) + .timeout(std::time::Duration::from_secs(120)) } fn verification_plan(candidate: &Candidate) -> String { match candidate.backend { Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => { - "the Portage package database will be checked for the package after the merge".into() + "the Portage package database must report the reviewed package identity and version after the merge".into() } - Backend::Flatpak => "`flatpak list` will be checked for the application id".into(), - Backend::Snap => "`snap list` will be checked for the snap".into(), + Backend::Flatpak => "Flatpak must report the reviewed full ref and commit".into(), + Backend::Snap => "snapd must report the reviewed name, revision, version and channel".into(), Backend::AppImage => "the managed record and file will be checked".into(), - Backend::Nix => "the shared Nix profile and its commands will be checked".into(), + Backend::Nix => "the active Nix profile must contain the reviewed immutable store path and commands".into(), Backend::CustomEbuild => { "the Portage package database will be checked for the custom atom".into() } @@ -1058,7 +1159,7 @@ mod tests { assert_eq!(resolved.source, InstallSource::ExplicitBackend); assert!(matches!( resolved.action, - SystemAction::InstallPackage { ref atom, .. } if atom == "app-editors/vim" + SystemAction::InstallPackage { ref atom, .. } if atom == "=app-editors/vim-9.1.0" )); let _ = root; } @@ -1210,6 +1311,12 @@ mod tests { } else { Ok(ok(format!("org.mozilla.firefox {version}\n"))) } + } else if is_flatpak && spec.args.iter().any(|a| a == "remote-info") { + Ok(ok(if spec.args.iter().any(|a| a == "--show-ref") { + "app/org.mozilla.firefox/x86_64/stable\n".into() + } else { + format!("{}\n", "a".repeat(64)) + })) } else if is_flatpak && spec.args.iter().any(|a| a == "remotes") { let options = if self .remote_verified @@ -1495,4 +1602,52 @@ mod tests { let text = verify_installed(&exec, target.path(), &resolved).unwrap(); assert!(text.contains("Portage package database"), "{text}"); } + fn verification_fixture(candidate: Candidate, action: SystemAction) -> ResolvedInstall { + ResolvedInstall { + request: InstallRequest::new("vim"), + candidate, + action, + effects: ResolvedPlan::default(), + rationale: vec![], + alternatives: vec![], + source: InstallSource::ExplicitBackend, + warnings: vec![], + verification: String::new(), + } + } + + #[test] + fn installed_portage_verification_requires_exact_identity_and_version() { + let dir = tempfile::tempdir().unwrap(); + let vdb = dir.path().join("var/db/pkg"); + std::fs::create_dir_all(vdb.join("dev-util/vim-9.1.0")).unwrap(); + std::fs::create_dir_all(vdb.join("app-editors/vim-9.0.0")).unwrap(); + let exec = make_exec(RecordingRunner::new()); + let mut candidate = Candidate::new(Backend::PortageSource, "app-editors/vim", "gentoo"); + candidate.version = Some("9.1.0".into()); + let action = action_for(&exec, dir.path(), &candidate).unwrap(); + let resolved = verification_fixture(candidate, action); + assert!(verify_installed(&exec, dir.path(), &resolved).is_err()); + std::fs::create_dir_all(vdb.join("app-editors/vim-9.1.0")).unwrap(); + assert!(verify_installed(&exec, dir.path(), &resolved).is_ok()); + } + + #[test] + fn installed_flatpak_verification_refuses_the_right_app_at_the_wrong_commit() { + use phoebus_core::selection::InstallArtifact; + let runner = RecordingRunner::new(); + let exec = make_exec(runner.clone()); + let mut candidate = Candidate::new(Backend::Flatpak, "org.example.App", "flathub"); + let reference = "app/org.example.App/x86_64/stable"; + candidate.artifact = Some(InstallArtifact::Flatpak { + reference: reference.into(), + commit: "a".repeat(64), + }); + let action = action_for(&exec, Path::new("/"), &candidate).unwrap(); + let resolved = verification_fixture(candidate, action); + runner.set_response("flatpak", ok(&format!("{reference}\n{}\n", "b".repeat(64)))); + assert!(verify_installed(&exec, Path::new("/"), &resolved).is_err()); + runner.set_response("flatpak", ok(&format!("{reference}\n{}\n", "a".repeat(64)))); + assert!(verify_installed(&exec, Path::new("/"), &resolved).is_ok()); + } } diff --git a/installer-rs/crates/phoebus-executor/src/lib.rs b/installer-rs/crates/phoebus-executor/src/lib.rs index 7a2ec20..2ddcf89 100644 --- a/installer-rs/crates/phoebus-executor/src/lib.rs +++ b/installer-rs/crates/phoebus-executor/src/lib.rs @@ -9,6 +9,7 @@ pub mod admin; pub mod agent_jail; pub mod ai; pub mod appimage; +pub mod artifact; pub mod auth; pub mod boot; pub mod boot_assessment; @@ -19,6 +20,7 @@ pub mod desktop_config; pub mod ebuild; pub mod encryption; pub mod error; +pub mod evidence; pub mod exec; pub mod install; pub mod kernel; diff --git a/installer-rs/crates/phoebus-executor/src/opencode_client.rs b/installer-rs/crates/phoebus-executor/src/opencode_client.rs index 02f855d..2b1e10b 100644 --- a/installer-rs/crates/phoebus-executor/src/opencode_client.rs +++ b/installer-rs/crates/phoebus-executor/src/opencode_client.rs @@ -154,6 +154,7 @@ impl HttpClient for CurlHttpClient<'_> { fn request(&self, request: &HttpRequest) -> Result { let mut temp: Option = None; let data_line = if let Some(body) = &request.body { + let body = self.exec.redactor().redact(body); if self.sandboxed { // Inline the body (escaped) into the curl config: the sandbox's // PrivateTmp would hide a temp file created here. @@ -238,18 +239,23 @@ impl HttpClient for CurlHttpClient<'_> { ); let out = if self.sandboxed { - crate::sandbox::run( + crate::sandbox::run_bounded( self.exec, "curl", - &["-sS".into(), "-K".into(), "-".into()], + &["--disable".into(), "-sS".into(), "-K".into(), "-".into()], config.into_bytes(), + request.max_body as usize + 128, + request.timeout.saturating_add(Duration::from_secs(30)), ) .map_err(|e| AiError::Provider(format!("transport error: {e}")))? } else { self.exec .run( CommandSpec::new("ai", "OpenCode request", "curl") - .args(["-sS", "-K", "-"]) + .args(["--disable", "-sS", "-K", "-"]) + .sensitive_output() + .output_limit(request.max_body as usize + 128) + .timeout(request.timeout.saturating_add(Duration::from_secs(30))) .stdin(config.into_bytes()), ) .map_err(|e| AiError::Provider(format!("transport error: {e}")))? @@ -476,8 +482,12 @@ pub fn parse_catalog(body: &str) -> Result { "provider catalog was not the expected object".into(), )); } - let parsed: ProviderCatalogBody = serde_json::from_value(value) - .map_err(|e| AiError::Provider(format!("provider catalog was not usable: {e}")))?; + let parsed: ProviderCatalogBody = serde_json::from_value(value).map_err(|e| { + AiError::Provider(format!( + "provider catalog schema was not usable ({:?})", + e.classify() + )) + })?; Ok(parsed.into_catalog()) } @@ -1257,4 +1267,42 @@ mod tests { assert_eq!(body["parts"][0]["type"], "text"); assert_eq!(body["parts"][0]["text"], "user prompt"); } + #[test] + fn unregistered_catalog_credentials_are_never_logged_or_attached_to_errors() { + let dir = tempfile::tempdir().unwrap(); + let runner = RecordingRunner::new(); + for success in [true, false] { + runner.set_response( + "curl", + CommandOutput { + status: if success { 0 } else { 22 }, + success, + stdout: b"{\"key\":\"synthetic-unregistered-token\"}\n__PHOEBUS_STATUS__200" + .to_vec(), + stderr: b"synthetic-unregistered-token".to_vec(), + duration: std::time::Duration::ZERO, + }, + ); + let logger = crate::log::Logger::open(dir.path().join("log"), Redactor::new(), false); + let exec = crate::exec::Exec::new( + Box::new(runner.clone()), + logger, + false, + dir.path(), + dir.path(), + ); + let result = CurlHttpClient::new(&exec) + .request(&HttpRequest::get("http://127.0.0.1:4096/provider")); + if success { + assert!(result.is_ok()); + } else { + assert!( + !format!("{:?}", result.unwrap_err()).contains("synthetic-unregistered-token") + ); + } + assert!(!std::fs::read_to_string(dir.path().join("log")) + .unwrap() + .contains("synthetic-unregistered-token")); + } + } } diff --git a/installer-rs/crates/phoebus-executor/src/personal.rs b/installer-rs/crates/phoebus-executor/src/personal.rs index 22b2604..4df1309 100644 --- a/installer-rs/crates/phoebus-executor/src/personal.rs +++ b/installer-rs/crates/phoebus-executor/src/personal.rs @@ -43,25 +43,7 @@ pub fn initiating_uid() -> u32 { } pub fn effective_uid() -> u32 { - // Read the effective uid from /proc without unsafe or a subprocess. The - // second field of `Uid:` is the effective uid. - if let Ok(status) = std::fs::read_to_string("/proc/self/status") { - for line in status.lines() { - if let Some(rest) = line.strip_prefix("Uid:") { - if let Some(effective) = rest.split_whitespace().nth(1) { - if let Ok(uid) = effective.parse::() { - return uid; - } - } - } - } - } - std::process::Command::new("id") - .arg("-u") - .output() - .ok() - .and_then(|o| String::from_utf8_lossy(&o.stdout).trim().parse().ok()) - .unwrap_or(1) + rustix::process::geteuid().as_raw() } /// Look up a user's home directory from the passwd database. `$HOME` is not diff --git a/installer-rs/crates/phoebus-executor/src/query.rs b/installer-rs/crates/phoebus-executor/src/query.rs index 257bce4..989eb00 100644 --- a/installer-rs/crates/phoebus-executor/src/query.rs +++ b/installer-rs/crates/phoebus-executor/src/query.rs @@ -69,7 +69,8 @@ fn capture( program: &str, args: &[&str], ) -> std::result::Result { - exec.runner.execute(&spec(root, program, args)) + exec.runner + .execute(&spec(root, program, args).timeout(std::time::Duration::from_secs(120))) } /// Run a mutating command against the intended system. diff --git a/installer-rs/crates/phoebus-executor/src/sandbox.rs b/installer-rs/crates/phoebus-executor/src/sandbox.rs index 321f1d5..e9b055f 100644 --- a/installer-rs/crates/phoebus-executor/src/sandbox.rs +++ b/installer-rs/crates/phoebus-executor/src/sandbox.rs @@ -23,6 +23,9 @@ pub const SANDBOX_PROPERTIES: &[&str] = &[ "DynamicUser=yes", "ProtectSystem=strict", "ProtectHome=yes", + "PrivateUsers=yes", + "ProtectProc=invisible", + "ProcSubset=pid", "PrivateDevices=yes", "PrivateTmp=yes", "NoNewPrivileges=yes", @@ -37,25 +40,18 @@ pub const SANDBOX_PROPERTIES: &[&str] = &[ "SystemCallFilter=@system-service", ]; -/// The subset of [`SANDBOX_PROPERTIES`] accepted by the **user** manager. -/// -/// `DynamicUser`, `PrivateDevices` and `ProtectKernelModules` are -/// system-manager-only; `systemd-run --user` rejects them. The remaining set -/// still gives an unprivileged model call a read-only system, no home access, -/// no new privileges and a restricted syscall/address-family set. +/// User-manager process restrictions. Filesystem and PID isolation are +/// established explicitly by Bubblewrap: systemd's filesystem settings can +/// imply a user namespace that prevents Bubblewrap from creating its own jail. +/// There is no fallback to a plain process if namespace creation fails. pub const USER_SANDBOX_PROPERTIES: &[&str] = &[ - "ProtectSystem=strict", - "ProtectHome=yes", - "PrivateTmp=yes", "NoNewPrivileges=yes", - "ProtectKernelTunables=yes", - "ProtectControlGroups=yes", - "RestrictNamespaces=yes", + "RestrictNamespaces=user mnt pid ipc uts", "LockPersonality=yes", "MemoryDenyWriteExecute=yes", "SystemCallArchitectures=native", "RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6", - "SystemCallFilter=@system-service", + "SystemCallFilter=@system-service @mount", ]; /// Whether `systemd-run` is available to build the boundary. @@ -81,6 +77,9 @@ fn build_argv(program: &str, args: &[String], user: bool, properties: &[&str]) - "--pipe".into(), "--collect".into(), "--service-type=exec".into(), + "--property=WorkingDirectory=/".into(), + "--property=MemoryMax=256M".into(), + "--property=TasksMax=64".into(), ]; if user { out.push("--user".into()); @@ -88,7 +87,61 @@ fn build_argv(program: &str, args: &[String], user: bool, properties: &[&str]) - for property in properties { out.push(format!("--property={property}")); } - out.push(program.to_string()); + out.extend( + ["/usr/bin/env", "-i", "PATH=/usr/bin:/bin", "LANG=C.UTF-8"] + .iter() + .map(|s| s.to_string()), + ); + if user { + // User-manager filesystem properties may be silently ineffective on + // older systemd versions. An explicit namespace jail is mandatory. + out.extend(model_jail_argv(program, args)); + } else { + out.push(program.to_string()); + out.extend(args.iter().cloned()); + } + out +} + +/// Minimal model runtime: no home, host process view, user runtime sockets or +/// inherited environment. The network is shared for remote/loopback providers. +fn model_jail_argv(program: &str, args: &[String]) -> Vec { + let mut out: Vec = [ + "/usr/bin/bwrap", + "--die-with-parent", + "--unshare-user", + "--unshare-pid", + "--unshare-ipc", + "--unshare-uts", + "--new-session", + "--cap-drop", + "ALL", + "--clearenv", + "--dev", + "/dev", + "--proc", + "/proc", + "--tmpfs", + "/tmp", + "--chdir", + "/", + "--setenv", + "PATH", + "/usr/bin:/bin", + "--setenv", + "LANG", + "C.UTF-8", + ] + .iter() + .map(|s| s.to_string()) + .collect(); + for dir in ["/usr", "/bin", "/sbin", "/lib", "/lib64", "/etc"] { + if Path::new(dir).exists() { + out.extend(["--ro-bind".into(), dir.into(), dir.into()]); + } + } + out.push("--".into()); + out.push(program.into()); out.extend(args.iter().cloned()); out } @@ -112,6 +165,24 @@ pub fn run( program: &str, args: &[String], stdin: Vec, +) -> Result { + run_bounded( + exec, + program, + args, + stdin, + 16 * 1024 * 1024, + std::time::Duration::from_secs(crate::ai::ai_timeout_secs().saturating_add(60)), + ) +} + +pub fn run_bounded( + exec: &Exec, + program: &str, + args: &[String], + stdin: Vec, + output_limit: usize, + timeout: std::time::Duration, ) -> Result { if !available() { return Err(ExecError::MissingTool( @@ -119,14 +190,28 @@ pub fn run( .into(), )); } - let wrapped = if user_scope() { + if user_scope() && !Path::new("/usr/bin/bwrap").is_file() { + return Err(ExecError::MissingTool( + "Bubblewrap (required for the unprivileged model filesystem boundary)".into(), + )); + } + let mut wrapped = if user_scope() { user_argv(program, args) } else { argv(program, args) }; + // The manager owns the actual worker, so killing only systemd-run on a + // deadline is insufficient. Bound the service itself as well. + wrapped.insert( + 0, + format!("--property=RuntimeMaxSec={}s", timeout.as_secs().max(1)), + ); exec.run( CommandSpec::new("ai", "query model (sandboxed)", "systemd-run") .args(wrapped) + .sensitive_output() + .output_limit(output_limit) + .timeout(timeout) .stdin(stdin), ) } @@ -162,9 +247,6 @@ mod tests { let args = user_argv("curl", &["-sS".into(), "-K".into(), "-".into()]); assert!(args.iter().any(|a| a == "--user"), "{args:?}"); for required in [ - "ProtectSystem=strict", - "ProtectHome=yes", - "PrivateTmp=yes", "NoNewPrivileges=yes", "RestrictAddressFamilies=", "SystemCallFilter=@system-service", @@ -174,7 +256,12 @@ mod tests { "missing {required}: {args:?}" ); } - // Properties the user manager rejects must never be passed. + assert!(args.iter().any(|a| a == "/usr/bin/bwrap")); + assert!(args.iter().any(|a| a == "--unshare-pid")); + assert!(args.iter().any(|a| a == "--clearenv")); + assert!(args.windows(3).any(|w| w == ["--ro-bind", "/etc", "/etc"])); + assert!(!args.iter().any(|a| a == "/home" || a == "/root")); + // System-manager-only properties must never be passed. for forbidden in [ "DynamicUser=yes", "PrivateDevices=yes", diff --git a/installer-rs/crates/phoebus-executor/src/snap.rs b/installer-rs/crates/phoebus-executor/src/snap.rs index f82a696..03c5a9a 100644 --- a/installer-rs/crates/phoebus-executor/src/snap.rs +++ b/installer-rs/crates/phoebus-executor/src/snap.rs @@ -202,8 +202,24 @@ pub fn list(exec: &Exec) -> Result> { /// Install a snap. Classic confinement must be requested explicitly by the /// caller and is surfaced in the reviewed plan. pub fn install(exec: &Exec, name: &str, channel: Option<&str>, classic: bool) -> Result { + install_revision(exec, name, channel, classic, None) +} + +pub fn install_revision( + exec: &Exec, + name: &str, + channel: Option<&str>, + classic: bool, + revision: Option<&str>, +) -> Result { let _ = require_ready(exec)?; let mut args = vec!["install".to_string(), name.to_string()]; + if let Some(revision) = revision { + if revision.is_empty() || !revision.bytes().all(|b| b.is_ascii_digit()) { + return Err(ExecError::operation("snap", "install", "invalid revision")); + } + args.push(format!("--revision={revision}")); + } if let Some(channel) = channel { args.push(format!("--channel={channel}")); } diff --git a/installer-rs/crates/phoebus-executor/src/system_lock.rs b/installer-rs/crates/phoebus-executor/src/system_lock.rs index 671abc2..1bc5e0f 100644 --- a/installer-rs/crates/phoebus-executor/src/system_lock.rs +++ b/installer-rs/crates/phoebus-executor/src/system_lock.rs @@ -1,25 +1,16 @@ -//! Inter-process system mutation lock. -//! -//! Ensures that only one mutating `sys` action runs at a time, preventing -//! transaction log corruption, Btrfs snapshot timestamp collisions, and -//! conflicting package manager operations. -//! -//! Uses atomic `O_CREAT | O_EXCL` file creation with automatic stale-lock recovery -//! (detects if the owning PID is no longer alive via `/proc/`). - -use std::fs::{self, OpenOptions}; -use std::io::Write; -use std::path::{Path, PathBuf}; -use std::time::{SystemTime, UNIX_EPOCH}; +//! Kernel-owned mutation lock. The inode is persistent, acquisition is atomic, +//! and process exit releases ownership without PID guessing or stale unlinking. use crate::error::{ExecError, Result}; use crate::exec::Exec; +use std::fs::File; +use std::io::Write; +use std::path::{Path, PathBuf}; pub const DEFAULT_LOCK_REL: &str = "run/phoebus/sys.lock"; - #[derive(Debug)] pub struct SystemLock { - lock_path: PathBuf, + _file: File, } #[derive(Debug, Clone, PartialEq, Eq)] @@ -28,7 +19,6 @@ struct LockInfo { created_unix: u64, operation: String, } - impl LockInfo { fn serialize(&self) -> String { format!( @@ -36,139 +26,72 @@ impl LockInfo { self.pid, self.created_unix, self.operation ) } - + #[cfg(test)] fn parse(text: &str) -> Option { - let mut pid = None; - let mut created_unix = None; - let mut operation = None; - - for line in text.lines() { - if let Some(val) = line.strip_prefix("pid=") { - pid = val.trim().parse::().ok(); - } else if let Some(val) = line.strip_prefix("created_unix=") { - created_unix = val.trim().parse::().ok(); - } else if let Some(val) = line.strip_prefix("operation=") { - operation = Some(val.trim().to_string()); - } - } - + let value = |key: &str| text.lines().find_map(|line| line.strip_prefix(key)); Some(Self { - pid: pid?, - created_unix: created_unix?, - operation: operation.unwrap_or_else(|| "unspecified operation".to_string()), + pid: value("pid=")?.parse().ok()?, + created_unix: value("created_unix=")?.parse().ok()?, + operation: value("operation=")?.into(), }) } } - fn now_unix() -> u64 { - SystemTime::now() - .duration_since(UNIX_EPOCH) + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) .map(|d| d.as_secs()) .unwrap_or(0) } - -fn is_pid_alive(pid: u32) -> bool { - if pid == 0 { - return false; - } - Path::new("/proc").join(pid.to_string()).exists() -} - pub fn lock_path(root: &Path) -> PathBuf { root.join(DEFAULT_LOCK_REL) } - impl SystemLock { - /// Attempt to acquire the system mutation lock for `operation`. + pub(crate) fn worker_lease(&self) -> Result { + rustix::io::fcntl_dupfd_cloexec(&self._file, 3) + .map(File::from) + .map_err(|e| ExecError::operation("sys", "lease mutation lock", e.to_string())) + } pub fn acquire(exec: &Exec, root: &Path, operation: &str) -> Result { let path = lock_path(root); - Self::acquire_at(exec, path, operation) + let file = phoebus_core::TargetRoot::new(root) + .open_lock_file(DEFAULT_LOCK_REL) + .map_err(|e| ExecError::operation("sys", "open mutation lock", e.to_string()))?; + Self::claim(exec, file, &path, operation) } - - /// Attempt to acquire the lock at an explicit path (used by tests and alternate paths). pub fn acquire_at(exec: &Exec, path: PathBuf, operation: &str) -> Result { - if let Some(parent) = path.parent() { - fs::create_dir_all(parent).map_err(|e| ExecError::io(parent.to_path_buf(), e))?; - } - - let my_pid = std::process::id(); - let now = now_unix(); - let info = LockInfo { - pid: my_pid, - created_unix: now, - operation: operation.to_string(), - }; - - match Self::try_create(&path, &info) { - Ok(()) => { - exec.logger.info(format!( - "acquired system lock at {} for `{operation}`", - path.display() - )); - Ok(Self { lock_path: path }) - } - Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => { - // Check if existing lock is stale - if let Ok(content) = fs::read_to_string(&path) { - if let Some(existing) = LockInfo::parse(&content) { - if !is_pid_alive(existing.pid) { - exec.logger.warn(format!( - "detected stale system lock held by dead PID {}; breaking lock", - existing.pid - )); - let _ = fs::remove_file(&path); - // Retry atomic creation once - if Self::try_create(&path, &info).is_ok() { - exec.logger.info(format!( - "reclaimed stale system lock at {} for `{operation}`", - path.display() - )); - return Ok(Self { lock_path: path }); - } - } else { - return Err(ExecError::operation( - "sys", - "acquire system lock", - format!( - "another Phoebus system mutation is currently in progress: `{}` (PID {}, started {}s ago)", - existing.operation, - existing.pid, - now.saturating_sub(existing.created_unix) - ), - )); - } - } - } - Err(ExecError::operation( + let parent = path + .parent() + .ok_or_else(|| ExecError::operation("sys", "lock", "lock has no parent"))?; + let name = path + .file_name() + .ok_or_else(|| ExecError::operation("sys", "lock", "lock has no name"))?; + let file = phoebus_core::TargetRoot::new(parent) + .open_lock_file(&name.to_string_lossy()) + .map_err(|e| ExecError::operation("sys", "open mutation lock", e.to_string()))?; + Self::claim(exec, file, &path, operation) + } + fn claim(exec: &Exec, mut file: File, path: &Path, operation: &str) -> Result { + rustix::fs::flock(&file, rustix::fs::FlockOperation::NonBlockingLockExclusive).map_err( + |e| { + ExecError::operation( "sys", "acquire system lock", - format!( - "another Phoebus system mutation is currently in progress (lockfile present at {})", - path.display() - ), - )) - } - Err(e) => Err(ExecError::io(path, e)), - } - } - - fn try_create(path: &Path, info: &LockInfo) -> std::io::Result<()> { - let mut file = OpenOptions::new().write(true).create_new(true).open(path)?; - file.write_all(info.serialize().as_bytes())?; - file.flush()?; - Ok(()) - } -} - -impl Drop for SystemLock { - fn drop(&mut self) { - if let Ok(content) = fs::read_to_string(&self.lock_path) { - if let Some(info) = LockInfo::parse(&content) { - if info.pid == std::process::id() { - let _ = fs::remove_file(&self.lock_path); - } - } - } + format!("another Phoebus system mutation is currently in progress ({e})"), + ) + }, + )?; + let info = LockInfo { + pid: std::process::id(), + created_unix: now_unix(), + operation: operation.into(), + }; + file.set_len(0) + .and_then(|_| file.write_all(info.serialize().as_bytes())) + .and_then(|_| file.sync_all()) + .map_err(|e| ExecError::io(path, e))?; + exec.logger + .info(format!("acquired system lock for `{operation}`")); + Ok(Self { _file: file }) } } @@ -178,6 +101,7 @@ mod tests { use crate::command::RecordingRunner; use crate::log::Logger; use phoebus_core::Redactor; + use std::fs; fn make_exec() -> Exec { let path = tempfile::tempdir().unwrap().keep(); @@ -208,15 +132,15 @@ mod tests { drop(lock); } - // After drop, lock file is cleaned up and can be acquired again - assert!(!lock_file.exists()); + // The inode remains; the kernel releases the lock with its descriptor. + assert!(lock_file.exists()); let lock2 = SystemLock::acquire_at(&exec, lock_file.clone(), "install emacs").unwrap(); assert!(lock_file.exists()); drop(lock2); } #[test] - fn stale_lock_is_reclaimed_when_process_is_dead() { + fn diagnostic_pid_never_controls_lock_ownership() { let temp = tempfile::tempdir().unwrap(); let lock_file = temp.path().join("sys.lock"); let exec = make_exec(); @@ -229,7 +153,7 @@ mod tests { }; fs::write(&lock_file, stale_info.serialize()).unwrap(); - // Acquisition should detect dead PID and reclaim + // An unheld inode is available regardless of the diagnostic PID. let lock = SystemLock::acquire_at(&exec, lock_file.clone(), "new install").unwrap(); assert!(lock_file.exists()); let content = fs::read_to_string(&lock_file).unwrap(); @@ -238,4 +162,109 @@ mod tests { assert_eq!(parsed.operation, "new install"); drop(lock); } + #[test] + fn lock_child_helper() { + let Some(path) = std::env::var_os("PHOEBUS_LOCK_TEST_PATH") else { + return; + }; + let exec = make_exec(); + let _lock = SystemLock::acquire_at(&exec, path.into(), "child fixture").unwrap(); + println!("LOCK_READY"); + std::io::stdout().flush().unwrap(); + std::thread::sleep(std::time::Duration::from_secs(20)); + } + + #[test] + fn crashing_owner_releases_the_same_inode_without_unlinking() { + use std::io::{BufRead, BufReader}; + use std::os::unix::fs::MetadataExt; + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("lock"); + let mut child = std::process::Command::new(std::env::current_exe().unwrap()) + .args([ + "--exact", + "system_lock::tests::lock_child_helper", + "--nocapture", + ]) + .env("PHOEBUS_LOCK_TEST_PATH", &path) + .stdout(std::process::Stdio::piped()) + .spawn() + .unwrap(); + let mut stdout = BufReader::new(child.stdout.take().unwrap()); + let mut line = String::new(); + loop { + line.clear(); + assert!(stdout.read_line(&mut line).unwrap() > 0); + if line.contains("LOCK_READY") { + break; + } + } + let inode = std::fs::metadata(&path).unwrap().ino(); + let exec = make_exec(); + assert!(SystemLock::acquire_at(&exec, path.clone(), "competitor").is_err()); + child.kill().unwrap(); + child.wait().unwrap(); + let _next = SystemLock::acquire_at(&exec, path.clone(), "recovery").unwrap(); + assert_eq!(std::fs::metadata(path).unwrap().ino(), inode); + } + #[test] + fn lease_owner_helper() { + let Some(root) = std::env::var_os("PHOEBUS_LEASE_ROOT") else { + return; + }; + let root = PathBuf::from(root); + let runner = crate::command::RealRunner::with_sink(std::sync::Arc::new(|s| { + print!("{s}"); + std::io::stdout().flush().unwrap(); + })); + let exec = Exec::new( + Box::new(runner), + Logger::open(root.join("log"), Redactor::new(), false), + false, + &root, + &root, + ); + let _lock = exec.lock_mutation(&root, "worker lease fixture").unwrap(); + exec.run(crate::command::CommandSpec::new("test", "leased worker", "python3") + .args(["-c", "import os,time; print('WORKER_READY',flush=True); deadline=time.monotonic()+10; release=os.environ['PHOEBUS_LEASE_RELEASE']; exec('while not os.path.exists(release) and time.monotonic() 0); + if line.contains("WORKER_READY") { + break; + } + } + broker.kill().unwrap(); + broker.wait().unwrap(); + let exec = make_exec(); + assert!(SystemLock::acquire(&exec, dir.path(), "competitor").is_err()); + std::fs::write(dir.path().join("release"), "release worker").unwrap(); + let start = std::time::Instant::now(); + loop { + if SystemLock::acquire(&exec, dir.path(), "after worker").is_ok() { + break; + } + assert!(start.elapsed() < std::time::Duration::from_secs(5)); + std::thread::sleep(std::time::Duration::from_millis(10)); + } + } } diff --git a/installer-rs/crates/phoebus-executor/tests/isolation_acceptance.rs b/installer-rs/crates/phoebus-executor/tests/isolation_acceptance.rs new file mode 100644 index 0000000..d245da9 --- /dev/null +++ b/installer-rs/crates/phoebus-executor/tests/isolation_acceptance.rs @@ -0,0 +1,183 @@ +//! Negative acceptance tests. Run explicitly on a Linux host with working +//! user namespaces, Bubblewrap and a systemd user manager. Only disposable +//! fixture files in the repository and /tmp are created. +use phoebus_executor::agent_jail::{prepare_jail, AgentJailConfig}; +use std::process::Command; + +#[test] +#[ignore = "requires real Bubblewrap user namespaces"] +fn developer_jail_denies_private_files_environment_processes_and_network() { + let temp = tempfile::tempdir().unwrap(); + let home = temp.path().join("home"); + let workspace = home.join("workspace"); + std::fs::create_dir_all(home.join(".ssh")).unwrap(); + std::fs::create_dir(&workspace).unwrap(); + std::fs::write(home.join("private"), "synthetic credential").unwrap(); + std::fs::write(home.join(".ssh/key"), "synthetic key").unwrap(); + let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + let port = listener.local_addr().unwrap().port(); + let script = format!( + r#" +import os, socket +home = {home:?} +ws = {workspace:?} +assert 'PHOEBUS_SYNTHETIC_CREDENTIAL' not in os.environ +for path in [home+'/private', home+'/.ssh/key', '/proc/{pid}/environ']: + try: + open(path).read() + except (FileNotFoundError, PermissionError): + pass + else: + raise AssertionError('private path readable: '+path) +assert os.statvfs('/etc').f_flag & os.ST_RDONLY +with open(ws+'/allowed', 'w') as f: f.write('workspace allowed') +s = socket.socket() +s.settimeout(1) +try: + s.connect(('127.0.0.1', {port})) +except OSError: + pass +else: + raise AssertionError('host network reachable') +print('denials passed') +"#, + home = home.to_string_lossy(), + workspace = workspace.to_string_lossy(), + pid = std::process::id() + ); + let config = AgentJailConfig { + workspace: workspace.clone(), + allow_network: false, + allow_nix_store: false, + extra_masked_subdirs: vec![], + }; + let jail = prepare_jail(&config, &home, "/usr/bin/python3", &["-c".into(), script]).unwrap(); + // Replace the reviewed pathname after preparation. The jail must bind the + // original directory, never the credential directory behind the new link. + let original = home.join("original-workspace"); + std::fs::rename(&workspace, &original).unwrap(); + std::os::unix::fs::symlink(home.join(".ssh"), &workspace).unwrap(); + let out = Command::new("bwrap") + .args(&jail.argv) + .env("PHOEBUS_SYNTHETIC_CREDENTIAL", "synthetic") + .output() + .unwrap(); + assert!( + out.status.success(), + "{}\n{}", + String::from_utf8_lossy(&out.stdout), + String::from_utf8_lossy(&out.stderr) + ); + assert_eq!( + std::fs::read_to_string(original.join("allowed")).unwrap(), + "workspace allowed" + ); + assert_eq!( + std::fs::read_to_string(home.join("private")).unwrap(), + "synthetic credential" + ); +} + +#[test] +#[ignore = "requires real systemd user namespace hardening"] +fn model_unit_denies_home_environment_processes_and_writes() { + // This location is beneath the account's home in the development checkout, + // so ProtectHome must hide it. No account credential is read by the probe. + let root = std::env::var_os("PHOEBUS_ISOLATION_FIXTURE_ROOT") + .map(std::path::PathBuf::from) + .unwrap_or_else(|| { + std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .ancestors() + .nth(3) + .unwrap() + .to_path_buf() + }); + let fixture = tempfile::Builder::new() + .prefix(".isolation-fixture-") + .tempdir_in(&root) + .unwrap(); + let private = fixture.path().join("private"); + std::fs::write(&private, "synthetic").unwrap(); + let home = + phoebus_executor::personal::home_for_uid(phoebus_executor::personal::effective_uid()) + .unwrap(); + assert!( + private.starts_with(home), + "acceptance fixture must be under the account home" + ); + let script = format!( + r#" +import os +assert 'PHOEBUS_SYNTHETIC_CREDENTIAL' not in os.environ +for path in [{private:?}, '/proc/{pid}/environ']: + try: + open(path).read() + except (FileNotFoundError, PermissionError): + pass + else: + raise AssertionError('private path readable: '+path) +assert os.statvfs('/etc').f_flag & os.ST_RDONLY +print('denials passed') +"#, + private = private.to_string_lossy(), + pid = std::process::id() + ); + let args = phoebus_executor::sandbox::user_argv("/usr/bin/python3", &["-c".into(), script]); + let out = Command::new("systemd-run") + .args(args) + .env("PHOEBUS_SYNTHETIC_CREDENTIAL", "synthetic") + .output() + .unwrap(); + assert!( + out.status.success(), + "{}\n{}", + String::from_utf8_lossy(&out.stdout), + String::from_utf8_lossy(&out.stderr) + ); + assert!(String::from_utf8_lossy(&out.stdout).contains("denials passed")); +} + +#[test] +#[ignore = "requires root and a real systemd system manager"] +fn model_system_unit_denies_root_home_environment_and_writes() { + assert_eq!( + phoebus_executor::personal::effective_uid(), + 0, + "run this probe only as root in a disposable VM" + ); + let fixture = tempfile::Builder::new() + .prefix(".phoebus-isolation-") + .tempdir_in("/root") + .unwrap(); + let private = fixture.path().join("private"); + std::fs::write(&private, "synthetic").unwrap(); + let script = format!( + r#" +import os +assert 'PHOEBUS_SYNTHETIC_CREDENTIAL' not in os.environ +assert os.geteuid() != 0 +try: + open({private:?}).read() +except (FileNotFoundError, PermissionError): + pass +else: + raise AssertionError('root home readable') +assert os.statvfs('/etc').f_flag & os.ST_RDONLY +print('denials passed') +"#, + private = private.to_string_lossy() + ); + let args = phoebus_executor::sandbox::argv("/usr/bin/python3", &["-c".into(), script]); + let out = Command::new("systemd-run") + .args(args) + .env("PHOEBUS_SYNTHETIC_CREDENTIAL", "synthetic") + .output() + .unwrap(); + assert!( + out.status.success(), + "{}\n{}", + String::from_utf8_lossy(&out.stdout), + String::from_utf8_lossy(&out.stderr) + ); + assert!(String::from_utf8_lossy(&out.stdout).contains("denials passed")); +} diff --git a/installer-rs/crates/phoebus-installer/src/bin/phoebus-agent-run.rs b/installer-rs/crates/phoebus-installer/src/bin/phoebus-agent-run.rs index eca209c..70bb7c8 100644 --- a/installer-rs/crates/phoebus-installer/src/bin/phoebus-agent-run.rs +++ b/installer-rs/crates/phoebus-installer/src/bin/phoebus-agent-run.rs @@ -63,13 +63,16 @@ fn main() -> ExitCode { return ExitCode::FAILURE; } - let home = match std::env::var("HOME").map(PathBuf::from) { - Ok(h) => h, - Err(_) => { - eprintln!("phoebus-agent-run: error: HOME environment variable is not set."); - return ExitCode::FAILURE; - } - }; + let home = + match phoebus_executor::personal::home_for_uid(phoebus_executor::personal::effective_uid()) + .and_then(|p| p.canonicalize().ok()) + { + Some(h) => h, + None => { + eprintln!("phoebus-agent-run: cannot resolve the account's home directory"); + return ExitCode::FAILURE; + } + }; let canonical_ws = match cli.workspace.canonicalize() { Ok(p) => p, @@ -89,14 +92,34 @@ fn main() -> ExitCode { extra_masked_subdirs: cli.extra_masks, }; - let argv = build_jail_argv(&config, &home, &cli.program, &cli.args); + if phoebus_executor::personal::effective_uid() == 0 { + eprintln!("phoebus-agent-run: developer agents must run as an unprivileged user"); + return ExitCode::FAILURE; + } + let argv = match build_jail_argv(&config, &home, &cli.program, &cli.args) { + Ok(args) => args, + Err(e) => { + eprintln!("phoebus-agent-run: {e}"); + return ExitCode::FAILURE; + } + }; if cli.dry_run { println!("bwrap {}", argv.join(" ")); return ExitCode::SUCCESS; } - let status = std::process::Command::new("bwrap").args(&argv).status(); + let jail = + match phoebus_executor::agent_jail::prepare_jail(&config, &home, &cli.program, &cli.args) { + Ok(jail) => jail, + Err(e) => { + eprintln!("phoebus-agent-run: {e}"); + return ExitCode::FAILURE; + } + }; + let status = std::process::Command::new("bwrap") + .args(&jail.argv) + .status(); match status { Ok(s) => { diff --git a/installer-rs/crates/phoebus-installer/src/bin/sys.rs b/installer-rs/crates/phoebus-installer/src/bin/sys.rs index 4017b60..d9f52d4 100644 --- a/installer-rs/crates/phoebus-installer/src/bin/sys.rs +++ b/installer-rs/crates/phoebus-installer/src/bin/sys.rs @@ -229,12 +229,7 @@ fn record_transaction( } fn effective_uid() -> u32 { - std::process::Command::new("id") - .arg("-u") - .output() - .ok() - .and_then(|o| String::from_utf8_lossy(&o.stdout).trim().parse().ok()) - .unwrap_or(1) + phoebus_executor::personal::effective_uid() } /// Persist a minimized conversation turn with the process redactor, surfacing a @@ -763,6 +758,11 @@ fn execute_action( return Err("mutating actions require root; run `sudo sys ...`".into()); } + let _mutation = if action.requires_root() && exec.is_real() && !exec.dry_run { + Some(exec.lock_mutation(&cli.root, &action.describe())?) + } else { + None + }; let effects_phase = exec.progress_phase("Checking the exact effects"); let resolved = actions::resolve_effects(exec, &action, &cli.root); if resolved.is_ok() { diff --git a/installer-rs/crates/phoebus-installer/src/service/execution.rs b/installer-rs/crates/phoebus-installer/src/service/execution.rs index b730008..afb7612 100644 --- a/installer-rs/crates/phoebus-installer/src/service/execution.rs +++ b/installer-rs/crates/phoebus-installer/src/service/execution.rs @@ -69,6 +69,17 @@ pub fn execute_plan_privileged( assume_yes: bool, ) -> Result { let plan = plans.load(plan_id)?; + let _lock = if plan + .actions + .iter() + .any(phoebus_core::action::SystemAction::requires_root) + && exec.is_real() + && !exec.dry_run + { + Some(exec.lock_mutation(root, "execute reviewed plan")?) + } else { + None + }; // The expected digest is the independently preserved approval the user // reviewed. A self-consistent reseal of a replacement plan cannot match it. validate_prepared_plan(exec, root, &plan, Some(expected_digest), initiator_uid)?; @@ -158,6 +169,20 @@ fn execute_prepared( assume_yes: bool, approvals: Option<(&ApprovalLedger, u32)>, ) -> Result { + let _lock = if plan + .actions + .iter() + .any(phoebus_core::action::SystemAction::requires_root) + && exec.is_real() + && !exec.dry_run + { + Some(exec.lock_mutation(root, "execute reviewed plan")?) + } else { + None + }; + // The first validation may precede authentication. Repeat under the same + // lock held through claim, mutation, verification and terminal recording. + validate_prepared_plan(exec, root, &plan, Some(&plan.digest), plan.initiator_uid)?; // Authentication/refusal happens before any claim, so a refused plan is not // consumed and stays reviewable (until it expires). let confirm = ServiceConfirm { assume_yes }; @@ -340,7 +365,14 @@ fn execute_claimed( } else { None }; - match actions::execute_inner(exec, action, auth, root, carried) { + match actions::execute_inner_with_candidate( + exec, + action, + auth, + root, + carried, + plan.candidate.as_ref(), + ) { Ok(result) => { action_phase.complete(); if result.snapshot.is_some() { diff --git a/installer-rs/crates/phoebus-installer/src/service/mod.rs b/installer-rs/crates/phoebus-installer/src/service/mod.rs index 9bb0779..43848b6 100644 --- a/installer-rs/crates/phoebus-installer/src/service/mod.rs +++ b/installer-rs/crates/phoebus-installer/src/service/mod.rs @@ -265,12 +265,7 @@ fn now_unix() -> u64 { /// elevation, bypass the root-owned approval ledger, and execute a /// root-requiring plan in-process. pub fn effective_uid() -> u32 { - std::process::Command::new("id") - .arg("-u") - .output() - .ok() - .and_then(|o| String::from_utf8_lossy(&o.stdout).trim().parse().ok()) - .unwrap_or(1) + phoebus_executor::personal::effective_uid() } /// Canonicalise a target root so two spellings of the same path compare equal. @@ -345,4 +340,6 @@ pub use plan::{ plan_overlay, plan_removal, plan_removal_with_ai, plan_selected_install, select_removal_copy, PlanStore, }; -pub use validation::{compute_plan_digest, seal_plan, validate_prepared_plan}; +pub use validation::{ + approval_digest_for_plan, compute_plan_digest, seal_plan, validate_prepared_plan, +}; diff --git a/installer-rs/crates/phoebus-installer/src/service/plan.rs b/installer-rs/crates/phoebus-installer/src/service/plan.rs index 03ba43b..2944c8d 100644 --- a/installer-rs/crates/phoebus-installer/src/service/plan.rs +++ b/installer-rs/crates/phoebus-installer/src/service/plan.rs @@ -16,7 +16,7 @@ use phoebus_executor::error::{ExecError, Result}; use phoebus_executor::exec::Exec; use phoebus_executor::install::{self, AiInstall, InstallRequest}; -use super::validation::{compute_plan_digest, seal_plan}; +use super::validation::{approval_digest_for_plan, compute_plan_digest, seal_plan}; use super::{ canonical_root, effective_uid, fresh_plan_id, is_safe_plan_id, now_unix, random_token, PlanClaim, PlanKind, PreparedPlan, DEFAULT_PLAN_TTL_SECONDS, @@ -90,7 +90,7 @@ pub fn plan_overlay( initiator_uid: effective_uid(), integrity: String::new(), }; - plan.digest = compute_plan_digest(&plan.actions, None, &plan.effects, &plan.step_effects); + plan.digest = approval_digest_for_plan(&plan)?; plans.save(&mut plan)?; Ok(plan) } @@ -459,7 +459,7 @@ fn build_install_plan( let digest = resolved.approval_digest(); let actions = vec![resolved.action.clone()]; - let requires_root = resolved.action.is_mutating(); + let requires_root = resolved.action.requires_root(); // Normalize the stored effect digest so the per-step binding check sees a // digest that matches the contents. let mut effects = resolved.effects.clone(); @@ -495,6 +495,7 @@ fn build_install_plan( integrity: String::new(), }; + plan.digest = approval_digest_for_plan(&plan)?; plans.save(&mut plan)?; Ok(plan) } @@ -741,7 +742,7 @@ pub fn build_removal_plan( "verify that `{}` ({}) is completely removed from the system", target_copy.id, target_copy.backend ), - requires_root: action.is_mutating(), + requires_root: action.requires_root(), source: target_copy.backend.clone(), executed: false, target_root: canonical_root(root), @@ -749,6 +750,7 @@ pub fn build_removal_plan( integrity: String::new(), }; + plan.digest = approval_digest_for_plan(&plan)?; plans.save(&mut plan)?; Ok(plan) } @@ -869,16 +871,10 @@ pub fn plan_general( exec.progress_phase(&format!("Checking evidence for {}", request.describe())); let output = match constraint { Some(backend) => match constrain_action(request.clone(), backend) { - Ok(action) => match actions::execute(exec, &action, None, root) { - Ok(outcome) => outcome.output, - Err(e) => format!("investigation failed: {e}"), - }, + Ok(action) => phoebus_executor::evidence::investigate(exec, &action, root), Err(msg) => format!("refused by the source constraint: {msg}"), }, - None => match actions::execute(exec, request, None, root) { - Ok(outcome) => outcome.output, - Err(e) => format!("investigation failed: {e}"), - }, + None => phoebus_executor::evidence::investigate(exec, request, root), }; if !output.starts_with("investigation failed:") && !output.starts_with("refused by the source constraint:") @@ -949,7 +945,6 @@ pub fn plan_general( established: true, ..Default::default() }; - let mut any_mutating = false; let mut step_effects = Vec::new(); for act in &actions_list { @@ -974,7 +969,6 @@ pub fn plan_general( .extend(eff.consequences.clone()); } step_effects.push(eff); - any_mutating |= act.is_mutating(); } combined_effects.recompute_digest(); @@ -999,12 +993,12 @@ pub fn plan_general( alternatives: Vec::new(), rationale: rationale_strings, warnings: Vec::new(), - actions: actions_list, + actions: actions_list.clone(), effects: combined_effects, step_effects, digest, verification: "verify execution of planned actions".into(), - requires_root: any_mutating, + requires_root: actions_list.iter().any(SystemAction::requires_root), source: "AI Assistant".into(), executed: false, target_root: canonical_root(root), @@ -1013,6 +1007,7 @@ pub fn plan_general( }; if !plan.actions.is_empty() { + plan.digest = approval_digest_for_plan(&plan)?; plans.save(&mut plan)?; } Ok(plan) diff --git a/installer-rs/crates/phoebus-installer/src/service/tests.rs b/installer-rs/crates/phoebus-installer/src/service/tests.rs index aa4267c..ad7fef4 100644 --- a/installer-rs/crates/phoebus-installer/src/service/tests.rs +++ b/installer-rs/crates/phoebus-installer/src/service/tests.rs @@ -158,6 +158,10 @@ fn sealed( initiator_uid, integrity: String::new(), }; + plan.requires_root = plan.actions.iter().any(SystemAction::requires_root); + if !plan.actions.is_empty() { + plan.digest = approval_digest_for_plan(&plan).unwrap(); + } seal_plan(&mut plan); plan } @@ -529,6 +533,21 @@ impl phoebus_executor::command::ProcessRunner for FlatpakRunner { } else { Ok(ok("org.mozilla.firefox 128\n".into())) } + } else if is_flatpak && spec.args.iter().any(|a| a == "remote-info") { + Ok(ok(if spec.args.iter().any(|a| a == "--show-ref") { + "app/org.mozilla.firefox/x86_64/stable\n".into() + } else { + format!("{}\n", "a".repeat(64)) + })) + } else if is_flatpak && spec.args.iter().any(|a| a == "info") { + Ok(ok(if installed { + format!( + "app/org.mozilla.firefox/x86_64/stable\n{}\n", + "a".repeat(64) + ) + } else { + String::new() + })) } else if is_flatpak && spec.args.iter().any(|a| a == "remotes") { Ok(ok("flathub\thttps://dl.flathub.org/repo/\t\n".into())) } else if is_flatpak && spec.args.iter().any(|a| a == "list") { @@ -819,6 +838,8 @@ fn portage_install_plan( initiator_uid: uid, integrity: String::new(), }; + plan.requires_root = plan.actions.iter().any(SystemAction::requires_root); + plan.digest = approval_digest_for_plan(&plan).unwrap(); seal_plan(&mut plan); plan } @@ -1113,6 +1134,7 @@ fn stale_effects_between_validation_and_execution_abort_the_transaction() { let changed = parse_emerge_pretend(WGET_PRETEND); let runner = SequenceRunner { responses: std::sync::Mutex::new(vec![ + command_out(VIM_PRETEND, true), command_out(VIM_PRETEND, true), command_out(WGET_PRETEND, true), ]), @@ -1165,6 +1187,7 @@ fn effect_resolution_failure_after_transaction_begin_is_terminal() { let reviewed = parse_emerge_pretend(VIM_PRETEND); let runner = SequenceRunner { responses: std::sync::Mutex::new(vec![ + command_out(VIM_PRETEND, true), command_out(VIM_PRETEND, true), command_out("not valid emerge output\n", true), ]), @@ -1333,6 +1356,8 @@ fn canonical_plan( initiator_uid: uid, integrity: String::new(), }; + plan.requires_root = plan.actions.iter().any(SystemAction::requires_root); + plan.digest = approval_digest_for_plan(&plan).unwrap(); seal_plan(&mut plan); plan } @@ -1796,6 +1821,8 @@ fn general_portage_plan( initiator_uid: uid, integrity: String::new(), }; + plan.requires_root = plan.actions.iter().any(SystemAction::requires_root); + plan.digest = approval_digest_for_plan(&plan).unwrap(); seal_plan(&mut plan); plan } @@ -2262,3 +2289,78 @@ fn constrain_action_allows_spanning_non_package_actions() { // A Portage-only action is allowed when the constraint is Portage. assert!(constrain_action(SystemAction::UpdateSystem, Backend::PortageSource).is_ok()); } + +#[test] +fn approval_context_cannot_be_resealed_under_a_retained_digest() { + let root = tempdir().unwrap(); + let exec = make_test_exec(root.path()); + let uid = effective_uid(); + let reviewed = sealed( + "context-bound", + PlanKind::General, + vec![SystemAction::History], + "d", + root.path(), + uid, + ); + let approved = reviewed.digest.clone(); + for mutation in 0..7 { + let mut forged = reviewed.clone(); + match mutation { + 0 => forged.kind = PlanKind::Undo, + 1 => forged.expires_unix += 1, + 2 => forged.created_unix -= 1, + 3 => forged.target_root = "/".into(), + 4 => forged.initiator_uid = uid.wrapping_add(1), + 5 => forged.requires_root = !forged.requires_root, + _ => forged.source = "substituted".into(), + } + seal_plan(&mut forged); + let err = + validate_prepared_plan(&exec, root.path(), &forged, Some(&approved), uid).unwrap_err(); + assert!( + err.to_string().contains("digest") || err.to_string().contains("lifetime"), + "{mutation}: {err}" + ); + forged.digest = approval_digest_for_plan(&forged).unwrap(); + seal_plan(&mut forged); + assert!(validate_prepared_plan(&exec, root.path(), &forged, Some(&approved), uid).is_err()); + } +} + +#[test] +fn model_investigation_redacts_registered_secrets_before_the_next_model_turn() { + use phoebus_ai::provider::{chat_response, ScriptedTransport}; + let transport = ScriptedTransport::new(vec![ + chat_response( + r#"{"version":1,"kind":"investigate","requests":[{"action":"inspect_service","name":"sshd"}]}"#, + ), + chat_response(r#"{"version":1,"summary":"Service inspected.","actions":[]}"#), + ]); + let runner = phoebus_executor::command::RecordingRunner::new(); + runner.set_response( + "systemctl", + command_out( + "ActiveState=active\nResult=synthetic-service-token\n/home/test/private\n", + true, + ), + ); + let exec = make_exec_with_runner(Path::new("/"), Box::new(runner)); + exec.register_secret(&phoebus_core::SecretString::new("synthetic-service-token")); + let store = PlanStore::with_dir(tempdir().unwrap().keep()); + plan_general( + &store, + &exec, + Path::new("/"), + "inspect sshd", + &SystemFacts::default(), + &general_ai(&transport), + None, + ) + .unwrap(); + let requests = transport.requests(); + assert_eq!(requests.len(), 2); + assert!(requests[1].contains("ActiveState=active")); + assert!(!requests[1].contains("synthetic-service-token")); + assert!(!requests[1].contains("/home/test/private")); +} diff --git a/installer-rs/crates/phoebus-installer/src/service/validation.rs b/installer-rs/crates/phoebus-installer/src/service/validation.rs index d0fd379..7bd5fe7 100644 --- a/installer-rs/crates/phoebus-installer/src/service/validation.rs +++ b/installer-rs/crates/phoebus-installer/src/service/validation.rs @@ -196,6 +196,36 @@ pub fn compute_plan_digest( } format!("{:x}", hasher.finalize()) } + +/// Versioned human approval envelope. Material effects alone are not an +/// approval: kind, lifetime, target, identity and verification selectors also +/// change what the privileged broker will execute and must be independently +/// bound. Presentation-only text stays outside the consumption identity. +pub fn approval_digest_for_plan(plan: &PreparedPlan) -> Result { + let steps = reviewed_steps(plan)?; + let material = compute_plan_digest( + &plan.actions, + plan.candidate.as_ref(), + &plan.effects, + &steps, + ); + let envelope = serde_json::to_vec(&( + "phoebus-approval-v2", + &plan.id, + plan.kind, + plan.created_unix, + plan.expires_unix, + &plan.target_root, + plan.initiator_uid, + plan.requires_root, + &plan.application, + &plan.source, + &plan.candidate, + material, + )) + .map_err(|e| ExecError::operation("service", "approval envelope", e.to_string()))?; + Ok(format!("{:x}", Sha256::digest(envelope))) +} // ----------------------------------------------------------------------------- // Privileged validation boundary // ----------------------------------------------------------------------------- @@ -260,6 +290,16 @@ pub fn validate_prepared_plan( "plan proposes no actions", )); } + if plan.expires_unix < plan.created_unix + || plan.expires_unix.saturating_sub(plan.created_unix) > super::DEFAULT_PLAN_TTL_SECONDS + || plan.created_unix > now_unix().saturating_add(30) + { + return Err(ExecError::operation( + "service", + "validate plan", + "invalid approval lifetime; review a fresh plan", + )); + } // Independently recompute the canonical approval digest from the exact // executable actions, candidate and reviewed material effects. The // `integrity` seal stored beside the plan is a self-consistency check the @@ -277,12 +317,7 @@ pub fn validate_prepared_plan( // change only `step_effects`, reseal" gap for General and Undo plans. let steps = reviewed_steps(plan)?; validate_effect_bindings(plan, &steps)?; - let canonical = compute_plan_digest( - &plan.actions, - plan.candidate.as_ref(), - &plan.effects, - &steps, - ); + let canonical = approval_digest_for_plan(plan)?; if plan.digest != canonical { return Err(ExecError::operation( "service", @@ -292,7 +327,7 @@ pub fn validate_prepared_plan( )); } if let Some(digest) = expected_digest { - if !digest.is_empty() && canonical != digest { + if digest.is_empty() || canonical != digest { return Err(ExecError::operation( "service", "validate plan", @@ -300,6 +335,36 @@ pub fn validate_prepared_plan( )); } } + if plan.requires_root != plan.actions.iter().any(SystemAction::requires_root) { + return Err(ExecError::operation( + "service", + "validate plan", + "plan privilege requirements do not match its actions", + )); + } + match plan.kind { + PlanKind::Install | PlanKind::LegacyInstall + if plan.actions.len() != 1 + || plan.candidate.is_none() + || plan.application.as_deref().unwrap_or("").is_empty() => + { + return Err(ExecError::operation( + "service", + "validate plan", + "invalid installation plan shape", + )); + } + PlanKind::Undo + if plan.actions.len() != 1 || !matches!(plan.actions[0], SystemAction::Undo { .. }) => + { + return Err(ExecError::operation( + "service", + "validate plan", + "undo plan must contain exactly one undo action", + )); + } + _ => {} + } if plan.target_root.is_empty() { return Err(ExecError::operation( "service", @@ -364,7 +429,8 @@ fn revalidate_plan_state(exec: &Exec, root: &Path, plan: &PreparedPlan) -> Resul format!("the reviewed plan changed before execution ({e}); review again"), ) })?; - if current_digest != plan.digest { + let material_digest = install::approval_digest_for(cand, act, &plan.effects); + if current_digest != material_digest { return Err(ExecError::operation( "service", "revalidate", diff --git a/installer/tests/vm/README.md b/installer/tests/vm/README.md index 44c05b4..0c7c41f 100644 --- a/installer/tests/vm/README.md +++ b/installer/tests/vm/README.md @@ -165,3 +165,20 @@ DISK=/var/tmp/phoebus-vm/disks/target.qcow2 \ ISO=installer/live/phoebus-installer-amd64.iso \ python3 installer/tests/vm/gui-driver.py gui ``` + +## Agentic hardening acceptance + +`agentic-hardening-guest.sh` requires QEMU/KVM and root, and is intended only +for an installed disposable overlay. Supply the current static binary as +`/tmp/phoebus-hardening-sys` and the static `isolation_acceptance` test executable +as `/tmp/phoebus-hardening-isolation`. Run the two user probes as the normal +account with `PHOEBUS_ISOLATION_FIXTURE_ROOT=$HOME` and +`--ignored --skip model_system_unit`; the root fixture runs the system-manager +probe separately. It also exercises deterministic history, descriptor-backed +snapshots, exact Portage installation/removal, persistent lock permissions, +Flatpak commit installation/removal, and the active Nix store-path pin. +Serve the files through the existing serial boot harness, authenticate sudo, +require every reported case, and request a clean poweroff. Never reuse the +sole source-build evidence image as a writable target: create a checked qcow2 +backing overlay first. Preserve failed diagnostics and distinguish fixture +errors from product failures. diff --git a/installer/tests/vm/agentic-hardening-guest.sh b/installer/tests/vm/agentic-hardening-guest.sh new file mode 100755 index 0000000..510c065 --- /dev/null +++ b/installer/tests/vm/agentic-hardening-guest.sh @@ -0,0 +1,50 @@ +#!/bin/bash +# Run only in a disposable QEMU overlay, after the serial driver authenticates. +set -euo pipefail +case "$(systemd-detect-virt)" in + qemu|kvm) ;; + *) echo 'disposable QEMU/KVM required'; exit 2 ;; +esac +[[ $(id -u) == 0 ]] || { echo 'root fixture required'; exit 2; } +SYS=/tmp/phoebus-hardening-sys +report() { printf 'CASE %s PASS\n' "$1"; } +# On failure, retain useful native diagnostics without pretending a missing +# case passed. These files contain only deterministic package/snapshot output. +on_exit() { + local rc="$?" + if [[ "$rc" -ne 0 ]]; then + printf 'CASE native-command FAIL exit=%s\n' "$rc" + for output in /tmp/phoebus-hardening-{install,flatpak,nix,snapshot}.out; do + [[ -f "$output" ]] || continue + printf 'Fixture diagnostic: %s\n' "$output" + tail -n 12 "$output" + done + fi +} +trap on_exit EXIT +"$SYS" history --legacy >/tmp/phoebus-hardening-history.out +report deterministic-history +/tmp/phoebus-hardening-isolation --ignored model_system_unit +report root-model-isolation +"$SYS" snapshot --legacy -y >/tmp/phoebus-hardening-snapshot.out +report descriptor-snapshot +if compgen -G '/var/db/pkg/app-misc/hello-*' >/dev/null; then + "$SYS" remove hello --legacy --portage -y >/tmp/phoebus-hardening-remove-before.out 2>&1 +fi +"$SYS" install hello --legacy --portage -y >/tmp/phoebus-hardening-install.out 2>&1 +# Dedicated workflow must have verified the exact candidate, not mere presence. +grep -q 'verified: app-misc/hello ' /tmp/phoebus-hardening-install.out >/dev/null +report portage-exact +"$SYS" remove hello --legacy --portage -y >/tmp/phoebus-hardening-remove.out 2>&1 +report portage-remove +[[ -f /run/phoebus/sys.lock ]] && [[ $(stat -c %a /run/phoebus/sys.lock) == 600 ]] +report persistent-kernel-lock + +"$SYS" install org.gnome.Calculator --legacy --flatpak -y >/tmp/phoebus-hardening-flatpak.out 2>&1 +grep -q 'verified: Flatpak app org.gnome.Calculator' /tmp/phoebus-hardening-flatpak.out +report flatpak-pin +"$SYS" remove org.gnome.Calculator --legacy --flatpak -y >/tmp/phoebus-hardening-flatpak-remove.out 2>&1 +report flatpak-remove +"$SYS" install hello --legacy --nix -y >/tmp/phoebus-hardening-nix.out 2>&1 +grep -q 'verified:' /tmp/phoebus-hardening-nix.out +report nix-pin