feat(worker): sandboxed decode child skeleton — rlimits, traced seccomp allowlist, pure-Rust decoders, libwebp in the child, parent RIFF check, musl image with test stage
This commit is contained in:
1 parent
2a38fa37b5
commit
3970cdca52
13 files changed
+1435
No files matched your search
@@ -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"
|
||||||
@@ -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"]
|
||||||
Executable
+41
@@ -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"
|
||||||
@@ -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<Vec<u8>, 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<Vec<u8>, 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<HookAction>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[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<Self, String> {
|
||||||
|
#[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 <n>")?;
|
||||||
|
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<i32> {
|
||||||
|
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<i32> {
|
||||||
|
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<u8>, 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))
|
||||||
|
}
|
||||||
@@ -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",
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -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<u8> {
|
||||||
|
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<u8> {
|
||||||
|
encode(&gradient(width, height), ImageFormat::Png)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A baseline JPEG gradient (no alpha channel).
|
||||||
|
pub fn jpeg(width: u32, height: u32) -> Vec<u8> {
|
||||||
|
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<u8> {
|
||||||
|
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<u8> {
|
||||||
|
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<u8>, 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<u8> {
|
||||||
|
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<u8> {
|
||||||
|
let mut bytes = png(200, 200);
|
||||||
|
bytes.truncate(bytes.len() / 2);
|
||||||
|
bytes
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Writes one named fixture on stdout (`faunosteo-worker fixture <name>`).
|
||||||
|
pub fn by_name(name: &str) -> Option<Vec<u8>> {
|
||||||
|
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,
|
||||||
|
})
|
||||||
|
}
|
||||||
@@ -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;
|
||||||
@@ -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);
|
||||||
@@ -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<String> = 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 <decode | run --check | version>");
|
||||||
|
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 <png|jpeg|webp|big-jpeg|big-png|tiny|huge-header|gif|truncated>"
|
||||||
|
);
|
||||||
|
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
|
||||||
|
}
|
||||||
@@ -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/<pid>/status` text.
|
||||||
|
pub fn thread_count(status: &str) -> Option<usize> {
|
||||||
|
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<BpfProgram, SandboxError> {
|
||||||
|
let rules: BTreeMap<i64, Vec<SeccompRule>> = 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<TargetArch, SandboxError> {
|
||||||
|
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");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -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<u8>),
|
||||||
|
/// 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<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Spawner {
|
||||||
|
pub fn new(exe: impl Into<PathBuf>) -> 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<Vec<u8>> = None;
|
||||||
|
let status: Option<ExitStatus> = 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<u8>) -> 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(),
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -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<WebpSummary, WebpIssue> {
|
||||||
|
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<WebpSummary, WebpIssue> {
|
||||||
|
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<u8> {
|
||||||
|
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<u8> {
|
||||||
|
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());
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -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"<svg xmlns='http://www.w3.org/2000/svg'/>",
|
||||||
|
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);
|
||||||
|
}
|
||||||
Reference in new issue
Block a user