From be7f6f5b81dc8180419cac6b3acd3e595b8fce53 Mon Sep 17 00:00:00 2001 From: Rohit P Date: Fri, 13 Nov 2026 14:04:07 -0800 Subject: [PATCH] fix: inspect service attachments without a worker lease --- .../server-reference/src/input_attachments.rs | 126 ++++++++++++++++-- harness/server-reference/src/service.rs | 3 +- .../server-reference/src/service_safety.rs | 24 ++++ .../tests/input_attachments.rs | 84 +++++++++++- 4 files changed, 220 insertions(+), 17 deletions(-) diff --git a/harness/server-reference/src/input_attachments.rs b/harness/server-reference/src/input_attachments.rs index ec9145c5..61cf6a53 100644 --- a/harness/server-reference/src/input_attachments.rs +++ b/harness/server-reference/src/input_attachments.rs @@ -1,8 +1,11 @@ //! Authenticated bounded uploads; model inputs are independent of sandbox files. use crate::http::{ApiError, App}; +use anyhow::ensure; use axum::{extract::Path, Extension, Json}; +use base64::{engine::general_purpose::STANDARD, Engine}; use openworker_runtime::{ - attachments::{Part, Upload}, + attachments::{InspectionUnsupported, Metadata, Part, Upload, CHUNK, MAX_TURN}, + safety::Phase, store::StateStore, }; use serde_json::Value; @@ -15,20 +18,115 @@ pub(crate) async fn upload( let blob = app.store.clone().input_attachment(&sid, &id, request)?; Ok(Json(blob.reply())) } -pub(crate) async fn inspect(app: &App, sid: &str, parts: &[Part]) -> Result, ApiError> { - app.store.input_safety_policy(sid)?; +pub(crate) async fn inspect( + app: &App, + sid: &str, + request: &str, + parts: &[Part], +) -> Result, ApiError> { + inspect_parts(app, sid, request, parts) + .await + .map_err(ApiError) +} +async fn inspect_parts( + app: &App, + sid: &str, + request: &str, + parts: &[Part], +) -> anyhow::Result> { + let (session, _) = app.store.input_safety_policy(sid)?; + let policy = app.config.safety.merge(&session)?; openworker_runtime::attachments::validate_parts(parts)?; - // Check ownership using the request-scoped store before trusted runtime - // inspection. Never allow an ID to cross a project/principal boundary. + let mut checked = Vec::new(); + let mut total = 0usize; + // API admission uses the authorized request-scoped store. The API runtime + // does not own this session's worker lease, so its metadata/inspection path + // must not be used here. Never claim or steal a lease just to inspect input. for part in parts { - if let Part::Image { attachment_id } | Part::Document { attachment_id } = part { - app.store - .clone() - .input_attachment(sid, attachment_id, Upload::Stat)?; - } + checked.push(match part { + Part::Text { text } => Part::Text { + text: crate::service_safety::inspect_attachment_text(app, sid, request, text) + .await + .map_err(|e| e.0)?, + }, + Part::Image { attachment_id } | Part::Document { attachment_id } => { + let blob = app + .store + .clone() + .input_attachment(sid, attachment_id, Upload::Stat)?; + ensure!(blob.sealed, "Attachment upload is incomplete"); + total = total.saturating_add(blob.metadata.size); + ensure!(total <= MAX_TURN, "Turn attachment byte limit exceeded"); + let image = matches!(part, Part::Image { .. }); + ensure!( + if image { + blob.metadata.media_type.starts_with("image/") + } else { + ["application/pdf", "text/plain"] + .contains(&blob.metadata.media_type.as_str()) + }, + "Attachment type mismatch" + ); + let id = if blob.metadata.media_type == "text/plain" { + let text = std::str::from_utf8(&blob.bytes)?; + let replacement = + crate::service_safety::inspect_attachment_text(app, sid, request, text) + .await + .map_err(|e| e.0)?; + if replacement.as_bytes() != blob.bytes { + let bytes = replacement.into_bytes(); + let hash = openworker_runtime::bundle::digest(&bytes); + let identity = openworker_runtime::bundle::digest(&serde_json::to_vec( + &serde_json::json!([ + blob.metadata.name, + blob.metadata.media_type, + hash + ]), + )?); + let metadata = Metadata { + id: format!("att_{identity}"), + sha256: hash, + size: bytes.len(), + ..blob.metadata.clone() + }; + let mut store = app.store.clone(); + store.input_attachment( + sid, + &metadata.id, + Upload::Begin { + metadata: metadata.clone(), + }, + )?; + for (i, chunk) in bytes.chunks(CHUNK).enumerate() { + store.input_attachment( + sid, + &metadata.id, + Upload::Chunk { + offset: i * CHUNK, + data: STANDARD.encode(chunk), + }, + )?; + } + store.input_attachment(sid, &metadata.id, Upload::Commit)?; + metadata.id + } else { + attachment_id.clone() + } + } else { + if policy.protects(Phase::UserInput, None) + || policy.protects(Phase::ModelInput, None) + { + return Err(InspectionUnsupported.into()); + } + attachment_id.clone() + }; + if image { + Part::Image { attachment_id: id } + } else { + Part::Document { attachment_id: id } + } + } + }); } - Ok(app - .runtime - .prepare_input_content(sid, parts, Some(&app.config.safety)) - .await?) + Ok(checked) } diff --git a/harness/server-reference/src/service.rs b/harness/server-reference/src/service.rs index 48ba1244..abbc6da5 100644 --- a/harness/server-reference/src/service.rs +++ b/harness/server-reference/src/service.rs @@ -323,7 +323,8 @@ async fn send( None, ), (None, Some(parts)) => { - let parts = crate::input_attachments::inspect(&app, &sid, &parts).await?; + let parts = + crate::input_attachments::inspect(&app, &sid, &submission_id, &parts).await?; let text = openworker_runtime::attachments::summary(&parts); (text, Some(parts)) } diff --git a/harness/server-reference/src/service_safety.rs b/harness/server-reference/src/service_safety.rs index b76afde2..333c49e0 100644 --- a/harness/server-reference/src/service_safety.rs +++ b/harness/server-reference/src/service_safety.rs @@ -36,6 +36,30 @@ async fn inspect_with( openworker_store_postgres::SubmissionError::InvalidRequest.into(), )); } + inspect_policy(app, sid, request, text, extra).await +} +/// UTF-8 documents have their own bounded upload limit, independent of the +/// 32 KB conversational-text limit. Admission never claims a worker lease. +pub(crate) async fn inspect_attachment_text( + app: &App, + sid: &str, + request: &str, + text: &str, +) -> Result { + if text.len() > openworker_runtime::attachments::MAX_FILE { + return Err(ApiError( + openworker_store_postgres::SubmissionError::InvalidRequest.into(), + )); + } + inspect_policy(app, Some(sid), request, text, None).await +} +async fn inspect_policy( + app: &App, + sid: Option<&str>, + request: &str, + text: &str, + extra: Option<&Config>, +) -> Result { let (config, pins) = if let Some(sid) = sid { let (session, pins) = app.store.input_safety_policy(sid)?; (app.config.safety.merge(&session)?, pins) diff --git a/harness/server-reference/tests/input_attachments.rs b/harness/server-reference/tests/input_attachments.rs index cc0549b6..932aae03 100644 --- a/harness/server-reference/tests/input_attachments.rs +++ b/harness/server-reference/tests/input_attachments.rs @@ -33,7 +33,7 @@ async fn uploads_cross_api_replicas_are_scoped_and_recoverable() { let mut store = PostgresStore::open(db.clone()).unwrap(); store.auth_bootstrap(ADMIN, "admin").unwrap(); let admin = store.authorized(ADMIN).unwrap(); - for sid in ["s_one", "s_two"] { + for sid in ["s_one", "s_two", "s_three"] { let mut session:Session=serde_json::from_value(json!({"id":sid,"name":"Input","workspace":"/work","coworker":"test","bundle_digest":"bundle","schema_digest":null,"interactions":[],"turn":null,"sandbox":null,"closed":false,"resource_policy":openworker_runtime::resource_policy::Resolved::default()})).unwrap(); if sid == "s_two" { session @@ -46,6 +46,20 @@ async fn uploads_cross_api_replicas_are_scoped_and_recoverable() { openworker_runtime::safety::Action::Block, )); } + if sid == "s_three" { + session + .safety + .guardrails + .user_input + .push(openworker_runtime::safety::Rule::regex( + "redact-secret", + "SECRET_[0-9]+", + openworker_runtime::safety::Action::Redact { + replacement: "[redacted]".into(), + keep_last: 0, + }, + )); + } store.save(&session, "session_created", json!({})).unwrap(); } for (token, principal, sid, role) in [ @@ -80,7 +94,9 @@ async fn uploads_cross_api_replicas_are_scoped_and_recoverable() { None, None, Default::default(), - Some(Box::new(store.clone())), + // An API replica does not own the worker's session leases. Sharing the + // worker store here concealed admission's accidental lease dependency. + Some(Box::new(PostgresStore::open(db.clone()).unwrap())), ) .unwrap(); let mut urls = vec![]; @@ -272,6 +288,70 @@ async fn uploads_cross_api_replicas_are_scoped_and_recoverable() { .unwrap() .input_attachment("s_one", "notes", Upload::Stat) .is_err()); + // Guardrails still inspect documents and produce immutable replacement + // references without acquiring or changing the worker's session lease. + let original = b"Document includes SECRET_12345."; + let metadata = Metadata { + id: "original".into(), + name: "secret.txt".into(), + media_type: "text/plain".into(), + size: original.len(), + sha256: openworker_runtime::bundle::digest(original), + }; + for upload in [ + Upload::Begin { metadata }, + Upload::Chunk { + offset: 0, + data: STANDARD.encode(original), + }, + Upload::Commit, + ] { + store + .input_attachment("s_three", "original", upload) + .unwrap(); + } + let redacted = post( + 1, + ADMIN, + "/v1/sessions/s_three/turns".into(), + json!({"content":[{"type":"text","text":""},{"type":"document","attachment_id":"original"}]}), + "redaction", + ) + .await + .unwrap(); + let status = redacted.status(); + let receipt: Value = redacted.json().await.unwrap(); + assert_eq!(status, 202, "{receipt}"); + let input = store + .submission_input("s_three", receipt["submissionId"].as_str().unwrap()) + .unwrap() + .unwrap(); + assert_eq!( + input[0], + Part::Text { + text: String::new() + } + ); + let Part::Document { attachment_id } = &input[1] else { + panic!("Document ordering changed") + }; + assert_ne!(attachment_id, "original"); + let blob = admin + .clone() + .input_attachment("s_three", attachment_id, Upload::Stat) + .unwrap(); + assert_eq!(blob.bytes, b"Document includes [redacted]."); + assert_eq!( + store + .input_attachment("s_three", "original", Upload::Stat) + .unwrap() + .bytes, + original + ); + assert!( + store.get("s_three").is_ok(), + "API inspection must not steal the worker lease" + ); for server in servers { server.abort(); let _ = server.await;