diff --git a/crates/worker/Cargo.toml b/crates/worker/Cargo.toml new file mode 100644 index 00000000..44c32d35 --- /dev/null +++ b/crates/worker/Cargo.toml @@ -0,0 +1,39 @@ +[package] +name = "faunosteo-worker" +description = "Faunosteo file-processing worker: job loop (R1) and the sandboxed decode child (R0 proof)" +version.workspace = true +edition.workspace = true +license.workspace = true +rust-version.workspace = true +publish.workspace = true + +[lib] +path = "src/lib.rs" + +[[bin]] +name = "faunosteo-worker" +path = "src/main.rs" + +[features] +default = [] +# Extra subcommands and flags for the sandbox tests and the seccomp derivation +# (crates/worker/Dockerfile stage `test`); never part of a release build. +test-hooks = ["dep:crc32fast"] + +[dependencies] +image.workspace = true +libwebp-sys.workspace = true +seccompiler.workspace = true +rlimit.workspace = true +libc.workspace = true +crc32fast = { version = "1.4", optional = true } + +# The worker owns I/O (it is the process boundary), so the core's disallowed_methods lint is +# off here; unsafe is allowed for the libwebp FFI only, each block carries a SAFETY comment. +[lints.rust] +unsafe_code = "allow" + +[lints.clippy] +unwrap_used = "deny" +expect_used = "deny" +disallowed_methods = "allow" diff --git a/crates/worker/Dockerfile b/crates/worker/Dockerfile new file mode 100644 index 00000000..6890654c --- /dev/null +++ b/crates/worker/Dockerfile @@ -0,0 +1,37 @@ +# syntax=docker/dockerfile:1.7 +# Faunosteo worker image (review Part IV, VIII.1). Build context = repository root: +# docker build -f crates/worker/Dockerfile --target test . # sandbox tests + seccomp derivation +# docker build -f crates/worker/Dockerfile -t faunosteo_worker:dev . # runtime image +# The binary is a static musl executable; the runtime image carries nothing else. + +FROM rust:1.99.0-alpine3.24 AS base +# build-base: the C compiler for libwebp (libwebp-sys, D-R4), nothing else is compiled from C. +# rustfmt/clippy: listed in rust-toolchain.toml, absent from the image's minimal profile. +RUN apk add --no-cache build-base && rustup component add rustfmt clippy +WORKDIR /w +COPY Cargo.toml Cargo.lock rust-toolchain.toml rustfmt.toml clippy.toml ./ +COPY .cargo .cargo +COPY crates crates + +FROM base AS build +RUN --mount=type=cache,id=faunosteo_cargo_registry_musl,target=/usr/local/cargo/registry \ + --mount=type=cache,id=faunosteo_target_musl,target=/w/target \ + cargo build -p faunosteo-worker --release --locked \ + && cp target/release/faunosteo-worker /faunosteo-worker + +# The tests run against the musl binary that ships, inside the default Docker seccomp +# profile (the inner filter is allowed by it). strace serves the allowlist derivation. +FROM base AS test +RUN apk add --no-cache strace +RUN --mount=type=cache,id=faunosteo_cargo_registry_musl,target=/usr/local/cargo/registry \ + --mount=type=cache,id=faunosteo_target_musl,target=/w/target \ + cargo test -p faunosteo-worker --features test-hooks --locked -- --test-threads=4 +RUN --mount=type=cache,id=faunosteo_cargo_registry_musl,target=/usr/local/cargo/registry \ + --mount=type=cache,id=faunosteo_target_musl,target=/w/target \ + sh crates/worker/scripts/derive-seccomp.sh + +FROM gcr.io/distroless/static-debian12:nonroot AS runtime +COPY --from=build /faunosteo-worker /faunosteo-worker +USER nonroot +ENTRYPOINT ["/faunosteo-worker"] +CMD ["run", "--check"] diff --git a/crates/worker/scripts/derive-seccomp.sh b/crates/worker/scripts/derive-seccomp.sh new file mode 100755 index 00000000..a1684092 --- /dev/null +++ b/crates/worker/scripts/derive-seccomp.sh @@ -0,0 +1,41 @@ +#!/bin/sh +# Derives the seccomp allowlist of the decode child from a real trace and checks it against +# `sandbox::ALLOWED_SYSCALLS` (review Part IV.1: "derived by strace over the fixture corpus +# at the caps on the production image, not hand-written"). Runs in the Alpine `test` stage +# of crates/worker/Dockerfile, where the musl binary that ships is built. +# +# Exit 1 when a traced syscall is missing from the allowlist (the sandbox would kill a +# legitimate decode). Syscalls the list allows but the trace never shows are printed for +# review (the abort path is expected there). +set -eu + +bin=target/debug/faunosteo-worker +cargo build -p faunosteo-worker --features test-hooks --locked +work=$(mktemp -d) + +fixtures="png jpeg webp big-jpeg big-png" +: > "$work/traced.raw" +for kind in $fixtures; do + "$bin" fixture "$kind" > "$work/$kind.bin" + # `env -i`: the child refuses a non-empty environment; `--no-seccomp` keeps the rlimits + # and prints the marker where the filter would be installed. + env -i strace -f -qq -o "$work/trace.$kind" "$bin" decode --no-seccomp \ + < "$work/$kind.bin" > "$work/$kind.webp" + awk 'found { print } /SECCOMP-MARKER/ { found = 1 }' "$work/trace.$kind" \ + | sed -E 's/^[0-9]+ +//; /^(\+\+\+|---)/d; s/^<\.\.\. ([a-z0-9_]+) resumed>.*/\1/; s/\(.*//' \ + | grep -E '^[a-z0-9_]+$' >> "$work/traced.raw" || true +done +sort -u "$work/traced.raw" > "$work/traced.txt" +"$bin" print-allowlist | sort -u > "$work/allowed.txt" + +echo "== syscalls traced after the sandbox marker" +cat "$work/traced.txt" +missing=$(comm -23 "$work/traced.txt" "$work/allowed.txt") +extra=$(comm -13 "$work/traced.txt" "$work/allowed.txt") +echo "== allowed but not traced (abort path expected): $(echo "$extra" | tr '\n' ' ')" +if [ -n "$missing" ]; then + echo "== TRACED BUT NOT ALLOWED (the filter would kill a legitimate decode):" + echo "$missing" + exit 1 +fi +echo "== allowlist covers the trace" diff --git a/crates/worker/src/decode.rs b/crates/worker/src/decode.rs new file mode 100644 index 00000000..fab9dedf --- /dev/null +++ b/crates/worker/src/decode.rs @@ -0,0 +1,286 @@ +//! The decode child: bytes in, one 512 × 512 lossy WebP out (review Part IV.1). R0 ships +//! the pipeline as the sandbox, musl and libwebp proof; the job semantics arrive with R1. + +use std::ffi::c_int; +use std::io::{self, Cursor, Read, Write}; + +use image::error::LimitErrorKind; +use image::imageops::FilterType; +use image::metadata::Orientation; +use image::{DynamicImage, ImageDecoder, ImageError, ImageFormat, ImageReader, Limits}; + +use crate::exit_codes; +use crate::limits::{ + MAX_ALLOC_BYTES, MAX_INPUT_BYTES, MAX_SIDE, MIN_SIDE, OUTPUT_SIDE, WEBP_QUALITY, +}; +use crate::sandbox; + +/// Why the child refused an input (one exit code each). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Reject { + UnsupportedType, + DecodeFailed, + Dimensions, + EncodeFailed, + Internal, +} + +impl Reject { + pub fn exit_code(self) -> i32 { + match self { + Self::UnsupportedType => exit_codes::UNSUPPORTED_TYPE, + Self::DecodeFailed => exit_codes::DECODE_FAILED, + Self::Dimensions => exit_codes::DIMENSIONS, + Self::EncodeFailed => exit_codes::ENCODE_FAILED, + Self::Internal => exit_codes::INTERNAL, + } + } +} + +/// Entry of `faunosteo-worker decode`: returns the process exit code. +/// +/// Order matters: the environment check and the sandbox come before the first byte of +/// input is read, and no thread exists at that point (`main` is a plain function). +pub fn main( + args: &[String], + stdin: &mut dyn Read, + stdout: &mut dyn Write, + stderr: &mut dyn Write, +) -> i32 { + if std::env::vars_os().next().is_some() { + let _ = writeln!(stderr, "decode: the environment must be empty"); + return exit_codes::ENV_NOT_EMPTY; + } + let hooks = match TestHooks::parse(args) { + Ok(hooks) => hooks, + Err(message) => { + let _ = writeln!(stderr, "decode: {message}"); + return exit_codes::USAGE; + } + }; + if let Err(error) = sandbox::apply(&sandbox::Limits::default(), hooks.seccomp) { + let _ = writeln!(stderr, "decode: sandbox: {error}"); + return exit_codes::SANDBOX_FAILED; + } + if let Some(code) = hooks.run_after_sandbox(stdout, stderr) { + return code; + } + + let mut input = Vec::new(); + let read = stdin + .take(MAX_INPUT_BYTES as u64 + 1) + .read_to_end(&mut input); + if read.is_err() { + return exit_codes::INTERNAL; + } + if input.len() > MAX_INPUT_BYTES { + let _ = writeln!(stderr, "decode: input over {MAX_INPUT_BYTES} bytes"); + return exit_codes::INPUT_TOO_LARGE; + } + + match process(&input) { + Ok(webp) => match stdout.write_all(&webp).and_then(|()| stdout.flush()) { + Ok(()) => exit_codes::OK, + Err(_) => exit_codes::OUTPUT_FAILED, + }, + Err(reject) => { + let _ = writeln!(stderr, "decode: {}", exit_codes::name(reject.exit_code())); + reject.exit_code() + } + } +} + +/// Decodes, orients, crops to a square and encodes one image; pure function of the bytes. +pub fn process(bytes: &[u8]) -> Result, Reject> { + let format = image::guess_format(bytes).map_err(|_| Reject::UnsupportedType)?; + if !matches!( + format, + ImageFormat::Jpeg | ImageFormat::Png | ImageFormat::WebP + ) { + return Err(Reject::UnsupportedType); + } + let mut reader = ImageReader::with_format(Cursor::new(bytes), format); + let mut limits = Limits::default(); + limits.max_image_width = Some(MAX_SIDE); + limits.max_image_height = Some(MAX_SIDE); + limits.max_alloc = Some(MAX_ALLOC_BYTES); + reader.limits(limits); + + let mut decoder = reader.into_decoder().map_err(map_image_error)?; + let (width, height) = decoder.dimensions(); + if width < MIN_SIDE || height < MIN_SIDE { + return Err(Reject::Dimensions); + } + let orientation = decoder.orientation().unwrap_or(Orientation::NoTransforms); + let mut image = DynamicImage::from_decoder(decoder).map_err(map_image_error)?; + image.apply_orientation(orientation); + let square = image + .resize_to_fill(OUTPUT_SIDE, OUTPUT_SIDE, FilterType::Lanczos3) + .into_rgba8(); + encode_webp(square.as_raw(), OUTPUT_SIDE, OUTPUT_SIDE, WEBP_QUALITY) +} + +fn map_image_error(error: ImageError) -> Reject { + match error { + ImageError::Limits(limit) => match limit.kind() { + LimitErrorKind::DimensionError => Reject::Dimensions, + _ => Reject::Internal, + }, + ImageError::Unsupported(_) => Reject::UnsupportedType, + ImageError::Decoding(_) | ImageError::IoError(_) => Reject::DecodeFailed, + _ => Reject::Internal, + } +} + +/// Encodes an RGBA buffer as lossy WebP through libwebp (D-R4: C confined to this process). +pub fn encode_webp(rgba: &[u8], width: u32, height: u32, quality: f32) -> Result, Reject> { + let expected = (width as usize) + .checked_mul(height as usize) + .and_then(|n| n.checked_mul(4)); + if expected != Some(rgba.len()) { + return Err(Reject::Internal); + } + let (Ok(w), Ok(h), Ok(stride)) = ( + c_int::try_from(width), + c_int::try_from(height), + c_int::try_from(width * 4), + ) else { + return Err(Reject::Internal); + }; + let mut output: *mut u8 = std::ptr::null_mut(); + // SAFETY: `rgba` holds exactly width × height × 4 bytes (checked above) with the matching + // stride; libwebp allocates the encoded buffer, writes its address into `output` and + // returns its size. The buffer is copied once and released with the matching WebPFree. + let size = + unsafe { libwebp_sys::WebPEncodeRGBA(rgba.as_ptr(), w, h, stride, quality, &mut output) }; + if size == 0 || output.is_null() { + return Err(Reject::EncodeFailed); + } + // SAFETY: libwebp returned `size` initialised bytes at `output`. + let encoded = unsafe { std::slice::from_raw_parts(output, size) }.to_vec(); + // SAFETY: `output` came from libwebp's allocator and is not read afterwards. + unsafe { libwebp_sys::WebPFree(output.cast()) }; + Ok(encoded) +} + +/// Version of the libwebp linked into this binary, as (major, minor, revision). +pub fn libwebp_version() -> (u8, u8, u8) { + // SAFETY: a pure getter of the FFI without arguments or side effects. + let packed = unsafe { libwebp_sys::WebPGetEncoderVersion() }; + let packed = u32::try_from(packed).unwrap_or(0); + ( + u8::try_from((packed >> 16) & 0xff).unwrap_or(0), + u8::try_from((packed >> 8) & 0xff).unwrap_or(0), + u8::try_from(packed & 0xff).unwrap_or(0), + ) +} + +/// Flags of the test build (`--features test-hooks`); a release build accepts no argument. +#[derive(Debug, Default)] +pub struct TestHooks { + pub seccomp: bool, + #[cfg(feature = "test-hooks")] + action: Option, +} + +#[cfg(feature = "test-hooks")] +#[derive(Debug, Clone, Copy)] +enum HookAction { + /// Makes a denied syscall (`getcwd`) after the filter: the child must die with SIGSYS. + Violate, + /// Writes a megabyte on stdout: the parent must cut the child at its output cap. + Flood, + /// Allocates the given number of GiB: `RLIMIT_AS` must abort the child. + AllocGib(usize), + /// Burns CPU forever: `RLIMIT_CPU` (SIGXCPU) or the parent's deadline must stop it. + Spin, +} + +impl TestHooks { + fn parse(args: &[String]) -> Result { + #[cfg(not(feature = "test-hooks"))] + let hooks = Self { seccomp: true }; + #[cfg(feature = "test-hooks")] + let mut hooks = Self { + seccomp: true, + action: None, + }; + #[cfg(feature = "test-hooks")] + { + let mut iter = args.iter(); + while let Some(arg) = iter.next() { + match arg.as_str() { + "--no-seccomp" => hooks.seccomp = false, + "--violate" => hooks.action = Some(HookAction::Violate), + "--flood" => hooks.action = Some(HookAction::Flood), + "--spin" => hooks.action = Some(HookAction::Spin), + "--alloc-gib" => { + let value = iter + .next() + .and_then(|v| v.parse().ok()) + .ok_or("--alloc-gib ")?; + hooks.action = Some(HookAction::AllocGib(value)); + } + other => return Err(format!("unknown flag {other}")), + } + } + } + #[cfg(not(feature = "test-hooks"))] + if let Some(arg) = args.first() { + return Err(format!("unexpected argument {arg}")); + } + Ok(hooks) + } + + #[cfg(feature = "test-hooks")] + fn run_after_sandbox(&self, stdout: &mut dyn Write, stderr: &mut dyn Write) -> Option { + if !self.seccomp { + // Marker for crates/worker/scripts/derive-seccomp.sh: syscalls after this line + // are the ones the filter must allow. + let _ = stderr.write_all(b"SECCOMP-MARKER\n"); + } + match self.action? { + HookAction::Violate => { + let cwd = std::env::current_dir(); + let _ = writeln!(stderr, "decode: getcwd survived the filter: {cwd:?}"); + Some(exit_codes::INTERNAL) + } + HookAction::Flood => { + let chunk = vec![0u8; 64 * 1024]; + for _ in 0..16 { + if stdout.write_all(&chunk).is_err() { + return Some(exit_codes::OUTPUT_FAILED); + } + } + Some(exit_codes::OK) + } + HookAction::AllocGib(gib) => { + let bytes = gib.saturating_mul(1024 * 1024 * 1024); + let buffer = vec![1u8; bytes]; + let _ = writeln!( + stderr, + "decode: allocated {} bytes", + std::hint::black_box(&buffer).len() + ); + Some(exit_codes::INTERNAL) + } + HookAction::Spin => loop { + std::hint::black_box(0u8); + }, + } + } + + #[cfg(not(feature = "test-hooks"))] + fn run_after_sandbox(&self, _stdout: &mut dyn Write, _stderr: &mut dyn Write) -> Option { + None + } +} + +/// Reads at most `cap` bytes from a reader, reporting whether more were available. +pub fn read_capped(reader: &mut dyn Read, cap: usize) -> io::Result<(Vec, bool)> { + let mut buffer = Vec::new(); + reader.take(cap as u64 + 1).read_to_end(&mut buffer)?; + let overflow = buffer.len() > cap; + buffer.truncate(cap); + Ok((buffer, overflow)) +} diff --git a/crates/worker/src/exit_codes.rs b/crates/worker/src/exit_codes.rs new file mode 100644 index 00000000..fb82a550 --- /dev/null +++ b/crates/worker/src/exit_codes.rs @@ -0,0 +1,33 @@ +//! Exit codes of the `decode` child, reserved away from 1 (generic failure), 101 (Rust +//! panic) and signal deaths (reported separately by the parent). The parent maps them to +//! the closed rejection reasons of STEP8_FILES_ANALYSIS II.7. + +pub const OK: i32 = 0; +pub const USAGE: i32 = 2; +pub const ENV_NOT_EMPTY: i32 = 10; +pub const SANDBOX_FAILED: i32 = 11; +pub const INPUT_TOO_LARGE: i32 = 12; +pub const UNSUPPORTED_TYPE: i32 = 13; +pub const DECODE_FAILED: i32 = 14; +pub const DIMENSIONS: i32 = 15; +pub const ENCODE_FAILED: i32 = 16; +pub const OUTPUT_FAILED: i32 = 17; +pub const INTERNAL: i32 = 18; + +/// Stable name of an exit code for logs and tests. +pub fn name(code: i32) -> &'static str { + match code { + OK => "ok", + USAGE => "usage", + ENV_NOT_EMPTY => "env_not_empty", + SANDBOX_FAILED => "sandbox_failed", + INPUT_TOO_LARGE => "input_too_large", + UNSUPPORTED_TYPE => "unsupported_type", + DECODE_FAILED => "decode_failed", + DIMENSIONS => "dimensions", + ENCODE_FAILED => "encode_failed", + OUTPUT_FAILED => "output_failed", + INTERNAL => "internal", + _ => "unknown", + } +} diff --git a/crates/worker/src/fixtures.rs b/crates/worker/src/fixtures.rs new file mode 100644 index 00000000..de6149ca --- /dev/null +++ b/crates/worker/src/fixtures.rs @@ -0,0 +1,96 @@ +//! Synthetic images for the sandbox tests and the seccomp derivation (`test-hooks` only): +//! nothing binary lives in the repository. + +use std::io::Cursor; + +use image::{DynamicImage, ImageBuffer, ImageFormat, Rgba}; + +fn gradient(width: u32, height: u32) -> DynamicImage { + let buffer = ImageBuffer::from_fn(width, height, |x, y| { + let r = u8::try_from(x * 255 / width.max(1)).unwrap_or(255); + let g = u8::try_from(y * 255 / height.max(1)).unwrap_or(255); + let b = u8::try_from((x / 8 + y / 8) % 256).unwrap_or(0); + Rgba([r, g, b, 255]) + }); + DynamicImage::ImageRgba8(buffer) +} + +fn encode(image: &DynamicImage, format: ImageFormat) -> Vec { + let mut out = Cursor::new(Vec::new()); + if image.write_to(&mut out, format).is_err() { + return Vec::new(); + } + out.into_inner() +} + +/// A PNG gradient. +pub fn png(width: u32, height: u32) -> Vec { + encode(&gradient(width, height), ImageFormat::Png) +} + +/// A baseline JPEG gradient (no alpha channel). +pub fn jpeg(width: u32, height: u32) -> Vec { + let rgb = DynamicImage::ImageRgb8(gradient(width, height).into_rgb8()); + encode(&rgb, ImageFormat::Jpeg) +} + +/// A lossless WebP gradient (the only WebP encoder of the `image` crate). +pub fn webp(width: u32, height: u32) -> Vec { + encode(&gradient(width, height), ImageFormat::WebP) +} + +/// A PNG whose header declares `width` × `height` with no pixel data: the decoder must +/// refuse it on dimensions before allocating anything. +pub fn png_header_only(width: u32, height: u32) -> Vec { + let mut out = vec![0x89, b'P', b'N', b'G', 0x0d, 0x0a, 0x1a, 0x0a]; + let mut ihdr = Vec::new(); + ihdr.extend_from_slice(&width.to_be_bytes()); + ihdr.extend_from_slice(&height.to_be_bytes()); + ihdr.extend_from_slice(&[8, 6, 0, 0, 0]); + push_chunk(&mut out, b"IHDR", &ihdr); + push_chunk(&mut out, b"IEND", &[]); + out +} + +fn push_chunk(out: &mut Vec, kind: &[u8; 4], payload: &[u8]) { + out.extend_from_slice(&(payload.len() as u32).to_be_bytes()); + let mut hasher = crc32fast::Hasher::new(); + hasher.update(kind); + hasher.update(payload); + out.extend_from_slice(kind); + out.extend_from_slice(payload); + out.extend_from_slice(&hasher.finalize().to_be_bytes()); +} + +/// The first bytes of a GIF: a format the avatar pipeline never accepts. +pub fn gif() -> Vec { + let mut out = b"GIF89a".to_vec(); + out.extend_from_slice(&[64, 0, 64, 0, 0xf7, 0, 0]); + out.extend(std::iter::repeat_n(0u8, 800)); + out +} + +/// A valid PNG cut in half. +pub fn truncated_png() -> Vec { + let mut bytes = png(200, 200); + bytes.truncate(bytes.len() / 2); + bytes +} + +/// Writes one named fixture on stdout (`faunosteo-worker fixture `). +pub fn by_name(name: &str) -> Option> { + Some(match name { + "png" => png(800, 600), + "jpeg" => jpeg(640, 480), + "webp" => webp(300, 700), + "big-jpeg" => jpeg(4096, 4096), + // Same pixel budget as the JPEG but compressible (4096 × 2048 of this gradient + // weighed more than the 5 MiB input cap). + "big-png" => png(3000, 3000), + "tiny" => png(32, 32), + "huge-header" => png_header_only(20_000, 20_000), + "gif" => gif(), + "truncated" => truncated_png(), + _ => return None, + }) +} diff --git a/crates/worker/src/lib.rs b/crates/worker/src/lib.rs new file mode 100644 index 00000000..8981b33b --- /dev/null +++ b/crates/worker/src/lib.rs @@ -0,0 +1,15 @@ +//! `faunosteo-worker` library: the pieces the binary, the tests and the R1 job loop share. +//! +//! Process model (review Part IV.1): a keyed parent spawns the same binary as `decode`, a +//! child with an empty environment that confines itself (rlimits + seccomp) before reading +//! one image on stdin and writing one 512 × 512 WebP on stdout. The parent never decodes: +//! it checks the container header of what comes back (`webp_check`). + +pub mod decode; +pub mod exit_codes; +#[cfg(feature = "test-hooks")] +pub mod fixtures; +pub mod limits; +pub mod sandbox; +pub mod spawn; +pub mod webp_check; diff --git a/crates/worker/src/limits.rs b/crates/worker/src/limits.rs new file mode 100644 index 00000000..f418bd04 --- /dev/null +++ b/crates/worker/src/limits.rs @@ -0,0 +1,26 @@ +//! Caps of the decode child (review Part IV.1 and STEP8_FILES_ANALYSIS II.5 step 6). + +use std::time::Duration; + +/// Largest accepted upload (STEP8 D4: 5 MiB at upload). +pub const MAX_INPUT_BYTES: usize = 5 * 1024 * 1024; +/// Largest output the parent reads before killing the child (a 512 × 512 WebP is ~30 KB). +pub const MAX_OUTPUT_BYTES: usize = 512 * 1024; +/// Smallest accepted side of the source image. +pub const MIN_SIDE: u32 = 64; +/// Largest accepted side of the source image (header check before decoding). +pub const MAX_SIDE: u32 = 4096; +/// Allocation budget handed to the decoders (`image::Limits::max_alloc`, advisory). +pub const MAX_ALLOC_BYTES: u64 = 256 * 1024 * 1024; +/// Side of the produced avatar. +pub const OUTPUT_SIDE: u32 = 512; +/// Lossy WebP quality of the produced avatar. +pub const WEBP_QUALITY: f32 = 82.0; +/// Hard address-space cap of the child (`RLIMIT_AS`): the real memory bound. +pub const CHILD_ADDRESS_SPACE_BYTES: u64 = 512 * 1024 * 1024; +/// CPU-time cap of the child (`RLIMIT_CPU`, seconds). +pub const CHILD_CPU_SECONDS: u64 = 10; +/// Wall-clock deadline after which the parent kills the child. +pub const CHILD_DEADLINE: Duration = Duration::from_secs(20); +/// Oldest libwebp the worker accepts to link (D-R4: the linked version is controlled). +pub const MIN_LIBWEBP_VERSION: (u8, u8, u8) = (1, 6, 0); diff --git a/crates/worker/src/main.rs b/crates/worker/src/main.rs new file mode 100644 index 00000000..7eea8959 --- /dev/null +++ b/crates/worker/src/main.rs @@ -0,0 +1,113 @@ +//! `faunosteo-worker` entry: a plain `main`, no async runtime, no thread, so the `decode` +//! child installs its sandbox in a single-threaded process (review Part IV.1). +//! +//! R0 subcommands: `decode` (the sandboxed child), `run --check` (prints the resolved +//! configuration, no job loop before R1), `version`. + +use std::io::Write; + +use faunosteo_worker::decode; +use faunosteo_worker::exit_codes; +use faunosteo_worker::limits::MIN_LIBWEBP_VERSION; + +fn main() { + let args: Vec = std::env::args().collect(); + let code = match args.get(1).map(String::as_str) { + Some("decode") => { + let stdin = std::io::stdin(); + let stdout = std::io::stdout(); + let stderr = std::io::stderr(); + decode::main( + &args[2..], + &mut stdin.lock(), + &mut stdout.lock(), + &mut stderr.lock(), + ) + } + Some("run") => run(&args[2..]), + Some("version") => version(), + #[cfg(feature = "test-hooks")] + Some("fixture") => fixture(&args[2..]), + #[cfg(feature = "test-hooks")] + Some("print-allowlist") => { + for name in faunosteo_worker::sandbox::allowed_names() { + println!("{name}"); + } + exit_codes::OK + } + _ => { + eprintln!("usage: faunosteo-worker "); + exit_codes::USAGE + } + }; + std::process::exit(code); +} + +fn version() -> i32 { + let (major, minor, revision) = decode::libwebp_version(); + println!( + "faunosteo-worker {} (core {}, libwebp {major}.{minor}.{revision})", + env!("CARGO_PKG_VERSION"), + faunosteo_core_version() + ); + exit_codes::OK +} + +fn faunosteo_core_version() -> &'static str { + // The worker links no core module before R1 (nothing to share yet); the version printed + // is the workspace version the two crates share. + env!("CARGO_PKG_VERSION") +} + +/// `run --check`: prints what the worker would start with, without secrets. The job loop +/// arrives at R1; a plain `run` therefore refuses to pretend it works. +fn run(args: &[String]) -> i32 { + let (major, minor, revision) = decode::libwebp_version(); + let libwebp_ok = (major, minor, revision) >= MIN_LIBWEBP_VERSION; + println!("faunosteo-worker run: R0 skeleton, the job loop arrives at R1"); + println!( + "libwebp {major}.{minor}.{revision} ({})", + if libwebp_ok { + "accepted" + } else { + "below the minimum, refusing to start" + } + ); + for name in ["SUPABASE_URL", "SUPABASE_SERVICE_ROLE_KEY", "WORKER_ID"] { + let state = if std::env::var_os(name).is_some() { + "set" + } else { + "unset" + }; + println!("{name}: {state}"); + } + let _ = std::io::stdout().flush(); + if !libwebp_ok { + return exit_codes::INTERNAL; + } + if args.iter().any(|arg| arg == "--check") { + exit_codes::OK + } else { + eprintln!("run: nothing to do before R1 (use --check to print the configuration)"); + exit_codes::USAGE + } +} + +#[cfg(feature = "test-hooks")] +fn fixture(args: &[String]) -> i32 { + let Some(bytes) = args + .first() + .and_then(|name| faunosteo_worker::fixtures::by_name(name)) + else { + eprintln!( + "usage: faunosteo-worker fixture " + ); + return exit_codes::USAGE; + }; + let stdout = std::io::stdout(); + let mut lock = stdout.lock(); + if lock.write_all(&bytes).and_then(|()| lock.flush()).is_err() { + return exit_codes::OUTPUT_FAILED; + } + exit_codes::OK +} diff --git a/crates/worker/src/sandbox.rs b/crates/worker/src/sandbox.rs new file mode 100644 index 00000000..0f52603e --- /dev/null +++ b/crates/worker/src/sandbox.rs @@ -0,0 +1,200 @@ +//! Confinement of the decode child (review Part IV.1), applied by the child itself from a +//! single-threaded process before it reads any input. Three layers: an empty environment +//! (cleared by the parent, checked in `decode`), rlimits on address space and CPU time, and +//! a seccomp allowlist installed with TSYNC that kills the process on any other syscall. + +use std::collections::BTreeMap; +use std::fmt; + +use seccompiler::{BpfProgram, SeccompAction, SeccompFilter, SeccompRule, TargetArch}; + +use crate::limits; + +/// Syscalls the decode child makes once the filter is installed (static musl binary, x86_64). +/// +/// Derived with `strace -f` over the fixture corpus at the caps (`crates/worker/scripts/ +/// derive-seccomp.sh`, run by the Dockerfile stage `test`, 2026-10-12: exactly these seven +/// after the marker) and proven by running every fixture through the full sandbox. musl's +/// mallocng used neither `brk` nor `mprotect`, and no `futex` appears in a single-threaded +/// decode. +pub const ALLOWED_SYSCALLS: &[(&str, i64)] = &[ + ("read", libc::SYS_read), + ("write", libc::SYS_write), + ("mmap", libc::SYS_mmap), + ("munmap", libc::SYS_munmap), + ("mremap", libc::SYS_mremap), + ("exit_group", libc::SYS_exit_group), + ("getrandom", libc::SYS_getrandom), +]; + +/// Syscalls of the abort path (`RLIMIT_AS` hit, allocation failure, panic = abort): what +/// musl's `abort()` and Rust's alloc error handler need, proven by the sandbox test +/// `the_address_space_limit_aborts_a_huge_allocation` (SIGABRT observed, not SIGSYS). +pub const ABORT_PATH_SYSCALLS: &[(&str, i64)] = &[ + ("rt_sigaction", libc::SYS_rt_sigaction), + ("rt_sigprocmask", libc::SYS_rt_sigprocmask), + ("getpid", libc::SYS_getpid), + ("gettid", libc::SYS_gettid), + ("tkill", libc::SYS_tkill), + ("tgkill", libc::SYS_tgkill), + ("exit", libc::SYS_exit), +]; + +/// Resource limits of the child. +#[derive(Debug, Clone, Copy)] +pub struct Limits { + pub address_space_bytes: u64, + pub cpu_seconds: u64, +} + +impl Default for Limits { + fn default() -> Self { + Self { + address_space_bytes: limits::CHILD_ADDRESS_SPACE_BYTES, + cpu_seconds: limits::CHILD_CPU_SECONDS, + } + } +} + +/// Why the sandbox could not be applied (the child exits `sandbox_failed`). +#[derive(Debug)] +pub enum SandboxError { + NotSingleThreaded(usize), + ProcStatusUnreadable, + Rlimit(String), + Seccomp(String), + UnsupportedArchitecture, +} + +impl fmt::Display for SandboxError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::NotSingleThreaded(n) => write!(f, "process has {n} threads, expected 1"), + Self::ProcStatusUnreadable => write!(f, "/proc/self/status unreadable"), + Self::Rlimit(detail) => write!(f, "rlimit: {detail}"), + Self::Seccomp(detail) => write!(f, "seccomp: {detail}"), + Self::UnsupportedArchitecture => write!(f, "no seccomp filter for this architecture"), + } + } +} + +impl std::error::Error for SandboxError {} + +/// Applies the three layers. `seccomp = false` keeps only the rlimits (the strace +/// derivation run of the test stage); a release child always passes `true`. +pub fn apply(limits: &Limits, seccomp: bool) -> Result<(), SandboxError> { + ensure_single_thread()?; + set_rlimits(limits)?; + if seccomp { + install_seccomp()?; + } + Ok(()) +} + +/// Every syscall name the filter allows, for the derivation script and the tests. +pub fn allowed_names() -> Vec<&'static str> { + ALLOWED_SYSCALLS + .iter() + .chain(ABORT_PATH_SYSCALLS) + .map(|(name, _)| *name) + .collect() +} + +/// Parses the `Threads:` line of a `/proc//status` text. +pub fn thread_count(status: &str) -> Option { + status + .lines() + .find_map(|line| line.strip_prefix("Threads:")) + .and_then(|value| value.trim().parse().ok()) +} + +fn ensure_single_thread() -> Result<(), SandboxError> { + let status = std::fs::read_to_string("/proc/self/status") + .map_err(|_| SandboxError::ProcStatusUnreadable)?; + match thread_count(&status) { + Some(1) => Ok(()), + Some(n) => Err(SandboxError::NotSingleThreaded(n)), + None => Err(SandboxError::ProcStatusUnreadable), + } +} + +fn set_rlimits(limits: &Limits) -> Result<(), SandboxError> { + rlimit::setrlimit( + rlimit::Resource::AS, + limits.address_space_bytes, + limits.address_space_bytes, + ) + .map_err(|error| SandboxError::Rlimit(format!("RLIMIT_AS: {error}")))?; + // Soft limit first (SIGXCPU, observable), hard limit two seconds later (SIGKILL): with + // soft == hard the kernel checks the hard limit first and the child dies by SIGKILL, + // indistinguishable from the parent's own deadline kill. + rlimit::setrlimit( + rlimit::Resource::CPU, + limits.cpu_seconds, + limits.cpu_seconds + 2, + ) + .map_err(|error| SandboxError::Rlimit(format!("RLIMIT_CPU: {error}"))) +} + +/// Builds the BPF program: allow the listed syscalls, kill the process on anything else. +pub fn build_filter() -> Result { + let rules: BTreeMap> = ALLOWED_SYSCALLS + .iter() + .chain(ABORT_PATH_SYSCALLS) + .map(|(_, number)| (*number, Vec::new())) + .collect(); + let filter = SeccompFilter::new( + rules, + SeccompAction::KillProcess, + SeccompAction::Allow, + target_arch()?, + ) + .map_err(|error| SandboxError::Seccomp(error.to_string()))?; + filter + .try_into() + .map_err(|error: seccompiler::BackendError| SandboxError::Seccomp(error.to_string())) +} + +fn install_seccomp() -> Result<(), SandboxError> { + let program = build_filter()?; + seccompiler::apply_filter_all_threads(&program) + .map_err(|error| SandboxError::Seccomp(error.to_string())) +} + +fn target_arch() -> Result { + if cfg!(target_arch = "x86_64") { + Ok(TargetArch::x86_64) + } else if cfg!(target_arch = "aarch64") { + Ok(TargetArch::aarch64) + } else { + Err(SandboxError::UnsupportedArchitecture) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn thread_count_reads_the_status_line() { + assert_eq!(thread_count("Name:\tx\nThreads:\t1\nSigQ:\t0/1\n"), Some(1)); + assert_eq!(thread_count("Threads:\t12\n"), Some(12)); + assert_eq!(thread_count("Name:\tx\n"), None); + } + + #[test] + fn the_filter_compiles() { + let program = build_filter(); + assert!(program.is_ok()); + } + + #[test] + fn no_file_or_process_syscall_is_allowed() { + let names = allowed_names(); + for forbidden in [ + "open", "openat", "execve", "clone", "fork", "socket", "ptrace", + ] { + assert!(!names.contains(&forbidden), "{forbidden} must stay denied"); + } + } +} diff --git a/crates/worker/src/spawn.rs b/crates/worker/src/spawn.rs new file mode 100644 index 00000000..0aaf52a3 --- /dev/null +++ b/crates/worker/src/spawn.rs @@ -0,0 +1,168 @@ +//! Runs the decode child from the keyed parent (review Part IV.1): empty environment, +//! bounded output, wall-clock deadline, and the mapping of every way the child can end to +//! a closed outcome. The parent reads the container header of the output, never the pixels. + +use std::io::{Read, Write}; +use std::os::unix::process::ExitStatusExt; +use std::path::PathBuf; +use std::process::{Command, ExitStatus, Stdio}; +use std::sync::mpsc; +use std::time::{Duration, Instant}; + +use crate::limits::{CHILD_DEADLINE, MAX_OUTPUT_BYTES, OUTPUT_SIDE}; +use crate::{exit_codes, webp_check}; + +/// How a decode child ended. +#[derive(Debug)] +pub enum ChildOutcome { + /// A 512 × 512 WebP whose container passed the parent's check. + Produced(Vec), + /// The child refused the input with one of its exit codes. + Rejected { code: i32, name: &'static str }, + /// The child died from a signal (SIGSYS 31 = seccomp, SIGABRT 6 = allocation failure, + /// SIGXCPU 24 = CPU limit, SIGKILL 9 = the parent). + Signalled { signal: i32 }, + /// The child wrote more than the output cap and was killed. + OutputOverflow, + /// The child outlived the deadline and was killed. + Timeout, + /// The child exited 0 but its output failed the container check, or it could not run. + Failed(String), +} + +/// A finished child run. +#[derive(Debug)] +pub struct ChildRun { + pub outcome: ChildOutcome, + pub stderr: String, +} + +/// Spawns `decode` children of one worker binary. +#[derive(Debug, Clone)] +pub struct Spawner { + pub exe: PathBuf, + pub deadline: Duration, + pub max_output: usize, + pub extra_args: Vec, +} + +impl Spawner { + pub fn new(exe: impl Into) -> Self { + Self { + exe: exe.into(), + deadline: CHILD_DEADLINE, + max_output: MAX_OUTPUT_BYTES, + extra_args: Vec::new(), + } + } + + /// Feeds `input` to a fresh child and classifies what comes back. + pub fn decode(&self, input: &[u8]) -> ChildRun { + let spawned = Command::new(&self.exe) + .arg("decode") + .args(&self.extra_args) + .env_clear() + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn(); + let mut child = match spawned { + Ok(child) => child, + Err(error) => return failed(format!("spawn: {error}")), + }; + let (Some(mut stdin), Some(stdout), Some(stderr)) = + (child.stdin.take(), child.stdout.take(), child.stderr.take()) + else { + let _ = child.kill(); + let _ = child.wait(); + return failed("child pipes unavailable".to_owned()); + }; + + let input = input.to_vec(); + let writer = std::thread::spawn(move || { + let _ = stdin.write_all(&input); + }); + let cap = self.max_output; + let (tx, rx) = mpsc::channel(); + std::thread::spawn(move || { + let mut buffer = Vec::new(); + let mut limited = stdout.take(cap as u64 + 1); + let _ = limited.read_to_end(&mut buffer); + let _ = tx.send(buffer); + }); + let err_reader = std::thread::spawn(move || { + let mut buffer = Vec::new(); + let _ = stderr.take(4096).read_to_end(&mut buffer); + String::from_utf8_lossy(&buffer).into_owned() + }); + + let started = Instant::now(); + let mut output: Option> = None; + let status: Option = loop { + if output.is_none() + && let Ok(buffer) = rx.try_recv() + { + if buffer.len() > cap { + let _ = child.kill(); + let _ = child.wait(); + let _ = writer.join(); + let stderr = err_reader.join().unwrap_or_default(); + return ChildRun { + outcome: ChildOutcome::OutputOverflow, + stderr, + }; + } + output = Some(buffer); + } + match child.try_wait() { + Ok(Some(status)) => break Some(status), + Ok(None) => { + if started.elapsed() > self.deadline { + let _ = child.kill(); + let _ = child.wait(); + break None; + } + std::thread::sleep(Duration::from_millis(20)); + } + Err(error) => return failed(format!("wait: {error}")), + } + }; + let _ = writer.join(); + let output = output.unwrap_or_else(|| rx.recv().unwrap_or_default()); + let stderr = err_reader.join().unwrap_or_default(); + if output.len() > cap { + return ChildRun { + outcome: ChildOutcome::OutputOverflow, + stderr, + }; + } + let outcome = match status { + None => ChildOutcome::Timeout, + Some(status) => classify(status, output), + }; + ChildRun { outcome, stderr } + } +} + +fn classify(status: ExitStatus, output: Vec) -> ChildOutcome { + match status.code() { + Some(0) => match webp_check::expect_square(&output, OUTPUT_SIDE) { + Ok(_) => ChildOutcome::Produced(output), + Err(issue) => ChildOutcome::Failed(format!("output refused: {issue}")), + }, + Some(code) => ChildOutcome::Rejected { + code, + name: exit_codes::name(code), + }, + None => ChildOutcome::Signalled { + signal: status.signal().unwrap_or(-1), + }, + } +} + +fn failed(detail: String) -> ChildRun { + ChildRun { + outcome: ChildOutcome::Failed(detail), + stderr: String::new(), + } +} diff --git a/crates/worker/src/webp_check.rs b/crates/worker/src/webp_check.rs new file mode 100644 index 00000000..cd0f96c4 --- /dev/null +++ b/crates/worker/src/webp_check.rs @@ -0,0 +1,207 @@ +//! Parent-side check of the child's output (review Part IV.1): the keyed parent never +//! decodes pixels. It parses the RIFF container, allowlists the chunk types, reads the +//! canvas size from the bitstream headers and refuses any metadata chunk. + +use std::fmt; + +/// Why the parent refused the child's output. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum WebpIssue { + TooShort, + NotRiff, + RiffSizeMismatch, + NotWebp, + ChunkOverrun, + ForbiddenChunk([u8; 4]), + MissingBitstream, + BadBitstream, + Dimensions { width: u32, height: u32 }, +} + +impl fmt::Display for WebpIssue { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::ForbiddenChunk(fourcc) => { + write!(f, "forbidden chunk {}", String::from_utf8_lossy(fourcc)) + } + Self::Dimensions { width, height } => write!(f, "unexpected size {width}x{height}"), + other => write!(f, "{other:?}"), + } + } +} + +/// What the parent learnt from the container without decoding a pixel. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct WebpSummary { + pub width: u32, + pub height: u32, + pub chunks: Vec<[u8; 4]>, +} + +const ALLOWED_CHUNKS: [&[u8; 4]; 4] = [b"VP8X", b"VP8 ", b"VP8L", b"ALPH"]; + +/// Parses the container of a WebP file produced by the child. +pub fn inspect(bytes: &[u8]) -> Result { + let header = bytes.get(0..12).ok_or(WebpIssue::TooShort)?; + if &header[0..4] != b"RIFF" { + return Err(WebpIssue::NotRiff); + } + let riff_size = u32::from_le_bytes([header[4], header[5], header[6], header[7]]) as usize; + if riff_size.checked_add(8) != Some(bytes.len()) { + return Err(WebpIssue::RiffSizeMismatch); + } + if &header[8..12] != b"WEBP" { + return Err(WebpIssue::NotWebp); + } + + let mut offset = 12; + let mut chunks = Vec::new(); + let mut dimensions = None; + while offset < bytes.len() { + let chunk_header = bytes + .get(offset..offset + 8) + .ok_or(WebpIssue::ChunkOverrun)?; + let fourcc = [ + chunk_header[0], + chunk_header[1], + chunk_header[2], + chunk_header[3], + ]; + let size = u32::from_le_bytes([ + chunk_header[4], + chunk_header[5], + chunk_header[6], + chunk_header[7], + ]) as usize; + let start = offset + 8; + let end = start.checked_add(size).ok_or(WebpIssue::ChunkOverrun)?; + let payload = bytes.get(start..end).ok_or(WebpIssue::ChunkOverrun)?; + if !ALLOWED_CHUNKS.contains(&&fourcc) { + return Err(WebpIssue::ForbiddenChunk(fourcc)); + } + if dimensions.is_none() { + dimensions = match &fourcc { + b"VP8X" => Some(parse_vp8x(payload)?), + b"VP8 " => Some(parse_vp8(payload)?), + b"VP8L" => Some(parse_vp8l(payload)?), + _ => None, + }; + } + chunks.push(fourcc); + offset = end + (size & 1); + } + let (width, height) = dimensions.ok_or(WebpIssue::MissingBitstream)?; + Ok(WebpSummary { + width, + height, + chunks, + }) +} + +/// `inspect`, then the canvas must be exactly `side` × `side`. +pub fn expect_square(bytes: &[u8], side: u32) -> Result { + let summary = inspect(bytes)?; + if summary.width != side || summary.height != side { + return Err(WebpIssue::Dimensions { + width: summary.width, + height: summary.height, + }); + } + Ok(summary) +} + +fn parse_vp8x(payload: &[u8]) -> Result<(u32, u32), WebpIssue> { + let p = payload.get(0..10).ok_or(WebpIssue::BadBitstream)?; + let width = 1 + u32::from_le_bytes([p[4], p[5], p[6], 0]); + let height = 1 + u32::from_le_bytes([p[7], p[8], p[9], 0]); + Ok((width, height)) +} + +fn parse_vp8(payload: &[u8]) -> Result<(u32, u32), WebpIssue> { + let p = payload.get(0..10).ok_or(WebpIssue::BadBitstream)?; + if p[3..6] != [0x9d, 0x01, 0x2a] { + return Err(WebpIssue::BadBitstream); + } + let width = u32::from(u16::from_le_bytes([p[6], p[7]]) & 0x3fff); + let height = u32::from(u16::from_le_bytes([p[8], p[9]]) & 0x3fff); + Ok((width, height)) +} + +fn parse_vp8l(payload: &[u8]) -> Result<(u32, u32), WebpIssue> { + let p = payload.get(0..5).ok_or(WebpIssue::BadBitstream)?; + if p[0] != 0x2f { + return Err(WebpIssue::BadBitstream); + } + let bits = u32::from_le_bytes([p[1], p[2], p[3], p[4]]); + Ok(((bits & 0x3fff) + 1, ((bits >> 14) & 0x3fff) + 1)) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn riff(chunks: &[(&[u8; 4], &[u8])]) -> Vec { + let mut body = b"WEBP".to_vec(); + for (fourcc, payload) in chunks { + body.extend_from_slice(*fourcc); + body.extend_from_slice(&(payload.len() as u32).to_le_bytes()); + body.extend_from_slice(payload); + if payload.len() % 2 == 1 { + body.push(0); + } + } + let mut out = b"RIFF".to_vec(); + out.extend_from_slice(&(body.len() as u32).to_le_bytes()); + out.extend_from_slice(&body); + out + } + + fn vp8x(width: u32, height: u32) -> Vec { + let w = (width - 1).to_le_bytes(); + let h = (height - 1).to_le_bytes(); + vec![0x10, 0, 0, 0, w[0], w[1], w[2], h[0], h[1], h[2]] + } + + #[test] + fn a_square_vp8x_file_passes() { + let bytes = riff(&[(b"VP8X", &vp8x(512, 512)), (b"VP8 ", &[0; 20])]); + let summary = expect_square(&bytes, 512); + assert_eq!(summary.map(|s| (s.width, s.height)), Ok((512, 512))); + } + + #[test] + fn metadata_chunks_are_refused() { + let bytes = riff(&[(b"VP8X", &vp8x(512, 512)), (b"EXIF", b"x")]); + assert_eq!(inspect(&bytes), Err(WebpIssue::ForbiddenChunk(*b"EXIF"))); + } + + #[test] + fn wrong_sizes_are_refused() { + let bytes = riff(&[(b"VP8X", &vp8x(511, 512)), (b"VP8 ", &[0; 20])]); + assert_eq!( + expect_square(&bytes, 512), + Err(WebpIssue::Dimensions { + width: 511, + height: 512 + }) + ); + let mut truncated = riff(&[(b"VP8X", &vp8x(512, 512))]); + truncated.pop(); + assert_eq!(inspect(&truncated), Err(WebpIssue::RiffSizeMismatch)); + assert_eq!(inspect(b"not a webp"), Err(WebpIssue::TooShort)); + } + + #[test] + fn simple_lossy_and_lossless_headers_give_the_size() { + let mut vp8 = vec![0u8; 10]; + vp8[3..6].copy_from_slice(&[0x9d, 0x01, 0x2a]); + vp8[6..8].copy_from_slice(&512u16.to_le_bytes()); + vp8[8..10].copy_from_slice(&512u16.to_le_bytes()); + assert!(expect_square(&riff(&[(b"VP8 ", &vp8)]), 512).is_ok()); + + let bits: u32 = (512 - 1) | ((512 - 1) << 14); + let mut vp8l = vec![0x2f]; + vp8l.extend_from_slice(&bits.to_le_bytes()); + assert!(expect_square(&riff(&[(b"VP8L", &vp8l)]), 512).is_ok()); + } +} diff --git a/crates/worker/tests/sandbox.rs b/crates/worker/tests/sandbox.rs new file mode 100644 index 00000000..3b0ed8ff --- /dev/null +++ b/crates/worker/tests/sandbox.rs @@ -0,0 +1,174 @@ +//! R0 proofs of the decode child, run against the real binary (`--features test-hooks`, +//! Linux): the full sandbox accepts the fixture corpus, refuses what it must, and every +//! other way the child can die is observed and classified by the parent. +#![cfg(all(feature = "test-hooks", target_os = "linux"))] +#![allow(clippy::unwrap_used, clippy::expect_used)] + +use std::process::{Command, Stdio}; +use std::time::Duration; + +use faunosteo_worker::spawn::{ChildOutcome, Spawner}; +use faunosteo_worker::{exit_codes, fixtures, limits, webp_check}; + +const SIGABRT: i32 = 6; +const SIGXCPU: i32 = 24; +const SIGSYS: i32 = 31; + +fn spawner() -> Spawner { + Spawner::new(env!("CARGO_BIN_EXE_faunosteo-worker")) +} + +fn with_hook(flags: &[&str]) -> Spawner { + let mut spawner = spawner(); + spawner.extra_args = flags.iter().map(|flag| (*flag).to_owned()).collect(); + spawner +} + +fn expect_rejected(bytes: &[u8], code: i32) { + let run = spawner().decode(bytes); + match run.outcome { + ChildOutcome::Rejected { code: got, .. } if got == code => {} + other => panic!( + "expected {}, got {other:?} (stderr: {})", + exit_codes::name(code), + run.stderr + ), + } +} + +#[test] +fn png_jpeg_and_webp_decode_through_the_full_sandbox() { + for (name, bytes) in [ + ("png", fixtures::png(800, 600)), + ("jpeg", fixtures::jpeg(640, 480)), + ("webp", fixtures::webp(300, 700)), + ] { + let run = spawner().decode(&bytes); + match run.outcome { + ChildOutcome::Produced(out) => { + let summary = webp_check::inspect(&out).unwrap(); + assert_eq!((summary.width, summary.height), (512, 512), "{name}"); + assert!( + out.len() < limits::MAX_OUTPUT_BYTES, + "{name}: {} bytes", + out.len() + ); + } + other => panic!("{name}: {other:?} (stderr: {})", run.stderr), + } + } +} + +#[test] +fn inputs_at_the_caps_decode_within_the_limits() { + let big = fixtures::jpeg(4096, 4096); + let run = spawner().decode(&big); + assert!( + matches!(run.outcome, ChildOutcome::Produced(_)), + "{:?} {}", + run.outcome, + run.stderr + ); +} + +#[test] +fn too_small_images_are_refused_on_dimensions() { + expect_rejected(&fixtures::png(32, 32), exit_codes::DIMENSIONS); +} + +#[test] +fn oversized_headers_are_refused_before_decoding() { + expect_rejected( + &fixtures::png_header_only(20_000, 20_000), + exit_codes::DIMENSIONS, + ); +} + +#[test] +fn unsupported_formats_are_refused() { + expect_rejected(&fixtures::gif(), exit_codes::UNSUPPORTED_TYPE); + expect_rejected( + b"", + exit_codes::UNSUPPORTED_TYPE, + ); +} + +#[test] +fn truncated_files_are_decode_failures() { + expect_rejected(&fixtures::truncated_png(), exit_codes::DECODE_FAILED); +} + +#[test] +fn the_child_refuses_a_non_empty_environment() { + let status = Command::new(env!("CARGO_BIN_EXE_faunosteo-worker")) + .arg("decode") + .env_clear() + .env("LEAKED", "1") + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .status() + .unwrap(); + assert_eq!(status.code(), Some(exit_codes::ENV_NOT_EMPTY)); +} + +#[test] +fn a_denied_syscall_kills_the_child_with_sigsys() { + let run = with_hook(&["--violate"]).decode(b""); + assert!( + matches!(run.outcome, ChildOutcome::Signalled { signal: SIGSYS }), + "{:?} {}", + run.outcome, + run.stderr + ); +} + +#[test] +fn an_output_flood_is_cut_at_the_cap() { + let run = with_hook(&["--flood"]).decode(b""); + assert!( + matches!(run.outcome, ChildOutcome::OutputOverflow), + "{:?}", + run.outcome + ); +} + +#[test] +fn the_address_space_limit_aborts_a_huge_allocation() { + let run = with_hook(&["--alloc-gib", "2"]).decode(b""); + assert!( + matches!(run.outcome, ChildOutcome::Signalled { signal: SIGABRT }), + "{:?} {}", + run.outcome, + run.stderr + ); +} + +#[test] +fn the_deadline_kills_a_spinning_child() { + let mut spawner = with_hook(&["--spin"]); + spawner.deadline = Duration::from_secs(2); + let run = spawner.decode(b""); + assert!( + matches!(run.outcome, ChildOutcome::Timeout), + "{:?}", + run.outcome + ); +} + +#[test] +fn the_cpu_limit_stops_a_spinning_child_before_the_deadline() { + let mut spawner = with_hook(&["--spin"]); + spawner.deadline = Duration::from_secs(limits::CHILD_CPU_SECONDS + 10); + let run = spawner.decode(b""); + assert!( + matches!(run.outcome, ChildOutcome::Signalled { signal: SIGXCPU }), + "{:?}", + run.outcome + ); +} + +#[test] +fn the_linked_libwebp_is_recent_enough() { + assert!(faunosteo_worker::decode::libwebp_version() >= limits::MIN_LIBWEBP_VERSION); +}