feat(worker): V1-2.3 sandboxed verify child and sheet-verify job mode
This commit is contained in:
1 parent
345dde59e6
commit
31fbb0317f
24 files changed
+2145
-87
No files matched your search
@@ -0,0 +1,321 @@
|
||||
//! The framed stdin input of the `verify` child (V1-2.3), written by the parent and read by
|
||||
//! the child: `[u32 LE header length][header JSON][document][base?][drawing bytes in header
|
||||
//! order]`. The parent frames bytes it never parses (document, base, drawings); the child
|
||||
//! reads them as borrowed slices.
|
||||
|
||||
use std::fmt;
|
||||
|
||||
use faunosteo_core::domain::sheet::verdict::{VerdictBinding, VerdictDrawing, VerdictInput};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::limits::VERIFY_MAX_HEADER_BYTES;
|
||||
|
||||
/// The header: the round, the lengths of the parts that follow, the drawing rows.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct FrameHeader {
|
||||
pub sheet_id: String,
|
||||
pub version_id: String,
|
||||
pub revision: u32,
|
||||
pub review_id: String,
|
||||
pub document_len: usize,
|
||||
pub base_len: Option<usize>,
|
||||
pub drawings: Vec<FrameDrawing>,
|
||||
}
|
||||
|
||||
/// One drawing row; `bytes_len` is absent when the parent passes the row without bytes.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct FrameDrawing {
|
||||
pub asset_id: String,
|
||||
pub sha256: String,
|
||||
pub byte_size: u64,
|
||||
pub bytes_len: Option<usize>,
|
||||
}
|
||||
|
||||
/// A decoded frame, borrowing the input buffer.
|
||||
#[derive(Debug)]
|
||||
pub struct Frame<'a> {
|
||||
pub header: FrameHeader,
|
||||
pub document: &'a str,
|
||||
pub base: Option<&'a str>,
|
||||
/// One entry per header drawing, in header order.
|
||||
pub drawing_bytes: Vec<Option<&'a [u8]>>,
|
||||
}
|
||||
|
||||
/// Why a frame could not be built or read (closed: the child's stderr names it).
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum FrameError {
|
||||
Truncated,
|
||||
HeaderTooLarge,
|
||||
HeaderInvalid,
|
||||
LengthMismatch,
|
||||
NotUtf8,
|
||||
}
|
||||
|
||||
impl fmt::Display for FrameError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let text = match self {
|
||||
Self::Truncated => "frame shorter than its header",
|
||||
Self::HeaderTooLarge => "header over its cap",
|
||||
Self::HeaderInvalid => "header is not the expected JSON",
|
||||
Self::LengthMismatch => "part lengths do not sum to the frame",
|
||||
Self::NotUtf8 => "document or base is not UTF-8",
|
||||
};
|
||||
f.write_str(text)
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for FrameError {}
|
||||
|
||||
/// Frames a verification input (the parent side).
|
||||
pub fn encode(input: &VerdictInput<'_>) -> Result<Vec<u8>, FrameError> {
|
||||
let header = header_of(input);
|
||||
let header_json = serde_json::to_vec(&header).map_err(|_| FrameError::HeaderInvalid)?;
|
||||
if header_json.len() > VERIFY_MAX_HEADER_BYTES {
|
||||
return Err(FrameError::HeaderTooLarge);
|
||||
}
|
||||
let header_len = u32::try_from(header_json.len()).map_err(|_| FrameError::HeaderTooLarge)?;
|
||||
let body = checked_body_len(&header).unwrap_or(0);
|
||||
let mut out = Vec::with_capacity(4 + header_json.len() + body);
|
||||
out.extend_from_slice(&header_len.to_le_bytes());
|
||||
out.extend_from_slice(&header_json);
|
||||
out.extend_from_slice(input.document.as_bytes());
|
||||
if let Some(base) = input.base_document {
|
||||
out.extend_from_slice(base.as_bytes());
|
||||
}
|
||||
for bytes in input.drawings.iter().filter_map(|d| d.bytes) {
|
||||
out.extend_from_slice(bytes);
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn header_of(input: &VerdictInput<'_>) -> FrameHeader {
|
||||
FrameHeader {
|
||||
sheet_id: input.binding.sheet_id.clone(),
|
||||
version_id: input.binding.version_id.clone(),
|
||||
revision: input.binding.revision,
|
||||
review_id: input.binding.review_id.clone(),
|
||||
document_len: input.document.len(),
|
||||
base_len: input.base_document.map(str::len),
|
||||
drawings: input
|
||||
.drawings
|
||||
.iter()
|
||||
.map(|d| FrameDrawing {
|
||||
asset_id: d.asset_id.to_owned(),
|
||||
sha256: d.sha256.to_owned(),
|
||||
byte_size: d.byte_size,
|
||||
bytes_len: d.bytes.map(<[u8]>::len),
|
||||
})
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Total length of the parts after the header; `None` on overflow.
|
||||
fn checked_body_len(header: &FrameHeader) -> Option<usize> {
|
||||
header
|
||||
.drawings
|
||||
.iter()
|
||||
.filter_map(|d| d.bytes_len)
|
||||
.try_fold(header.document_len, usize::checked_add)?
|
||||
.checked_add(header.base_len.unwrap_or(0))
|
||||
}
|
||||
|
||||
/// Reads a frame (the child side): every length must be exact, nothing may trail.
|
||||
pub fn decode(bytes: &[u8]) -> Result<Frame<'_>, FrameError> {
|
||||
let (prefix, rest) = bytes.split_at_checked(4).ok_or(FrameError::Truncated)?;
|
||||
let mut length = [0u8; 4];
|
||||
length.copy_from_slice(prefix);
|
||||
let header_len =
|
||||
usize::try_from(u32::from_le_bytes(length)).map_err(|_| FrameError::HeaderTooLarge)?;
|
||||
if header_len > VERIFY_MAX_HEADER_BYTES {
|
||||
return Err(FrameError::HeaderTooLarge);
|
||||
}
|
||||
let (header_json, mut body) = rest
|
||||
.split_at_checked(header_len)
|
||||
.ok_or(FrameError::Truncated)?;
|
||||
let header: FrameHeader =
|
||||
serde_json::from_slice(header_json).map_err(|_| FrameError::HeaderInvalid)?;
|
||||
if checked_body_len(&header) != Some(body.len()) {
|
||||
return Err(FrameError::LengthMismatch);
|
||||
}
|
||||
let document = take_text(&mut body, header.document_len)?;
|
||||
let base = header
|
||||
.base_len
|
||||
.map(|len| take_text(&mut body, len))
|
||||
.transpose()?;
|
||||
let drawing_bytes = header
|
||||
.drawings
|
||||
.iter()
|
||||
.map(|d| d.bytes_len.map(|len| take(&mut body, len)))
|
||||
.collect();
|
||||
Ok(Frame {
|
||||
header,
|
||||
document,
|
||||
base,
|
||||
drawing_bytes,
|
||||
})
|
||||
}
|
||||
|
||||
/// Splits `len` bytes off the front; the lengths were checked against the body beforehand.
|
||||
fn take<'a>(body: &mut &'a [u8], len: usize) -> &'a [u8] {
|
||||
let (head, tail) = body.split_at(len.min(body.len()));
|
||||
*body = tail;
|
||||
head
|
||||
}
|
||||
|
||||
fn take_text<'a>(body: &mut &'a [u8], len: usize) -> Result<&'a str, FrameError> {
|
||||
std::str::from_utf8(take(body, len)).map_err(|_| FrameError::NotUtf8)
|
||||
}
|
||||
|
||||
impl Frame<'_> {
|
||||
/// The core's input, borrowing the frame.
|
||||
pub fn input(&self) -> VerdictInput<'_> {
|
||||
VerdictInput {
|
||||
binding: VerdictBinding {
|
||||
sheet_id: self.header.sheet_id.clone(),
|
||||
version_id: self.header.version_id.clone(),
|
||||
revision: self.header.revision,
|
||||
review_id: self.header.review_id.clone(),
|
||||
},
|
||||
document: self.document,
|
||||
base_document: self.base,
|
||||
drawings: self
|
||||
.header
|
||||
.drawings
|
||||
.iter()
|
||||
.zip(&self.drawing_bytes)
|
||||
.map(|(row, bytes)| VerdictDrawing {
|
||||
asset_id: &row.asset_id,
|
||||
sha256: &row.sha256,
|
||||
byte_size: row.byte_size,
|
||||
bytes: *bytes,
|
||||
})
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#![allow(clippy::unwrap_used)]
|
||||
use super::*;
|
||||
|
||||
fn binding() -> VerdictBinding {
|
||||
VerdictBinding {
|
||||
sheet_id: "s".to_owned(),
|
||||
version_id: "v".to_owned(),
|
||||
revision: 3,
|
||||
review_id: "r".to_owned(),
|
||||
}
|
||||
}
|
||||
|
||||
fn input<'a>(base: Option<&'a str>, drawings: Vec<VerdictDrawing<'a>>) -> VerdictInput<'a> {
|
||||
VerdictInput {
|
||||
binding: binding(),
|
||||
document: "{\"d\":\"é\"}",
|
||||
base_document: base,
|
||||
drawings,
|
||||
}
|
||||
}
|
||||
|
||||
fn drawing(bytes: Option<&[u8]>) -> VerdictDrawing<'_> {
|
||||
VerdictDrawing {
|
||||
asset_id: "a",
|
||||
sha256: "h",
|
||||
byte_size: 3,
|
||||
bytes,
|
||||
}
|
||||
}
|
||||
|
||||
/// Rewrites the header of a valid frame with `edit`, keeping its body.
|
||||
fn with_header(frame: &[u8], edit: impl Fn(&mut serde_json::Value)) -> Vec<u8> {
|
||||
let len = u32::from_le_bytes(frame[..4].try_into().unwrap()) as usize;
|
||||
let mut header: serde_json::Value = serde_json::from_slice(&frame[4..4 + len]).unwrap();
|
||||
edit(&mut header);
|
||||
let json = serde_json::to_vec(&header).unwrap();
|
||||
let mut out = (json.len() as u32).to_le_bytes().to_vec();
|
||||
out.extend_from_slice(&json);
|
||||
out.extend_from_slice(&frame[4 + len..]);
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_frame_round_trips() {
|
||||
let original = input(
|
||||
Some("{}"),
|
||||
vec![drawing(Some(b"abc")), drawing(None), drawing(Some(b"xyz"))],
|
||||
);
|
||||
let bytes = encode(&original).unwrap();
|
||||
let frame = decode(&bytes).unwrap();
|
||||
assert_eq!(frame.document, original.document);
|
||||
assert_eq!(frame.base, Some("{}"));
|
||||
assert_eq!(
|
||||
frame.drawing_bytes,
|
||||
vec![Some(&b"abc"[..]), None, Some(&b"xyz"[..])]
|
||||
);
|
||||
let read = frame.input();
|
||||
assert_eq!(read.binding, original.binding);
|
||||
assert_eq!(read.drawings.len(), 3);
|
||||
assert_eq!(read.drawings[1].bytes, None);
|
||||
assert_eq!(read.drawings[2].byte_size, 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_absent_and_an_empty_base_differ() {
|
||||
let none = encode(&input(None, vec![])).unwrap();
|
||||
assert_eq!(decode(&none).unwrap().base, None);
|
||||
let empty = encode(&input(Some(""), vec![])).unwrap();
|
||||
assert_eq!(decode(&empty).unwrap().base, Some(""));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_frames_are_refused() {
|
||||
let good = encode(&input(Some("{}"), vec![drawing(Some(b"abc"))])).unwrap();
|
||||
assert_eq!(decode(&good[..3]).err(), Some(FrameError::Truncated));
|
||||
assert_eq!(decode(&good[..10]).err(), Some(FrameError::Truncated));
|
||||
assert_eq!(
|
||||
decode(&good[..good.len() - 1]).err(),
|
||||
Some(FrameError::LengthMismatch)
|
||||
);
|
||||
let mut trailing = good.clone();
|
||||
trailing.push(0);
|
||||
assert_eq!(decode(&trailing).err(), Some(FrameError::LengthMismatch));
|
||||
let mut huge = ((VERIFY_MAX_HEADER_BYTES + 1) as u32)
|
||||
.to_le_bytes()
|
||||
.to_vec();
|
||||
huge.extend(vec![b' '; VERIFY_MAX_HEADER_BYTES + 1]);
|
||||
assert_eq!(decode(&huge).err(), Some(FrameError::HeaderTooLarge));
|
||||
let mut not_json = 3u32.to_le_bytes().to_vec();
|
||||
not_json.extend_from_slice(b"{x}");
|
||||
assert_eq!(decode(¬_json).err(), Some(FrameError::HeaderInvalid));
|
||||
let unknown = with_header(&good, |h| h["extra"] = 1.into());
|
||||
assert_eq!(decode(&unknown).err(), Some(FrameError::HeaderInvalid));
|
||||
let overflow = with_header(&good, |h| h["document_len"] = usize::MAX.into());
|
||||
assert_eq!(decode(&overflow).err(), Some(FrameError::LengthMismatch));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_document_or_base_that_is_not_utf8_is_refused() {
|
||||
let good = encode(&input(Some("ab"), vec![])).unwrap();
|
||||
let mut bad_base = good.clone();
|
||||
let last = bad_base.len() - 1;
|
||||
bad_base[last] = 0xff;
|
||||
assert_eq!(decode(&bad_base).err(), Some(FrameError::NotUtf8));
|
||||
let mut bad_document = good;
|
||||
let len = u32::from_le_bytes(bad_document[..4].try_into().unwrap()) as usize;
|
||||
bad_document[4 + len] = 0xc3;
|
||||
assert_eq!(decode(&bad_document).err(), Some(FrameError::NotUtf8));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_drawing_bytes_are_a_length_mismatch() {
|
||||
let good = encode(&input(None, vec![drawing(Some(b"abc"))])).unwrap();
|
||||
let missing = &good[..good.len() - 3];
|
||||
assert_eq!(decode(missing).err(), Some(FrameError::LengthMismatch));
|
||||
let without = with_header(&good[..good.len() - 3], |h| {
|
||||
h["drawings"][0]["bytes_len"] = serde_json::Value::Null;
|
||||
});
|
||||
assert_eq!(decode(&without).unwrap().drawing_bytes, vec![None]);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user