Files
faunosteo/crates/worker/src/decode.rs
T
bchanot e967ce6736 test(worker): verify child at the input caps, brk bounded by the limits
Max frame (document and base 2 MiB, drawings 6 MiB) passes through the full
sandbox; refusals just beyond give caps verdicts; RLIMIT_AS and the argument
filters still stop the verify child; seccomp traced on the max input; the two
tracked misclassifications asserted as current behaviour.
2026-11-01 21:07:23 +01:00

394 lines
16 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 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,
/// A decoder budget (`image::Limits`, allocation, complexity) exceeded by the content.
ResourceLimit,
/// libwebp failed on the buffer the child produced itself: an environment fault.
EncodeFailed,
/// A programming or I/O fault of the child, never a judgement on the content.
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::ResourceLimit => exit_codes::RESOURCE_LIMIT,
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)
}
/// Every decode-time error is a judgement on the content (a content code): an uploader must
/// never be able to produce a "broken environment" outcome (security audit of R0).
fn map_image_error(error: ImageError) -> Reject {
match error {
ImageError::Limits(limit) => match limit.kind() {
LimitErrorKind::DimensionError => Reject::Dimensions,
_ => Reject::ResourceLimit,
},
ImageError::Unsupported(_) => Reject::UnsupportedType,
_ => Reject::DecodeFailed,
}
}
/// Encodes an RGBA buffer as lossy WebP through libwebp (D-R4: C confined to this process).
#[allow(unsafe_code)]
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 Some(stride_bytes) = width.checked_mul(4) else {
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(stride_bytes),
) else {
return Err(Reject::Internal);
};
let mut output: *mut u8 = std::ptr::null_mut();
// SAFETY: WebPEncodeRGBA reads `height` rows of `stride` bytes starting at `rgba`;
// `rgba.len() == width * height * 4` and `stride == width * 4` are established above with
// overflow-checked arithmetic, so every read stays inside the slice, which outlives the
// call. `&mut output` is a valid `*mut *mut u8` for the duration of the call: libwebp
// stores the address of a buffer it allocated there, or leaves it null and returns 0.
// libwebp retains no pointer once the call returns.
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: a non-zero return means libwebp initialised exactly `size` bytes at `output`
// (both non-zero and non-null, checked just above). The slice lives only for the copy
// below and is dropped before the buffer is released.
let encoded = unsafe { std::slice::from_raw_parts(output, size) }.to_vec();
// SAFETY: `output` was allocated by libwebp for this call and must be released by its
// own WebPFree; this is the single release and the pointer is not used afterwards.
unsafe { libwebp_sys::WebPFree(output.cast()) };
Ok(encoded)
}
/// Version of the libwebp linked into this binary, as (major, minor, revision).
#[allow(unsafe_code)]
pub fn libwebp_version() -> (u8, u8, u8) {
// SAFETY: WebPGetEncoderVersion takes no argument, touches no memory owned by the caller
// and has no side effect: it returns the version packed into a C int.
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),
/// Grows the heap by the given GiB in 4 KiB chunks kept alive (the small-allocation path,
/// where musl extends the heap with `brk`): `RLIMIT_AS` must abort the child as well.
AllocSmallGib(usize),
/// Burns CPU forever: `RLIMIT_CPU` (SIGXCPU) or the parent's deadline must stop it.
Spin,
/// Sends SIGTERM to the parent through `tkill`: the argument filter must kill the child.
SignalParent,
/// Maps executable memory: the `mmap` argument filter must kill the child.
MmapExec,
}
impl TestHooks {
/// Shared with the `verify` child, which takes the same flags.
pub(crate) 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),
"--signal-parent" => hooks.action = Some(HookAction::SignalParent),
"--mmap-exec" => hooks.action = Some(HookAction::MmapExec),
"--alloc-gib" => {
let value = iter
.next()
.and_then(|v| v.parse().ok())
.ok_or("--alloc-gib <n>")?;
hooks.action = Some(HookAction::AllocGib(value));
}
"--alloc-small-gib" => {
let value = iter
.next()
.and_then(|v| v.parse().ok())
.ok_or("--alloc-small-gib <n>")?;
hooks.action = Some(HookAction::AllocSmallGib(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")]
pub(crate) 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: one `sched_yield`, a syscall
// the decode path never makes, right where the filter would be installed. The
// syscalls after it are the ones the filter must allow. (A string marker is not
// readable by strace once PR_SET_DUMPABLE is 0.)
std::thread::yield_now();
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::AllocSmallGib(gib) => {
let chunks = gib.saturating_mul(1024 * 1024 * 1024) / 4096;
let kept: Vec<Vec<u8>> = (0..chunks).map(|_| vec![1u8; 4096]).collect();
let _ = writeln!(
stderr,
"decode: kept {} chunks",
std::hint::black_box(&kept).len()
);
Some(exit_codes::INTERNAL)
}
HookAction::Spin => loop {
std::hint::black_box(0u8);
},
HookAction::SignalParent => {
let survived = negative_hooks::signal_parent();
let _ = writeln!(
stderr,
"decode: tkill(parent) survived the filter: {survived}"
);
Some(exit_codes::INTERNAL)
}
HookAction::MmapExec => {
let survived = negative_hooks::mmap_exec();
let _ = writeln!(
stderr,
"decode: mmap(PROT_EXEC) survived the filter: {survived}"
);
Some(exit_codes::INTERNAL)
}
}
}
#[cfg(not(feature = "test-hooks"))]
pub(crate) fn run_after_sandbox(
&self,
_stdout: &mut dyn Write,
_stderr: &mut dyn Write,
) -> Option<i32> {
None
}
}
/// Negative proofs of the seccomp argument filters (`test-hooks` only): each call must die
/// with SIGSYS before returning; a return value means the filter let it through.
#[cfg(feature = "test-hooks")]
#[allow(unsafe_code)]
mod negative_hooks {
/// `tkill(getppid(), SIGTERM)`: a signal to another process.
pub fn signal_parent() -> i32 {
// SAFETY: a raw syscall with three integer arguments and no pointer: the kernel
// validates them, so the call cannot touch this process's memory. What the proof
// checks is behaviour: under the filter the process dies with SIGSYS before any
// signal exists; without the filter the parent would receive SIGTERM, which is why
// this module is compiled with the test hooks only and reached by `--signal-parent`.
unsafe { libc::syscall(libc::SYS_tkill, libc::getppid(), libc::SIGTERM) as i32 }
}
/// `mmap` of one executable page.
pub fn mmap_exec() -> i32 {
// SAFETY: an anonymous private mapping with a null address hint and no file
// descriptor: no existing mapping is touched, and the returned address is only
// compared with MAP_FAILED, never dereferenced. Under the filter the process dies
// with SIGSYS before the mapping exists; without it one page leaks in a test process.
let page = unsafe {
libc::mmap(
std::ptr::null_mut(),
4096,
libc::PROT_READ | libc::PROT_EXEC,
libc::MAP_PRIVATE | libc::MAP_ANONYMOUS,
-1,
0,
)
};
i32::from(page != libc::MAP_FAILED)
}
}
/// 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))
}