feat(worker): V1-2.3 sandboxed verify child and sheet-verify job mode

This commit is contained in:
bchanot committed 2026-11-01 17:20:07 +01:00
1 parent 345dde59e6
commit 31fbb0317f
24 files changed
+2145 -87

No files matched your search

+145 -14
View File
@@ -1,6 +1,8 @@
//! `Backend` over PostgREST and the Storage API with the service key (STORAGE.md §3.3).
//! Thin by design: key shapes are checked before any URL is built, every status is
//! classified here, and the closed `P0001` refusals of the RPCs come back as `Refused`.
//! The same client serves `VerifyBackend` (V1-2.3): larger caps for the round's input and
//! the verdict, drawing keys checked before any URL is built.
use std::time::Duration;
@@ -9,13 +11,19 @@ use serde_json::{Value, json};
use ureq::Agent;
use ureq::http::Response;
use crate::backend::{Backend, BackendError, BackendResult, Job, Leftover, Purge};
use crate::backend::{
Backend, BackendError, BackendResult, CompleteAnswer, FailAnswer, Job, Leftover, Purge,
VerifyBackend, VerifyInput, VerifyJob,
};
use crate::config::Config;
use crate::keys;
use crate::limits::MAX_INPUT_BYTES;
/// Largest RPC response the worker reads (a claim of 100 rows is a few KiB).
const MAX_RPC_BODY: u64 = 1024 * 1024;
/// Largest `get_sheet_verification_input` response: two 2 MiB documents, whose JSON string
/// escaping can double them, and the drawing rows.
const MAX_INPUT_RPC_BODY: u64 = 16 * 1024 * 1024;
pub struct HttpBackend {
agent: Agent,
@@ -52,8 +60,22 @@ impl HttpBackend {
Ok(format!("{}/storage/v1/object/{bucket}/{key}", self.base))
}
/// A sheet drawing: `<sha256>.svg` in a well-formed bucket, nothing else.
fn drawing_url(&self, bucket: &str, key: &str) -> BackendResult<String> {
validate_bucket(bucket)?;
if !keys::is_drawing_key(key) {
return Err(BackendError::Internal("drawing key refused".to_owned()));
}
Ok(format!("{}/storage/v1/object/{bucket}/{key}", self.base))
}
/// Calls an RPC and returns the response body text of a 2xx.
fn rpc(&self, name: &str, body: &Value) -> BackendResult<String> {
self.rpc_capped(name, body, MAX_RPC_BODY)
}
/// `rpc` with its own response cap.
fn rpc_capped(&self, name: &str, body: &Value, cap: u64) -> BackendResult<String> {
let mut response = self
.agent
.post(&self.rpc_url(name))
@@ -63,7 +85,7 @@ impl HttpBackend {
.send_json(body)
.map_err(network)?;
let status = response.status().as_u16();
let text = read_text(&mut response)?;
let text = read_text_capped(&mut response, cap)?;
if (200..300).contains(&status) {
Ok(text)
} else {
@@ -79,18 +101,12 @@ impl HttpBackend {
fn rpc_void(&self, name: &str, body: &Value) -> BackendResult<()> {
self.rpc(name, body).map(|_| ())
}
}
impl Backend for HttpBackend {
fn claim_jobs(&self, max_jobs: u32) -> BackendResult<Vec<Job>> {
self.rpc_json("claim_avatar_jobs", &json!({ "max_jobs": max_jobs }))
}
fn download_quarantine(&self, bucket: &str, key: &str) -> BackendResult<Vec<u8>> {
let url = self.object_url(bucket, key)?;
/// GET of an object, read up to `cap` bytes (`Overflow` past it).
fn get_object(&self, url: &str, cap: usize) -> BackendResult<Vec<u8>> {
let mut response = self
.agent
.get(&url)
.get(url)
.header("apikey", &self.key)
.header("Authorization", &format!("Bearer {}", self.key))
.call()
@@ -103,14 +119,25 @@ impl Backend for HttpBackend {
let bytes = response
.body_mut()
.with_config()
.limit(MAX_INPUT_BYTES as u64 + 1)
.limit(cap as u64 + 1)
.read_to_vec()
.map_err(|e| BackendError::Network(e.to_string()))?;
if bytes.len() > MAX_INPUT_BYTES {
if bytes.len() > cap {
return Err(BackendError::Overflow);
}
Ok(bytes)
}
}
impl Backend for HttpBackend {
fn claim_jobs(&self, max_jobs: u32) -> BackendResult<Vec<Job>> {
self.rpc_json("claim_avatar_jobs", &json!({ "max_jobs": max_jobs }))
}
fn download_quarantine(&self, bucket: &str, key: &str) -> BackendResult<Vec<u8>> {
let url = self.object_url(bucket, key)?;
self.get_object(&url, MAX_INPUT_BYTES)
}
fn put_clean(&self, bucket: &str, key: &str, bytes: &[u8]) -> BackendResult<()> {
let url = self.object_url(bucket, key)?;
@@ -194,6 +221,65 @@ impl Backend for HttpBackend {
}
}
impl VerifyBackend for HttpBackend {
fn claim_verifications(&self, max_jobs: u32) -> BackendResult<Vec<VerifyJob>> {
self.rpc_json(
"claim_sheet_verifications",
&json!({ "max_jobs": max_jobs }),
)
}
fn verification_input(
&self,
review_id: &str,
lease_token: &str,
) -> BackendResult<Option<VerifyInput>> {
let text = self.rpc_capped(
"get_sheet_verification_input",
&json!({ "review_id": review_id, "lease_token": lease_token }),
MAX_INPUT_RPC_BODY,
)?;
serde_json::from_str(&text).map_err(|e| BackendError::Decode(e.to_string()))
}
fn download_drawing(
&self,
bucket: &str,
key: &str,
max_bytes: usize,
) -> BackendResult<Vec<u8>> {
let url = self.drawing_url(bucket, key)?;
self.get_object(&url, max_bytes)
}
fn complete_verification(
&self,
review_id: &str,
lease_token: &str,
verdict: &[u8],
) -> BackendResult<CompleteAnswer> {
// The spawner already checked the bytes are a JSON object (under the output cap).
let verdict: Value =
serde_json::from_slice(verdict).map_err(|e| BackendError::Internal(e.to_string()))?;
self.rpc_json(
"complete_sheet_verification",
&json!({ "review_id": review_id, "lease_token": lease_token, "verdict": verdict }),
)
}
fn fail_verification(
&self,
review_id: &str,
lease_token: &str,
code: &str,
) -> BackendResult<FailAnswer> {
self.rpc_json(
"fail_sheet_verification",
&json!({ "review_id": review_id, "lease_token": lease_token, "code": code }),
)
}
}
fn validate_bucket(bucket: &str) -> BackendResult<()> {
let ok = !bucket.is_empty()
&& bucket
@@ -211,10 +297,14 @@ fn network(error: ureq::Error) -> BackendError {
}
fn read_text(response: &mut Response<ureq::Body>) -> BackendResult<String> {
read_text_capped(response, MAX_RPC_BODY)
}
fn read_text_capped(response: &mut Response<ureq::Body>, cap: u64) -> BackendResult<String> {
response
.body_mut()
.with_config()
.limit(MAX_RPC_BODY)
.limit(cap)
.read_to_string()
.map_err(|e| BackendError::Network(e.to_string()))
}
@@ -295,6 +385,36 @@ mod tests {
);
}
#[test]
fn the_m6_answers_and_rows_deserialize() {
assert_eq!(
serde_json::from_str::<CompleteAnswer>("\"malformed\"").ok(),
Some(CompleteAnswer::Malformed)
);
assert_eq!(
serde_json::from_str::<FailAnswer>("\"retry\"").ok(),
Some(FailAnswer::Retry)
);
assert!(serde_json::from_str::<CompleteAnswer>("\"other\"").is_err());
assert_eq!(
serde_json::from_str::<Option<VerifyInput>>("null").ok(),
Some(None)
);
let input = serde_json::from_value::<Option<VerifyInput>>(json!({
"review_id": "r", "version_id": "v", "sheet_id": "s", "revision": 2,
"document": "{}", "base_document": null,
"drawings": [{ "asset_id": "a", "sha256": "h", "byte_size": 10,
"bucket": "anatomical-sheet-assets", "object_key": "h.svg", "uploaded": true }]
}));
assert_eq!(
input.ok().flatten().map(|i| i.drawings[0].byte_size),
Some(10)
);
let jobs = serde_json::from_value::<Vec<VerifyJob>>(json!([{ "review_id": "r",
"version_id": "v", "sheet_id": "s", "revision": 1, "lease_token": "t", "attempts": 1 }]));
assert_eq!(jobs.ok().map(|j| j[0].revision), Some(1));
}
#[test]
fn object_urls_need_valid_buckets_and_keys() {
let config = Config::from_vars(|name| match name {
@@ -320,6 +440,17 @@ mod tests {
.object_url("avatars", "profiles/../etc/passwd")
.is_err()
);
let drawing = format!("{}.svg", "ab".repeat(32));
assert_eq!(
backend
.drawing_url("anatomical-sheet-assets", &drawing)
.ok(),
Some(format!(
"http://kong:8000/storage/v1/object/anatomical-sheet-assets/{drawing}"
))
);
assert!(backend.drawing_url("anatomical-sheet-assets", key).is_err());
assert!(backend.drawing_url("a/b", &drawing).is_err());
assert_eq!(
backend.rpc_url("claim_avatar_jobs"),
"http://kong:8000/rest/v1/rpc/claim_avatar_jobs"