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
+145
-14
@@ -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"
|
||||
|
||||
Reference in new issue
Block a user