Skip to main content

alien_core/
sandbox_image.rs

1//! What a sandbox image must carry for the agent to serve, and the Dockerfile text carrying it.
2//!
3//! Two kinds of image exist and neither is built the way the other is. AWS renders one per
4//! deployment onto a customer-supplied base image; GCP builds static images in CI. Nothing at build
5//! time reads the other side, and a value that disagrees is invisible until a session fails: an
6//! agent listening on a port no caller dials, or an exec into a uid the image never created.
7//!
8//! So the values live here once and both kinds render the block that carries them from this
9//! module. The same holds for the default sandbox base both kinds start from: its toolchain is
10//! listed here once, and a probe reads that list rather than restating it. The Dockerfiles and the
11//! tool list are committed as generated text because CI builds them with `docker build` and probes
12//! them from a shell, neither of which can call a Rust function.
13
14/// Path the agent binary is installed at inside every sandbox image.
15///
16/// An image that installs one path and entrypoints another exits before it serves, and the
17/// session times out on connect.
18pub const AGENT_PATH: &str = "/usr/local/bin/alien-sandbox-agent";
19
20/// Port the agent serves unless the platform pins another.
21///
22/// Defined once because two independent copies are a runtime-only failure: the image build places
23/// the agent on one port and the client dials the other, and nothing catches it until a sandbox
24/// hangs. AWS scopes its endpoint token to an explicit port set, so this cannot be discovered.
25pub const AGENT_PORT: u16 = 8971;
26
27/// Header carrying a preview capability. Never `Authorization`: the caller's own bearer token
28/// belongs to the code inside the sandbox and reaches it untouched.
29pub const PREVIEW_CAPABILITY_HEADER: &str = "x-alien-preview-capability";
30
31/// Header naming the sandbox port a preview request is for.
32pub const PREVIEW_PORT_HEADER: &str = "x-alien-preview-port";
33
34/// Header a caller puts its own bearer in when the backend's edge consumes `Authorization` for
35/// its own credential (GCP). The agent, after the capability verifies, re-emits it as
36/// `Authorization` towards `127.0.0.1` only.
37pub const CALLER_AUTHORIZATION_HEADER: &str = "x-alien-caller-authorization";
38
39/// Environment variable naming the header a backend's callers use for their own bearer
40/// (`authorization` when unset). Set on backends whose edge replaces `Authorization`.
41pub const ENV_CALLER_AUTHORIZATION_HEADER: &str = "ALIEN_SANDBOX_CALLER_AUTHORIZATION_HEADER";
42
43/// Longest a preview capability lives, in seconds. A grant never outlives the session either.
44pub const PREVIEW_CAPABILITY_MAX_SECONDS: i64 = 15 * 60;
45
46/// Set by the Kubernetes backend only: the pod mounts the agent binary and `/opt/alien`
47/// read-only itself, so the agent verifies that instead of building a private mount namespace
48/// (a pod's default seccomp profile blocks `unshare`). The agent refuses to start if the mounts
49/// are not there, so setting it elsewhere cannot turn protection off.
50pub const ENV_PROTECTED_MOUNTS: &str = "ALIEN_SANDBOX_PROTECTED_MOUNTS";
51
52/// Comma-separated `host:port` addresses of the Kubernetes API server (its Service ClusterIP and
53/// the real endpoint IPs) that the startup gate must see dropped. The Operator sets it on every
54/// Kubernetes sandbox pod, because service links are off and the pod has no
55/// `KUBERNETES_SERVICE_HOST` to learn the address from.
56pub const ENV_MUST_DROP_KUBE_API: &str = "ALIEN_SANDBOX_MUST_DROP_KUBE_API";
57/// A public `host:port` the startup gate must also see dropped. The Operator sets it only where
58/// the declared egress forbids direct public traffic (`none`, and `internet`, which goes through
59/// the gateway). It is unset when the policy allows that address, so an `allow` pod is not
60/// refused for reaching it.
61pub const ENV_MUST_DROP_PUBLIC: &str = "ALIEN_SANDBOX_MUST_DROP_PUBLIC";
62/// The public address the Operator asks the gate to probe.
63pub const MUST_DROP_PUBLIC_PROBE: &str = "1.1.1.1:443";
64/// The agent's first argument that stages the protected files (the Kubernetes init container).
65pub const STAGE_PROTECTED_FILES_ARGUMENT: &str = "--stage-protected-files";
66/// The agent's first argument that prints its uid and gid and exits, touching nothing else.
67pub const AGENT_IDENTITY_ARGUMENT: &str = "identity";
68/// File name the staging step also writes at the top of the staging directory. Agents built before
69/// the directory mount were staged that way and an Operator of that release mounts it over the
70/// image's agent path; keeping it lets that Operator run an image built with this agent.
71pub const STAGED_AGENT_NAME: &str = "agent";
72/// Name of the directory inside the staging volume that the pod mounts read-only at `/opt/alien`.
73pub const STAGED_METADATA_NAME: &str = "opt";
74/// The agent's file name inside that directory. A pod mounts directories only, never the single
75/// file: runtimes that run the pod in a VM share a directory mount into the guest as a mount
76/// point but do not list a single-file bind mount, so the agent could not prove the file
77/// read-only there. The container starts the agent from [`STAGED_AGENT_PATH`].
78pub const STAGED_AGENT_FILE: &str = "alien-sandbox-agent";
79/// Where the staged agent runs from on Kubernetes (inside the read-only `/opt/alien` mount).
80pub const STAGED_AGENT_PATH: &str = "/opt/alien/alien-sandbox-agent";
81
82/// Mode of the agent binary, owned by `0:0` so the exec uid cannot rewrite its supervisor.
83pub const AGENT_MODE: u32 = 0o755;
84
85/// Name of the exec identity's passwd and group entries.
86pub const EXEC_USER: &str = "sandbox";
87
88/// Mode of the session root, which the exec uid owns.
89pub const SESSION_ROOT_MODE: u32 = 0o700;
90
91/// `RUST_LOG` for a GCP image, which the agent needs set before it logs anything.
92pub const GCP_AGENT_LOG_FILTER: &str = "info";
93
94/// Linux capabilities a root image process keeps: Docker's default set without `NET_RAW`.
95///
96/// `(name, number)` pairs, one list for both sides of the contract. The agent keeps exactly
97/// this set for the image's command and a Kubernetes pod grants exactly this set to the agent
98/// (`drop: [ALL]`, then these), so the agent can start the command with what it is entitled to
99/// and nothing more. Never `NET_ADMIN`, `SYS_ADMIN` or `NET_RAW`.
100pub const IMAGE_ROOT_CAPABILITY_SET: &[(&str, u8)] = &[
101    ("CHOWN", 0),
102    ("DAC_OVERRIDE", 1),
103    ("FOWNER", 3),
104    ("FSETID", 4),
105    ("KILL", 5),
106    ("SETGID", 6),
107    ("SETUID", 7),
108    ("SETPCAP", 8),
109    ("NET_BIND_SERVICE", 10),
110    ("SYS_CHROOT", 18),
111    ("MKNOD", 27),
112    ("AUDIT_WRITE", 29),
113    ("SETFCAP", 31),
114];
115
116/// [`IMAGE_ROOT_CAPABILITY_SET`] as the 32-bit `CapEff` mask the agent applies.
117pub const IMAGE_ROOT_CAPABILITY_MASK: u32 = {
118    let mut mask = 0u32;
119    let mut index = 0;
120    while index < IMAGE_ROOT_CAPABILITY_SET.len() {
121        mask |= 1 << IMAGE_ROOT_CAPABILITY_SET[index].1;
122        index += 1;
123    }
124    mask
125};
126
127/// How an image ends, and the isolation that ending permits.
128///
129/// One value rather than two, because `ALIEN_SANDBOX_ISOLATION` and the trailing `USER` describe
130/// the same decision from opposite sides: an image that asks for `uid-split` under a non-root
131/// `USER` has no privilege left to drop with, and every exec in it fails.
132#[derive(Debug, Clone, Copy, PartialEq, Eq)]
133pub enum Isolation {
134    /// The agent starts as root and drops to the exec uid before every spawn, so a command can
135    /// never rewrite its own supervisor. The image declares no `USER`.
136    UidSplit,
137    /// The agent starts as the exec uid and supervises commands under it, which is all a runtime
138    /// that refuses a root image can offer. The image ends `USER <uid>:<uid>`.
139    Platform,
140}
141
142impl Isolation {
143    /// The `ALIEN_SANDBOX_ISOLATION` value the agent parses.
144    pub fn env_value(self) -> &'static str {
145        match self {
146            Self::UidSplit => "uid-split",
147            Self::Platform => "platform",
148        }
149    }
150}
151
152/// How the agent decides a caller may be served.
153#[derive(Debug, Clone, Copy, PartialEq, Eq)]
154pub enum Authorization {
155    /// The connection is the proof. The agent serves an uncapabilitied request only from a socket
156    /// peer it cannot trace back to the exec uid, which keeps the supervised command out.
157    Transport,
158    /// The caller presents a signed token, which is what a network anything can reach requires.
159    Capability,
160    /// A per-boot credential is read through the cloud's authenticated native file API.
161    NativeFile,
162}
163
164impl Authorization {
165    /// The `ALIEN_SANDBOX_AUTHORIZATION` value the agent parses.
166    pub fn env_value(self) -> &'static str {
167        match self {
168            Self::Transport => "transport",
169            Self::Capability => "capability",
170            Self::NativeFile => "native-file",
171        }
172    }
173}
174
175/// The values an image must carry for the agent to run in it.
176#[derive(Debug, Clone, Copy, PartialEq, Eq)]
177pub struct SandboxImage {
178    /// Uid the supervised command runs as, resolved from a non-root base USER or the default.
179    pub exec_uid: u32,
180    /// Primary gid from the base USER, which may differ from its uid.
181    pub exec_gid: u32,
182    /// Writable session directory. Image-owned directories may also be writable on VM backends.
183    pub session_root: &'static str,
184    /// Port the agent serves, both its own protocol and any lifecycle hooks.
185    pub port: u16,
186    pub authorization: Authorization,
187    pub isolation: Isolation,
188}
189
190impl SandboxImage {
191    /// Gid the supervised command runs as.
192    pub fn exec_gid(&self) -> u32 {
193        self.exec_gid
194    }
195
196    /// The agent's configuration contract as `(name, value)` pairs, in the order the `ENV` block
197    /// lists them.
198    pub fn contract_env_vars(&self) -> [(&'static str, String); 6] {
199        [
200            ("ALIEN_SANDBOX_ROOT", self.session_root.to_string()),
201            ("ALIEN_SANDBOX_PORT", self.port.to_string()),
202            (
203                "ALIEN_SANDBOX_AUTHORIZATION",
204                self.authorization.env_value().to_string(),
205            ),
206            ("ALIEN_SANDBOX_EXEC_UID", self.exec_uid.to_string()),
207            ("ALIEN_SANDBOX_EXEC_GID", self.exec_gid().to_string()),
208            (
209                "ALIEN_SANDBOX_ISOLATION",
210                self.isolation.env_value().to_string(),
211            ),
212        ]
213    }
214
215    /// The `uid:gid` the image runs as, or `None` when it declares no user and starts as root.
216    /// Why the gid is explicit is in the `USER` comment [`entrypoint`] renders.
217    pub fn user(&self) -> Option<String> {
218        match self.isolation {
219            Isolation::UidSplit => None,
220            Isolation::Platform => Some(format!("{}:{}", self.exec_uid, self.exec_gid())),
221        }
222    }
223
224    /// The port the image exposes, as an OCI `ExposedPorts` key.
225    pub fn exposed_port(&self) -> String {
226        format!("{}/tcp", self.port)
227    }
228
229    /// The exec identity's `/etc/passwd` line, without a trailing newline.
230    pub fn passwd_entry(&self) -> String {
231        format!(
232            "{EXEC_USER}:x:{uid}:{gid}::{root}:/sbin/nologin",
233            uid = self.exec_uid,
234            gid = self.exec_gid(),
235            root = self.session_root,
236        )
237    }
238
239    /// The exec identity's `/etc/group` line, without a trailing newline.
240    pub fn group_entry(&self) -> String {
241        format!("{EXEC_USER}:x:{gid}:", gid = self.exec_gid())
242    }
243}
244
245/// The Lambda MicroVM image, rendered per deployment onto a customer base image.
246///
247/// The agent runs as root so it can drop to [`SandboxImage::exec_uid`] before every spawn; inside
248/// a MicroVM that is contained by hardware virtualisation, which is the tenant boundary. A
249/// shared-kernel backend must give the agent `CAP_SETUID` instead of root.
250pub const AWS_MICROVM: SandboxImage = SandboxImage {
251    exec_uid: 60000,
252    exec_gid: 60000,
253    session_root: "/sandbox",
254    port: AGENT_PORT,
255    authorization: Authorization::Transport,
256    isolation: Isolation::UidSplit,
257};
258
259/// GCP keeps a root supervisor separate from the non-root command identity.
260/// Live conformance must verify root execution and capability bounds because the
261/// provider's published custom-image requirements do not promise root support.
262/// Agent Platform serves the port the template declares; the agent keeps the shared port so a
263/// workload that binds 8080 itself does not collide with it (measured live: with the agent on
264/// 8080 a root supervisor that also binds 8080 exits at startup).
265pub const GCP_AGENT_PLATFORM: SandboxImage = SandboxImage {
266    exec_uid: 1000,
267    exec_gid: 1000,
268    session_root: "/sandbox",
269    port: AGENT_PORT,
270    authorization: Authorization::Transport,
271    isolation: Isolation::UidSplit,
272};
273
274/// Every variable a GCP Agent Platform image sets: the contract, then `RUST_LOG`.
275pub fn gcp_agent_platform_env() -> Vec<(&'static str, String)> {
276    let mut env = GCP_AGENT_PLATFORM.contract_env_vars().to_vec();
277    env.push(("RUST_LOG", GCP_AGENT_LOG_FILTER.to_string()));
278    env.push(("ALIEN_SANDBOX_IMAGE_COMMAND", "true".into()));
279    // The edge consumes `Authorization` for its own JWT, so a caller's bearer travels in a
280    // header of its own and the agent re-emits it towards the code inside.
281    env.push((
282        ENV_CALLER_AUTHORIZATION_HEADER,
283        CALLER_AUTHORIZATION_HEADER.into(),
284    ));
285    env
286}
287
288/// Azure serves the agent through a published port and an authenticated native file read.
289/// Its native exec path is never used for packaged images because it grants excess capabilities.
290pub const AZURE_SANDBOX: SandboxImage = SandboxImage {
291    exec_uid: 1000,
292    exec_gid: 1000,
293    session_root: "/sandbox",
294    port: AGENT_PORT,
295    authorization: Authorization::NativeFile,
296    isolation: Isolation::UidSplit,
297};
298
299/// A Kubernetes sandbox pod. The cluster's sandboxed runtime is the tenant boundary and refuses to
300/// start a root container here (`runAsNonRoot`), so the agent starts as the exec uid and
301/// supervises under it. Anything on the cluster network can reach the pod, so a caller presents a
302/// signed capability. The exec uid is a default: a non-root base `USER` replaces it.
303pub const KUBERNETES_SANDBOX: SandboxImage = SandboxImage {
304    exec_uid: 1000,
305    exec_gid: 1000,
306    session_root: "/sandbox",
307    port: AGENT_PORT,
308    authorization: Authorization::Capability,
309    isolation: Isolation::Platform,
310};
311
312/// The image every default sandbox builds on, by index digest so both architectures are pinned.
313///
314/// Bumped by hand, then regenerated: Renovate skips the generated Dockerfiles and does not read
315/// this file.
316pub const DEFAULT_SANDBOX_BASE_IMAGE: &str = "public.ecr.aws/docker/library/buildpack-deps:26.04@sha256:159ea382e6fb39e62480ee932113f885f7bd787cd4895fc4dc71aebb175077fd";
317
318/// The image uv and uvx are copied out of, by index digest.
319pub const DEFAULT_SANDBOX_UV_IMAGE: &str = "ghcr.io/astral-sh/uv:0.12.21@sha256:a7aed3216253ee804de3e2d8afa5073baa1a177335345d43845cd4165e43b711";
320
321/// A tool the default sandbox base ships, and the command that shows it runs.
322#[derive(Debug, Clone, Copy, PartialEq, Eq)]
323pub struct SandboxTool {
324    /// The Ubuntu archive package it comes from, or `None` for one copied out of
325    /// [`DEFAULT_SANDBOX_UV_IMAGE`].
326    pub package: Option<&'static str>,
327    /// Prints the tool's version and exits zero.
328    pub version_command: &'static str,
329}
330
331/// The toolchain of the default sandbox base, and the one list its probes read.
332///
333/// Every tool lands in `/usr/bin` or `/usr/local/bin`: a supervised command gets a fixed `PATH`
334/// and never the image's `ENV`, so a tool anywhere else is invisible to it.
335pub const DEFAULT_SANDBOX_TOOLS: &[SandboxTool] = &[
336    SandboxTool {
337        package: Some("nftables"),
338        version_command: "/usr/sbin/nft --version",
339    },
340    SandboxTool {
341        package: Some("iptables"),
342        version_command: "iptables-nft --version",
343    },
344    SandboxTool {
345        package: Some("nodejs"),
346        version_command: "node --version",
347    },
348    SandboxTool {
349        package: Some("npm"),
350        version_command: "npm --version",
351    },
352    SandboxTool {
353        package: Some("ripgrep"),
354        version_command: "rg --version",
355    },
356    SandboxTool {
357        package: Some("jq"),
358        version_command: "jq --version",
359    },
360    SandboxTool {
361        package: Some("zip"),
362        version_command: "zip -v",
363    },
364    SandboxTool {
365        package: Some("less"),
366        version_command: "less --version",
367    },
368    SandboxTool {
369        package: Some("nano"),
370        version_command: "nano --version",
371    },
372    SandboxTool {
373        package: Some("vim-tiny"),
374        version_command: "vim.tiny --version",
375    },
376    SandboxTool {
377        package: Some("htop"),
378        version_command: "htop --version",
379    },
380    SandboxTool {
381        package: None,
382        version_command: "uv --version",
383    },
384    SandboxTool {
385        package: None,
386        version_command: "uvx --version",
387    },
388];
389
390/// The `RUN` step creating the exec identity and the session root it owns.
391pub fn identity_setup(image: &SandboxImage) -> String {
392    format!(
393        r#"RUN test ! -L /etc/passwd && test ! -L /etc/group && test ! -L {root} \
394 && touch /etc/passwd /etc/group \
395 && chown 0:0 /etc/passwd /etc/group && chmod 0644 /etc/passwd /etc/group \
396 && (awk -F: '$3 == {uid} {{ found=1 }} END {{ exit !found }}' /etc/passwd || printf '{passwd}\n' >> /etc/passwd) \
397 && (awk -F: '$3 == {gid} {{ found=1 }} END {{ exit !found }}' /etc/group || printf '{group}\n' >> /etc/group) \
398 && mkdir -p {root} \
399 && chown {uid}:{gid} {root} \
400 && chmod {SESSION_ROOT_MODE:04o} {root}"#,
401        passwd = image.passwd_entry(),
402        group = image.group_entry(),
403        root = image.session_root,
404        uid = image.exec_uid,
405        gid = image.exec_gid(),
406    )
407}
408
409/// The `ENV` block carrying the agent's configuration contract.
410pub fn contract_env(image: &SandboxImage) -> String {
411    let vars: Vec<String> = image
412        .contract_env_vars()
413        .iter()
414        .map(|(name, value)| format!("{name}={value}"))
415        .collect();
416    format!("ENV {}", vars.join(" \\\n    "))
417}
418
419/// `EXPOSE`, the image's ending, and the `ENTRYPOINT`.
420pub fn entrypoint(image: &SandboxImage) -> String {
421    let ending = match image.user() {
422        None => String::new(),
423        Some(user) => format!(
424            "# Explicit gid so a runtime that does not read /etc/passwd cannot start the agent in \
425             group 0, which\n# makes the exec drop a privilege crossing whose setgroups needs a \
426             CAP_SETGID this image lacks, so\n# every exec fails.\nUSER {user}\n"
427        ),
428    };
429    format!(
430        "EXPOSE {port}\n{ending}ENTRYPOINT [\"{AGENT_PATH}\"]",
431        port = image.exposed_port()
432    )
433}
434
435/// Path of the committed minimal wolfi GCP Dockerfile, relative to the repository root.
436#[cfg(test)]
437const GCP_DOCKERFILE: &str = "docker/Dockerfile.alien-sandbox-agent";
438
439/// Path of the committed default GCP sandbox Dockerfile, relative to the repository root.
440#[cfg(test)]
441const GCP_DEFAULT_DOCKERFILE: &str = "docker/Dockerfile.alien-sandbox-gcp";
442
443/// Path of the committed default sandbox base Dockerfile, relative to the repository root.
444#[cfg(test)]
445const DEFAULT_SANDBOX_DOCKERFILE: &str = "docker/Dockerfile.alien-sandbox-default";
446
447/// Path of the committed tool list a probe of the default sandbox base reads.
448#[cfg(test)]
449const DEFAULT_SANDBOX_TOOLS_FILE: &str = "docker/sandbox-default-tools.txt";
450
451/// Set to regenerate every committed file this module renders instead of comparing against them.
452/// Named for the agent Dockerfile; every generated header prints the name, so a rename rewrites all.
453#[cfg(test)]
454const SANDBOX_FILES_UPDATE: &str = "UPDATE_SANDBOX_AGENT_DOCKERFILE";
455
456/// Renders [`DEFAULT_SANDBOX_DOCKERFILE`], the tools-only base every default sandbox builds on.
457#[cfg(test)]
458fn default_sandbox_dockerfile() -> String {
459    let packages: Vec<&str> = DEFAULT_SANDBOX_TOOLS
460        .iter()
461        .filter_map(|tool| tool.package)
462        .collect();
463    format!(
464        r#"# Generated by `cargo test -p alien-core --lib sandbox_image`. Do not edit by hand.
465# Regenerate with {SANDBOX_FILES_UPDATE}=1 in front of that command.
466#
467# Multi-arch tools-only base for the default sandbox images, with no agent. An image that runs the
468# agent adds it and its own ending on top, and a runtime with no in-guest agent runs this as is,
469# so it declares no USER, ENTRYPOINT or ENV.
470
471FROM {DEFAULT_SANDBOX_BASE_IMAGE}
472
473# No version pins: the -updates and -security pockets supersede a pinned version and the arm64
474# ports lag behind, so a pin breaks the build. The published digest is what fixes the versions.
475# ca-certificates is already in the base; naming it upgrades the trust store to the archive's
476# current one instead of the one frozen in the base digest.
477RUN apt-get update \
478 && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
479      ca-certificates {packages} \
480 && rm -rf /var/lib/apt/lists/*
481
482COPY --from={DEFAULT_SANDBOX_UV_IMAGE} /uv /uvx /usr/local/bin/
483"#,
484        packages = packages.join(" "),
485    )
486}
487
488/// Renders [`DEFAULT_SANDBOX_TOOLS_FILE`], one version command per line.
489#[cfg(test)]
490fn default_sandbox_tools_list() -> String {
491    let mut list = format!(
492        "# Generated by `cargo test -p alien-core --lib sandbox_image`. Do not edit by hand.
493# Regenerate with {SANDBOX_FILES_UPDATE}=1 in front of that command.
494#
495# One command per tool the default sandbox base ships; each prints a version and exits zero.
496"
497    );
498    for tool in DEFAULT_SANDBOX_TOOLS {
499        list.push_str(tool.version_command);
500        list.push('\n');
501    }
502    list
503}
504
505/// Where a GCP image's final stage starts.
506#[cfg(test)]
507enum GcpBase {
508    Image(&'static str),
509    /// A build-arg with no default, which whoever builds the image must pass.
510    BuildArg(&'static str),
511}
512
513/// Renders [`GCP_DOCKERFILE`], the minimal wolfi image.
514#[cfg(test)]
515fn gcp_agent_platform_dockerfile() -> String {
516    gcp_dockerfile(
517        "Multi-arch build for the alien-sandbox-agent Docker image",
518        GcpBase::Image("docker.io/chainguard/wolfi-base:latest"),
519        "# git is for the sandboxed command, not the agent, and pulls 24 transitive packages. That cost
520# lands here because this image is the sandbox, with no customer base image underneath to carry it.
521RUN apk add --no-cache git",
522    )
523}
524
525/// Renders [`GCP_DEFAULT_DOCKERFILE`], the default GCP sandbox image: the agent on the default
526/// sandbox base ([`DEFAULT_SANDBOX_DOCKERFILE`]), which whoever builds it passes by digest.
527#[cfg(test)]
528fn gcp_default_sandbox_dockerfile() -> String {
529    assert_eq!(
530        GCP_AGENT_PLATFORM.exec_uid, 1000,
531        "the userdel below exists only because Ubuntu's own user holds the exec uid"
532    );
533    gcp_dockerfile(
534        "Multi-arch build for the default GCP sandbox image: the default sandbox base plus the agent",
535        GcpBase::BuildArg("SANDBOX_DEFAULT_BASE"),
536        "# Ubuntu ships `ubuntu` at uid 1000. Appending a second entry for that uid leaves `id` and every
537# tool resolving it to `ubuntu`, so the exec user would not be `sandbox`.
538RUN userdel --remove ubuntu",
539    )
540}
541
542/// Renders a GCP Dockerfile onto `base`, with `base_setup` run as root before the agent lands.
543///
544/// Everything outside the shared block is here because it is true of the GCP images alone: the
545/// `binary-selector` stage, which exists because the release workflow builds one manifest for two
546/// architectures from binaries cross-compiled outside Docker; and `RUST_LOG`, which the agent's own
547/// `EnvFilter` needs before it will emit anything.
548#[cfg(test)]
549fn gcp_dockerfile(title: &str, base: GcpBase, base_setup: &str) -> String {
550    let image = &GCP_AGENT_PLATFORM;
551    // An ARG read by a FROM must precede the first FROM, or it is scoped to a stage and empty.
552    // BuildKit reads a parser directive only on the first lines, before any other comment.
553    let (directive, base_arg, base) = match base {
554        GcpBase::Image(reference) => (String::new(), String::new(), reference.to_string()),
555        GcpBase::BuildArg(name) => (
556            "# check=skip=InvalidDefaultArgInFrom\n".to_string(),
557            format!(
558                "# No default: the base's digest exists only once it is built, so whoever builds \
559                 this image\n# passes it. The check directive on line 1 is for this.\nARG {name}\n\n"
560            ),
561            format!("${{{name}}}"),
562        ),
563    };
564    format!(
565        r#"{directive}# Generated by `cargo test -p alien-core --lib sandbox_image`. Do not edit by hand.
566# Regenerate with {SANDBOX_FILES_UPDATE}=1 in front of that command.
567#
568# {title}
569# Run directly as the GCP Agent Platform sandbox; nothing layers on top of it
570
571{base_arg}FROM docker.io/chainguard/wolfi-base:latest AS binary-selector
572
573COPY target/aarch64-unknown-linux-musl/release/alien-sandbox-agent /tmp/alien-sandbox-agent-aarch64
574COPY target/x86_64-unknown-linux-musl/release/alien-sandbox-agent /tmp/alien-sandbox-agent-x86_64
575
576ARG TARGETARCH
577RUN case "$TARGETARCH" in \
578       amd64)  cp /tmp/alien-sandbox-agent-x86_64 /tmp/alien-sandbox-agent ;; \
579       arm64)  cp /tmp/alien-sandbox-agent-aarch64 /tmp/alien-sandbox-agent ;; \
580       *)      echo "unsupported TARGETARCH '$TARGETARCH'" >&2; exit 1 ;; \
581    esac
582
583FROM {base}
584
585{base_setup}
586
587# Root-owned and unwritable by uid {exec_uid}: the supervised command runs under that uid and must not
588# be able to rewrite its own supervisor.
589COPY --from=binary-selector --chown=0:0 --chmod={AGENT_MODE:04o} \
590     /tmp/alien-sandbox-agent {AGENT_PATH}
591
592# Numeric ids and a plain append rather than adduser, which differs across base distributions.
593# Linux runs a process under a uid with no passwd entry, but tooling inside the sandbox reads one.
594{identity}
595
596# The template carries no env, so the contract lives here, and none of it is optional. transport
597# serves an uncapabilitied request only from a socket `peer::transport_may_serve` cannot trace
598# back to the exec uid, and the agent refuses the mode where /proc/net/tcp is unreadable.
599{env}
600
601# The release build resolves tracing-subscriber once across every package it names, and five of
602# them ask for env-filter, so the agent's fmt::init() has an EnvFilter under it. Unset, that
603# filter discards the startup warning saying this image serves requests without a capability.
604ENV RUST_LOG={GCP_AGENT_LOG_FILTER} \
605    ALIEN_SANDBOX_IMAGE_COMMAND=true
606
607# The edge consumes `Authorization` for its own credential, so a preview caller's bearer arrives in
608# this header and the agent hands it to the code inside as `Authorization`.
609ENV {ENV_CALLER_AUTHORIZATION_HEADER}={CALLER_AUTHORIZATION_HEADER}
610
611# These published agent images have no application startup command. Declare that explicitly so
612# inherited base CMD values cannot become agent arguments or a second shell process.
613RUN mkdir -p /opt/alien \
614 && printf '%s\n' '{empty_image_command}' > {IMAGE_COMMAND_PATH} \
615 && chmod 0444 {IMAGE_COMMAND_PATH}
616
617{entrypoint}
618CMD []
619"#,
620        empty_image_command = serde_json::to_string(&SandboxImageCommand {
621            user: Some(String::new()),
622            working_directory: "/".into(),
623            ..Default::default()
624        })
625        .expect("static default image command must serialize"),
626        exec_uid = image.exec_uid,
627        identity = identity_setup(image),
628        env = contract_env(image),
629        entrypoint = entrypoint(image),
630    )
631}
632
633#[cfg(test)]
634mod tests {
635    use super::*;
636
637    /// A root-supervisor workload commonly binds 8080 itself; the agent must not take it.
638    #[test]
639    fn the_gcp_agent_leaves_port_8080_to_the_workload() {
640        assert_ne!(GCP_AGENT_PLATFORM.port, 8080);
641        assert_eq!(GCP_AGENT_PLATFORM.port, AGENT_PORT);
642    }
643
644    /// The published contract value (Docker's default set without `NET_RAW`); the name list the
645    /// pod grants must equal the mask the agent applies.
646    #[test]
647    fn root_capability_set_is_dockers_default_without_net_raw() {
648        assert_eq!(IMAGE_ROOT_CAPABILITY_MASK, 0xa80405fb);
649        for forbidden in ["NET_ADMIN", "SYS_ADMIN", "NET_RAW"] {
650            assert!(IMAGE_ROOT_CAPABILITY_SET
651                .iter()
652                .all(|(name, _)| *name != forbidden));
653        }
654    }
655
656    fn committed_path(relative: &str) -> std::path::PathBuf {
657        std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
658            .join("../..")
659            .join(relative)
660    }
661
662    /// Where two texts first part, in terms a reader can act on. `assert_eq!` on a whole
663    /// Dockerfile prints two escaped blobs and says nothing about which line moved.
664    fn first_difference(committed: &str, rendered: &str) -> String {
665        for (index, (left, right)) in committed.lines().zip(rendered.lines()).enumerate() {
666            if left != right {
667                let line = index + 1;
668                return format!("line {line}: committed {left:?}, contract renders {right:?}");
669            }
670        }
671        format!(
672            "committed has {} lines, the contract renders {}",
673            committed.lines().count(),
674            rendered.lines().count()
675        )
676    }
677
678    /// The whole file, not chosen properties. A mutation this comparison cannot see is one that
679    /// leaves the bytes alone, and there is no such mutation.
680    #[test]
681    fn the_committed_gcp_dockerfiles_are_what_the_contract_renders() {
682        for (file, rendered) in [
683            (GCP_DOCKERFILE, gcp_agent_platform_dockerfile()),
684            (GCP_DEFAULT_DOCKERFILE, gcp_default_sandbox_dockerfile()),
685            (DEFAULT_SANDBOX_DOCKERFILE, default_sandbox_dockerfile()),
686            (DEFAULT_SANDBOX_TOOLS_FILE, default_sandbox_tools_list()),
687        ] {
688            let path = committed_path(file);
689
690            if std::env::var_os(SANDBOX_FILES_UPDATE).is_some() {
691                std::fs::write(&path, &rendered)
692                    .unwrap_or_else(|error| panic!("{} must be writable: {error}", path.display()));
693                continue;
694            }
695
696            let committed = std::fs::read_to_string(&path)
697                .unwrap_or_else(|error| panic!("{} must be readable: {error}", path.display()));
698            assert!(
699                committed == rendered,
700                "{file} has drifted from the contract it is rendered from.\n\
701                 {}\n\
702                 Regenerate it: {SANDBOX_FILES_UPDATE}=1 cargo test -p alien-core --lib sandbox_image",
703                first_difference(&committed, &rendered)
704            );
705        }
706    }
707
708    /// An image built without a Dockerfile carries what the CI images carry, so the env the
709    /// accessor hands out is read back from the committed file rather than restated.
710    #[test]
711    fn the_gcp_env_accessor_is_every_env_the_committed_dockerfile_sets() {
712        let committed = std::fs::read_to_string(committed_path(GCP_DEFAULT_DOCKERFILE)).unwrap();
713        let mut set = Vec::new();
714        let mut in_env = false;
715        for line in committed.lines() {
716            let line = line.trim();
717            let rest = match line.strip_prefix("ENV ") {
718                Some(rest) => rest,
719                None if in_env => line,
720                None => continue,
721            };
722            in_env = rest.ends_with('\\');
723            for pair in rest.trim_end_matches('\\').split_whitespace() {
724                let (name, value) = pair.split_once('=').expect("ENV name=value");
725                set.push((name.to_string(), value.to_string()));
726            }
727        }
728        let accessor: Vec<(String, String)> = gcp_agent_platform_env()
729            .into_iter()
730            .map(|(name, value)| (name.to_string(), value))
731            .collect();
732        assert_eq!(accessor, set);
733    }
734
735    /// Every consumer derives these, so nothing else compares them against a number. The
736    /// setup emitters tell the agent which uid to drop to; if that stops matching the uid the
737    /// image creates, the sandbox starts and every exec fails.
738    #[test]
739    fn the_two_images_carry_the_identities_their_stacks_were_built_against() {
740        assert_eq!(AWS_MICROVM.port, 8971);
741        assert_eq!(AWS_MICROVM.exec_uid, 60000);
742        assert_eq!(AWS_MICROVM.session_root, "/sandbox");
743        assert_eq!(GCP_AGENT_PLATFORM.port, 8971);
744        assert_eq!(GCP_AGENT_PLATFORM.exec_uid, 1000);
745        assert_eq!(GCP_AGENT_PLATFORM.session_root, "/sandbox");
746        for image in [&AWS_MICROVM, &GCP_AGENT_PLATFORM] {
747            assert_ne!(image.exec_uid, 0, "the exec uid must never be root");
748        }
749    }
750
751    /// The ending an image declares and the isolation it claims come off one value, so they
752    /// cannot disagree. The AWS half is rendered at run time and reaches no committed file, which
753    /// is why the whole-file comparison above covers only the GCP side of it.
754    #[test]
755    fn the_ending_an_image_declares_follows_its_isolation() {
756        assert!(!entrypoint(&AWS_MICROVM).contains("USER "));
757        assert!(contract_env(&AWS_MICROVM).contains("ALIEN_SANDBOX_ISOLATION=uid-split"));
758        assert_eq!(GCP_AGENT_PLATFORM.isolation, Isolation::UidSplit);
759        assert!(contract_env(&GCP_AGENT_PLATFORM).contains("ALIEN_SANDBOX_ISOLATION=uid-split"));
760    }
761}
762
763/// Root-owned metadata copied from the base image at bundle creation, never from an exec caller.
764#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
765#[serde(rename_all = "camelCase", deny_unknown_fields)]
766pub struct SandboxImageCommand {
767    /// Original OCI USER, including an empty string for Docker's root default.
768    /// Absent only in released metadata whose boot command used the exec identity.
769    #[serde(default, skip_serializing_if = "Option::is_none")]
770    pub user: Option<String>,
771    /// OCI Entrypoint followed by Cmd; empty means there is no image command.
772    pub command: Vec<String>,
773    /// Image environment only, before runtime authorization and provider variables are added.
774    pub env: std::collections::BTreeMap<String, String>,
775    /// OCI WorkingDir, or / if the image does not declare one.
776    pub working_directory: String,
777}
778
779/// Installed outside the command-writable session directory.
780pub const IMAGE_COMMAND_PATH: &str = "/opt/alien/image-command.json";
781
782/// Per-boot agent credential read only through an authenticated native file API.
783pub const NATIVE_TOKEN_PATH: &str = "/opt/alien/native-token";