fix(security): harden agent execution and approval boundaries
Some checks are pending
ci / test (push) Waiting to run
Some checks are pending
ci / test (push) Waiting to run
This commit is contained in:
parent
fc35c5a368
commit
78b896988c
44 changed files with 2757 additions and 549 deletions
104
docs/AGENTIC-HARDENING.md
Normal file
104
docs/AGENTIC-HARDENING.md
Normal file
|
|
@ -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.
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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).
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -580,7 +580,9 @@ inside the privileged broker (`sys --broker --execute-plan <id> --plan-uid <uid>
|
|||
--approval-digest <sha256> --root <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 <id> --plan-uid <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
|
||||
|
|
|
|||
|
|
@ -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`
|
||||
|
|
|
|||
40
docs/adr/0015-agent-execution-boundaries.md
Normal file
40
docs/adr/0015-agent-execution-boundaries.md
Normal file
|
|
@ -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.
|
||||
|
|
@ -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.
|
||||
|
|
|
|||
2
installer-rs/Cargo.lock
generated
2
installer-rs/Cargo.lock
generated
|
|
@ -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",
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -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() {
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 `<redacted>`.
|
||||
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() {
|
||||
|
|
|
|||
|
|
@ -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<String>,
|
||||
/// 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<InstallArtifact>,
|
||||
/// 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,
|
||||
|
|
|
|||
|
|
@ -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<OnceLock<File>>,
|
||||
}
|
||||
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<File> {
|
||||
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<File> {
|
||||
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<PathBuf>) -> 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<PathBuf> {
|
||||
let rel = Path::new(relative.trim_start_matches('/'));
|
||||
for component in rel.components() {
|
||||
match component {
|
||||
Component::ParentDir => {
|
||||
if rel.components().any(|c| {
|
||||
matches!(
|
||||
c,
|
||||
Component::ParentDir | Component::Prefix(_) | Component::RootDir
|
||||
)
|
||||
}) {
|
||||
return Err(CoreError::Validation(format!(
|
||||
"target path must not contain `..`: {relative}"
|
||||
"target path must not contain parent traversal: {relative}"
|
||||
)));
|
||||
}
|
||||
Component::RootDir | Component::Prefix(_) => {
|
||||
return Err(CoreError::Validation(format!(
|
||||
"target path must be relative: {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<PathBuf> {
|
||||
self.resolve(absolute)
|
||||
}
|
||||
|
||||
pub fn etc(&self, relative: &str) -> Result<PathBuf> {
|
||||
self.resolve(&format!("etc/{relative}"))
|
||||
pub fn etc(&self, rel: &str) -> Result<PathBuf> {
|
||||
self.resolve(&format!("etc/{rel}"))
|
||||
}
|
||||
|
||||
pub fn var(&self, relative: &str) -> Result<PathBuf> {
|
||||
self.resolve(&format!("var/{relative}"))
|
||||
pub fn var(&self, rel: &str) -> Result<PathBuf> {
|
||||
self.resolve(&format!("var/{rel}"))
|
||||
}
|
||||
|
||||
pub fn boot(&self, relative: &str) -> Result<PathBuf> {
|
||||
self.resolve(&format!("boot/{relative}"))
|
||||
pub fn boot(&self, rel: &str) -> Result<PathBuf> {
|
||||
self.resolve(&format!("boot/{rel}"))
|
||||
}
|
||||
|
||||
pub fn home(&self, relative: &str) -> Result<PathBuf> {
|
||||
self.resolve(&format!("home/{relative}"))
|
||||
pub fn home(&self, rel: &str) -> Result<PathBuf> {
|
||||
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<File> {
|
||||
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() {
|
||||
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<File> {
|
||||
self.directory(relative, false)
|
||||
}
|
||||
pub fn ensure_dir(&self, relative: &str) -> Result<PathBuf> {
|
||||
self.directory(relative, true)?;
|
||||
self.resolve(relative)
|
||||
}
|
||||
pub fn ensure_dir_mode(&self, relative: &str, mode: u32) -> Result<PathBuf> {
|
||||
let dir = self.directory(relative, true)?;
|
||||
fs::fchmod(&dir, Mode::from_bits_truncate(mode)).map_err(|e| io(&self.root, e))?;
|
||||
self.resolve(relative)
|
||||
}
|
||||
fn write_mode(&self, relative: &str, bytes: &[u8], mode: Option<u32>) -> Result<PathBuf> {
|
||||
let path = self.resolve(relative)?;
|
||||
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!(
|
||||
"refusing to write through a symlink inside the target: {}",
|
||||
current.display()
|
||||
"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());
|
||||
}
|
||||
Ok(())
|
||||
result
|
||||
}
|
||||
|
||||
pub fn ensure_dir(&self, relative: &str) -> Result<PathBuf> {
|
||||
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)
|
||||
}
|
||||
|
||||
/// Create a directory with an explicit mode (on Unix).
|
||||
pub fn ensure_dir_mode(&self, relative: &str, mode: u32) -> Result<PathBuf> {
|
||||
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)
|
||||
}
|
||||
|
||||
pub fn write(&self, relative: &str, contents: impl AsRef<[u8]>) -> Result<PathBuf> {
|
||||
self.reject_symlink_components(relative)?;
|
||||
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<File> {
|
||||
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 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(),
|
||||
));
|
||||
}
|
||||
std::fs::write(&path, contents).map_err(|e| CoreError::io(path.clone(), e))?;
|
||||
Ok(path)
|
||||
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<String> {
|
||||
let path = self.resolve(relative)?;
|
||||
std::fs::read_to_string(&path).map_err(|e| CoreError::io(path, 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(),
|
||||
));
|
||||
}
|
||||
let mut text = String::new();
|
||||
file.read_to_string(&mut text)
|
||||
.map_err(|e| CoreError::io(&path, e))?;
|
||||
Ok(text)
|
||||
}
|
||||
|
||||
/// 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))
|
||||
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<PathBuf> {
|
||||
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 bytes = std::fs::read(src).map_err(|e| CoreError::io(src, e))?;
|
||||
self.write_mode(relative, &bytes, Some(mode))
|
||||
}
|
||||
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)
|
||||
}
|
||||
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@ toml.workspace = true
|
|||
tempfile.workspace = true
|
||||
sha2 = "0.10"
|
||||
roxmltree = "0.20"
|
||||
rustix.workspace = true
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile.workspace = true
|
||||
|
|
|
|||
|
|
@ -199,7 +199,9 @@ fn pretend_args(action: &SystemAction) -> Option<Vec<String>> {
|
|||
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<ActionOutcome> {
|
||||
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<ActionOutcome> {
|
||||
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<ActionOutcome> {
|
||||
// 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,6 +1712,16 @@ pub fn execute_inner(
|
|||
),
|
||||
));
|
||||
}
|
||||
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,
|
||||
|
|
@ -1682,6 +1740,7 @@ pub fn execute_inner(
|
|||
)?;
|
||||
format!("installed Flatpak app {app_id}")
|
||||
}
|
||||
}
|
||||
SystemAction::FlatpakRemove { app_id } => {
|
||||
run_in_target(
|
||||
exec,
|
||||
|
|
@ -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 => {
|
||||
|
|
|
|||
|
|
@ -70,77 +70,153 @@ pub fn build_jail_argv(
|
|||
home: &Path,
|
||||
program: &str,
|
||||
args: &[String],
|
||||
) -> Vec<String> {
|
||||
let mut out: Vec<String> = vec![
|
||||
"--die-with-parent".into(),
|
||||
"--dev".into(),
|
||||
"/dev".into(),
|
||||
"--proc".into(),
|
||||
"/proc".into(),
|
||||
"--tmpfs".into(),
|
||||
"/tmp".into(),
|
||||
];
|
||||
|
||||
// Read-only system mounts
|
||||
) -> Result<Vec<String>> {
|
||||
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<PathBuf> = 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<String> = [
|
||||
"--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;
|
||||
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()]);
|
||||
}
|
||||
let sensitive_path = home.join(clean);
|
||||
let path_str = sensitive_path.to_string_lossy().to_string();
|
||||
out.push("--tmpfs".into());
|
||||
out.push(path_str);
|
||||
}
|
||||
|
||||
// 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<String>,
|
||||
_workspace: std::fs::File,
|
||||
}
|
||||
|
||||
pub fn prepare_jail(
|
||||
config: &AgentJailConfig,
|
||||
home: &Path,
|
||||
program: &str,
|
||||
args: &[String],
|
||||
) -> Result<PreparedJail> {
|
||||
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,9 +233,40 @@ pub fn run_jailed(
|
|||
));
|
||||
}
|
||||
|
||||
let argv = build_jail_argv(config, home, program, args);
|
||||
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)]
|
||||
mod tests {
|
||||
|
|
@ -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}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
);
|
||||
|
|
|
|||
221
installer-rs/crates/phoebus-executor/src/artifact.rs
Normal file
221
installer-rs/crates/phoebus-executor/src/artifact.rs
Normal file
|
|
@ -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<String> {
|
||||
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<String> {
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
|
@ -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<String> = 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 {
|
||||
|
|
|
|||
|
|
@ -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<Arc<std::fs::File>>,
|
||||
}
|
||||
|
||||
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 {
|
||||
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 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,
|
||||
})?;
|
||||
|
||||
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();
|
||||
// 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),
|
||||
}
|
||||
}
|
||||
|
||||
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),
|
||||
)
|
||||
})
|
||||
}
|
||||
Ok(())
|
||||
});
|
||||
|
||||
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 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 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 status = status.map_err(|source| ExecError::Spawn {
|
||||
program: spec.program.clone(),
|
||||
source,
|
||||
})?;
|
||||
let duration = start.elapsed();
|
||||
let code = status.code().unwrap_or(-1);
|
||||
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<u8> {
|
||||
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<P: Read + AsFd>(
|
||||
pipe: Option<P>,
|
||||
log: Option<&StreamSink>,
|
||||
user: Option<&StreamSink>,
|
||||
spec: &CommandSpec,
|
||||
stop: &AtomicBool,
|
||||
exceeded: &AtomicBool,
|
||||
) -> Result<Vec<u8>> {
|
||||
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() {
|
||||
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;
|
||||
}
|
||||
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() {
|
||||
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());
|
||||
}
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)",
|
||||
|
|
|
|||
144
installer-rs/crates/phoebus-executor/src/evidence.rs
Normal file
144
installer-rs/crates/phoebus-executor/src/evidence.rs
Normal file
|
|
@ -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"));
|
||||
}
|
||||
}
|
||||
|
|
@ -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<ProgressSink>,
|
||||
mutation_owner: Mutex<
|
||||
Option<(
|
||||
PathBuf,
|
||||
std::thread::ThreadId,
|
||||
std::sync::Weak<crate::system_lock::SystemLock>,
|
||||
)>,
|
||||
>,
|
||||
}
|
||||
|
||||
pub struct MutationGuard {
|
||||
_lock: Arc<crate::system_lock::SystemLock>,
|
||||
// Reentrancy is thread-scoped; ownership must not migrate to another thread.
|
||||
_thread: std::marker::PhantomData<std::rc::Rc<()>>,
|
||||
}
|
||||
|
||||
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<MutationGuard> {
|
||||
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<CommandOutput> {
|
||||
pub fn run(&self, mut spec: CommandSpec) -> Result<CommandOutput> {
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -212,7 +212,16 @@ pub fn action_for(_exec: &Exec, root: &Path, candidate: &Candidate) -> Result<Sy
|
|||
match candidate.backend {
|
||||
Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => {
|
||||
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"],
|
||||
let phoebus_core::selection::InstallArtifact::Flatpak { reference, commit } =
|
||||
crate::artifact::require(c)?
|
||||
else {
|
||||
return Err(ExecError::operation(
|
||||
"install",
|
||||
"verify",
|
||||
"wrong Flatpak artifact type",
|
||||
));
|
||||
if installed
|
||||
.map(|o| o.stdout_lossy().lines().any(|l| l.trim() == c.id))
|
||||
.unwrap_or(false)
|
||||
{
|
||||
};
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -154,6 +154,7 @@ impl HttpClient for CurlHttpClient<'_> {
|
|||
fn request(&self, request: &HttpRequest) -> Result<HttpResponse, AiError> {
|
||||
let mut temp: Option<tempfile::NamedTempFile> = 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<Catalog, AiError> {
|
|||
"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"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::<u32>() {
|
||||
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
|
||||
|
|
|
|||
|
|
@ -69,7 +69,8 @@ fn capture(
|
|||
program: &str,
|
||||
args: &[&str],
|
||||
) -> std::result::Result<CommandOutput, ExecError> {
|
||||
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.
|
||||
|
|
|
|||
|
|
@ -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,8 +87,62 @@ fn build_argv(program: &str, args: &[String], user: bool, properties: &[&str]) -
|
|||
for property in properties {
|
||||
out.push(format!("--property={property}"));
|
||||
}
|
||||
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<String> {
|
||||
let mut out: Vec<String> = [
|
||||
"/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<u8>,
|
||||
) -> Result<crate::command::CommandOutput> {
|
||||
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<u8>,
|
||||
output_limit: usize,
|
||||
timeout: std::time::Duration,
|
||||
) -> Result<crate::command::CommandOutput> {
|
||||
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",
|
||||
|
|
|
|||
|
|
@ -202,8 +202,24 @@ pub fn list(exec: &Exec) -> Result<Vec<SnapEntry>> {
|
|||
/// 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<String> {
|
||||
install_revision(exec, name, channel, classic, None)
|
||||
}
|
||||
|
||||
pub fn install_revision(
|
||||
exec: &Exec,
|
||||
name: &str,
|
||||
channel: Option<&str>,
|
||||
classic: bool,
|
||||
revision: Option<&str>,
|
||||
) -> Result<String> {
|
||||
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}"));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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/<pid>`).
|
||||
|
||||
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<Self> {
|
||||
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::<u32>().ok();
|
||||
} else if let Some(val) = line.strip_prefix("created_unix=") {
|
||||
created_unix = val.trim().parse::<u64>().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<File> {
|
||||
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<Self> {
|
||||
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<Self> {
|
||||
if let Some(parent) = path.parent() {
|
||||
fs::create_dir_all(parent).map_err(|e| ExecError::io(parent.to_path_buf(), e))?;
|
||||
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)
|
||||
}
|
||||
|
||||
let my_pid = std::process::id();
|
||||
let now = now_unix();
|
||||
fn claim(exec: &Exec, mut file: File, path: &Path, operation: &str) -> Result<Self> {
|
||||
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 ({e})"),
|
||||
)
|
||||
},
|
||||
)?;
|
||||
let info = LockInfo {
|
||||
pid: my_pid,
|
||||
created_unix: now,
|
||||
operation: operation.to_string(),
|
||||
pid: std::process::id(),
|
||||
created_unix: now_unix(),
|
||||
operation: operation.into(),
|
||||
};
|
||||
|
||||
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(
|
||||
"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);
|
||||
}
|
||||
}
|
||||
}
|
||||
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()<deadline: time.sleep(0.01)')"])
|
||||
.env("PHOEBUS_LEASE_RELEASE", root.join("release").to_string_lossy())).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn crashing_broker_does_not_unlock_a_still_running_worker() {
|
||||
use std::io::{BufRead, BufReader};
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut broker = std::process::Command::new(std::env::current_exe().unwrap())
|
||||
.args([
|
||||
"--exact",
|
||||
"system_lock::tests::lease_owner_helper",
|
||||
"--nocapture",
|
||||
])
|
||||
.env("PHOEBUS_LEASE_ROOT", dir.path())
|
||||
.stdout(std::process::Stdio::piped())
|
||||
.spawn()
|
||||
.unwrap();
|
||||
let mut stdout = BufReader::new(broker.stdout.take().unwrap());
|
||||
let mut line = String::new();
|
||||
loop {
|
||||
line.clear();
|
||||
assert!(stdout.read_line(&mut line).unwrap() > 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));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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"));
|
||||
}
|
||||
|
|
@ -63,10 +63,13 @@ 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.");
|
||||
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;
|
||||
}
|
||||
};
|
||||
|
|
@ -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) => {
|
||||
|
|
|
|||
|
|
@ -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() {
|
||||
|
|
|
|||
|
|
@ -69,6 +69,17 @@ pub fn execute_plan_privileged(
|
|||
assume_yes: bool,
|
||||
) -> Result<PlanExecutionOutcome> {
|
||||
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<PlanExecutionOutcome> {
|
||||
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() {
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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"));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<String> {
|
||||
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",
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
50
installer/tests/vm/agentic-hardening-guest.sh
Executable file
50
installer/tests/vm/agentic-hardening-guest.sh
Executable file
|
|
@ -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
|
||||
Loading…
Add table
Reference in a new issue