Lightweight coding agent that runs in your terminal
Rust
Support bounded request bodies in AWS SigV4 signing (#56277)
viyatb-oai129220bf057d
diff --git a/codex-rs/network-proxy/Cargo.toml b/codex-rs/network-proxy/Cargo.tomlindex df3c80240b..0706660b95 100644--- a/codex-rs/network-proxy/Cargo.toml+++ b/codex-rs/network-proxy/Cargo.toml@@ -57,6 +57,7 @@ sha2 = { workspace = true }[dev-dependencies]pretty_assertions = { workspace = true }tempfile = { workspace = true }+tokio = { workspace = true, features = ["test-util"] }[target.'cfg(target_family = "unix")'.dependencies]libc = { workspace = true }diff --git a/codex-rs/network-proxy/src/aws_sigv4.rs b/codex-rs/network-proxy/src/aws_sigv4.rsindex 4fc2cd656b..717a3fccc5 100644--- a/codex-rs/network-proxy/src/aws_sigv4.rs+++ b/codex-rs/network-proxy/src/aws_sigv4.rs@@ -14,6 +14,7 @@ use aws_sigv4::http_request::UriPathNormalizationMode;use aws_sigv4::http_request::sign;use aws_sigv4::sign::v4;use codex_utils_absolute_path::AbsolutePathBuf;+use rama_core::bytes::Bytes;use rama_core::extensions::ExtensionsMut;use rama_core::extensions::ExtensionsRef;use rama_http::Body;@@ -28,6 +29,7 @@ use schemars::JsonSchema;use serde::Deserialize;use serde::Serialize;use sha2::Digest as _;+use std::time::Duration;use std::time::SystemTime;/// A credential source in the trusted proxy process, never in the executor environment.@@ -77,11 +79,16 @@ pub struct AwsSigV4Config {pub session_token: Option<ProxySecretSource>,#[serde(default = "https_port")]pub port: u16,+ #[serde(default = "default_max_body_bytes")]+ pub max_body_bytes: usize,}pub(crate) fn https_port() -> u16 {443}+pub(crate) fn default_max_body_bytes() -> usize {+ 8 * 1024 * 1024+}#[derive(Clone, PartialEq, Eq)]pub(crate) struct AwsSigV4Signer {@@ -118,6 +125,10 @@ impl AwsSigV4Config {}}ensure!(self.port != 0, "invalid AWS signing port");+ ensure!(+ self.max_body_bytes <= 16 * 1024 * 1024,+ "AWS signing body limit exceeds 16 MiB"+ );self.access_key_id.validate()?;self.secret_access_key.validate()?;if let Some(token) = &self.session_token {@@ -333,7 +344,7 @@ impl AwsSigV4Signer {}))}- pub(crate) fn sign(&self, req: Request, guest: &GuestSignature) -> Result<Request> {+ pub(crate) async fn sign(&self, mut req: Request, guest: &GuestSignature) -> Result<Request> {ensure!(req.uri().scheme_str() == Some("https")&& req.uri().port_u16().unwrap_or(443) == self.config.port@@ -341,6 +352,7 @@ impl AwsSigV4Signer {"AWS signing requires the configured HTTPS origin and supported framing");let had_payload_hash = req.headers().contains_key("x-amz-content-sha256");+ let mut permit = None;let (mut parts, body, payload_hash) = if guest.unsigned_payload {let (parts, body) = req.into_parts();ensure!(@@ -357,14 +369,26 @@ impl AwsSigV4Signer {);(parts, body, "UNSIGNED-PAYLOAD".to_string())} else {- let (parts, body) = req.into_parts();+ let (bytes, trailers) = if req.body().is_end_stream() {+ (Bytes::new(), None)+ } else {+ permit = Some(crate::body_budget::reserve(&mut req).await?);+ let body = std::mem::take(req.body_mut());+ tokio::time::timeout(+ Duration::from_secs(30),+ crate::body_budget::collect_body(body, self.config.max_body_bytes),+ )+ .await+ .map_err(|_| anyhow!("AWS signing body read timed out"))??+ };+ let (parts, _) = req.into_parts();ensure!(- body.is_end_stream()- && crate::body_budget::content_length_matches(&parts.headers, /*size*/ 0),- "AWS signing requires an empty or explicitly unsigned payload"+ trailers.is_none()+ && crate::body_budget::content_length_matches(&parts.headers, bytes.len()),+ "AWS signing requires unambiguous payload framing");- let digest = format!("{:x}", sha2::Sha256::digest([]));- (parts, Body::empty(), digest)+ let digest = format!("{:x}", sha2::Sha256::digest(&bytes));+ (parts, Body::from(bytes), digest)};if ["connection", "proxy-connection", "upgrade", "te"].iter()@@ -497,7 +521,12 @@ impl AwsSigV4Signer {);parts.headers.insert(header.name(), value);}- Ok(Request::from_parts(parts, body))+ let req = Request::from_parts(parts, body);+ Ok(if permit.is_some() {+ crate::body_budget::retain(req)+ } else {+ req+ })}}diff --git a/codex-rs/network-proxy/src/aws_sigv4_tests.rs b/codex-rs/network-proxy/src/aws_sigv4_tests.rsindex 94fe412ead..fcde5d2389 100644--- a/codex-rs/network-proxy/src/aws_sigv4_tests.rs+++ b/codex-rs/network-proxy/src/aws_sigv4_tests.rs@@ -13,6 +13,7 @@ fn config(service: &str) -> AwsSigV4Config {secret_access_key: ProxySecretSource::EnvVar("SECRET_KEY".into()),session_token: None,port: 443,+ max_body_bytes: 1024,}}@@ -35,6 +36,12 @@ fn signer(config: AwsSigV4Config) -> AwsSigV4Signer {.unwrap()}+fn time() -> SystemTime {+ chrono::DateTime::parse_from_rfc3339("2015-08-30T12:36:00Z")+ .unwrap()+ .into()+}+pub(crate) fn guest_authorization(service: &str, signed_headers: &str) -> String {format!("AWS4-HMAC-SHA256 Credential=MASKEDACCESSKEY/20150830/us-east-1/{service}/aws4_request, SignedHeaders={signed_headers}, Signature={:064x}",@@ -42,18 +49,20 @@ pub(crate) fn guest_authorization(service: &str, signed_headers: &str) -> String)}-fn resign(signer: &AwsSigV4Signer, mut req: Request, headers: &str) -> Result<Request> {+async fn resign(signer: &AwsSigV4Signer, mut req: Request, headers: &str) -> Result<Request> {let auth = guest_authorization(&signer.config.service, headers);req.headers_mut().insert("authorization", HeaderValue::from_str(&auth)?);req.headers_mut().insert("x-amz-date", HeaderValue::from_static("20150830T123600Z"));let guest = signer.plan(&req)?.expect("selected guest credential");- signer.sign(req, &guest)+ signer.sign(req, &guest).await}#[test]fn matches_aws_published_iam_signature_vector() {+ use rama_core::futures::FutureExt as _;+// AWS Signature Version 4 ListUsers example, 2015-08-30.let request = Request::builder().method("GET")@@ -70,6 +79,8 @@ fn matches_aws_published_iam_signature_vector() {request,"content-type;host;x-amz-date",)+ .now_or_never()+ .expect("an empty request must sign without waiting for buffer capacity").unwrap();assert_eq!(signed.headers()["authorization"],@@ -78,17 +89,65 @@ fn matches_aws_published_iam_signature_vector() {}#[tokio::test]-async fn streams_explicitly_unsigned_s3_uploads() {+async fn signs_actual_payload_and_replaces_untrusted_signing_headers() {let mut config = config("s3");config.session_token = Some(ProxySecretSource::EnvVar("SESSION_TOKEN".into()));let signer = signer(config);+ let mut cookie = HeaderValue::from_static("b=2");+ cookie.set_sensitive(true);+ let request = Request::builder()+ .method("PUT")+ .version(rama_http::Version::HTTP_2)+ .uri("https://bucket.s3.amazonaws.com/a%20b?tag=b&tag=a&empty=")+ .header("host", "bucket.s3.amazonaws.com")+ .header("cookie", "a=1")+ .header("cookie", cookie)+ .header("authorization", "guest-signature")+ .header("x-amz-date", "19700101T000000Z")+ .header("x-amz-security-token", "guest-token")+ .header("x-amz-content-sha256", "untrusted-guest-hash")+ .body(Body::from("hello"))+ .unwrap();+ let signed = resign(+ &signer,+ request,+ "cookie;host;x-amz-content-sha256;x-amz-date",+ )+ .await+ .unwrap();+ assert_eq!(+ signed.headers()["x-amz-content-sha256"],+ "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"+ );+ assert_eq!(signed.headers()["x-amz-date"], "20150830T123600Z");+ assert_eq!(+ signed.headers()["x-amz-security-token"],+ "secret-session-token"+ );+ assert!(signed.headers()["x-amz-security-token"].is_sensitive());+ assert!(signed.headers()["authorization"].is_sensitive());+ assert_eq!(+ signed+ .headers()+ .get_all("cookie")+ .iter()+ .collect::<Vec<_>>(),+ vec![&HeaderValue::from_static("a=1; b=2")]+ );+ assert!(signed.headers()["cookie"].is_sensitive());+ let forwarded = signed.into_body().collect().await.unwrap().to_bytes();+ assert_eq!(forwarded.as_ref(), b"hello");+ assert!(!format!("{signer:?}").contains("EXAMPLEKEY"));+ assert!(!format!("{signer:?}").contains("AKIDEXAMPLE"));++ // An SDK's unsigned S3 upload streams through without consuming the literal-body budget.let upload = Request::builder().uri("https://bucket.s3.amazonaws.com/upload").header("x-amz-content-sha256", "UNSIGNED-PAYLOAD").header("x-unsigned-metadata", "forward only").body(Body::from(vec![b'x'; 1025])).unwrap();- let upload = resign(&signer, upload, "host;x-amz-date").unwrap();+ let upload = resign(&signer, upload, "host;x-amz-date").await.unwrap();assert_eq!(upload.headers()["x-amz-content-sha256"], "UNSIGNED-PAYLOAD");let authorization = upload.headers()["authorization"].to_str().unwrap();assert!(authorization.contains("SignedHeaders=host;x-amz-date;x-amz-security-token,"));@@ -99,8 +158,57 @@ async fn streams_explicitly_unsigned_s3_uploads() {);}-#[test]-fn rejects_wrong_transport_scope_streaming_and_nonempty_bodies() {+#[tokio::test]+async fn canonicalizes_query_order_without_changing_encoded_s3_path() {+ use sha2::Digest;++ for service in ["s3", "s3-object-lambda", "s3-outposts"] {+ let signer = signer(config(service));+ let payload_hash = format!("{:x}", sha2::Sha256::digest(b""));+ let signed_headers = "host;x-amz-content-sha256;x-amz-date";+ // Build the canonical request independently of SDK request canonicalization.+ // The encoded space and repeated slash must remain part of the object key.+ let canonical_request = format!(+ "GET\n/a%20b//key\na=one&a=two&space=a%20b&z=last\nhost:bucket.s3.amazonaws.com\nx-amz-content-sha256:{payload_hash}\nx-amz-date:20150830T123600Z\n\n{signed_headers}\n{payload_hash}"+ );+ let scope = format!("20150830/us-east-1/{service}/aws4_request");+ let string_to_sign = format!(+ "AWS4-HMAC-SHA256\n20150830T123600Z\n{scope}\n{:x}",+ sha2::Sha256::digest(canonical_request.as_bytes())+ );+ let key = aws_sigv4::sign::v4::generate_signing_key(+ "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY",+ time(),+ "us-east-1",+ service,+ );+ let signature = aws_sigv4::sign::v4::calculate_signature(key, string_to_sign.as_bytes());+ let authorization = format!(+ "AWS4-HMAC-SHA256 Credential=AKIDEXAMPLE/{scope}, SignedHeaders={signed_headers}, Signature={signature}"+ );+ for query in [+ "z=last&a=two&a=one&space=a%20b",+ "a=one&space=a%20b&a=two&z=last",+ ] {+ let uri = format!("https://bucket.s3.amazonaws.com/a%20b//key?{query}");+ let request = Request::builder()+ .uri(&uri)+ .header("x-amz-content-sha256", payload_hash.as_str())+ .body(Body::empty())+ .unwrap();+ let signed = resign(&signer, request, signed_headers).await.unwrap();+ assert_eq!(signed.uri().to_string(), uri);+ assert_eq!(+ signed.headers()["authorization"],+ authorization,+ "{service}"+ );+ }+ }+}++#[tokio::test]+async fn rejects_wrong_transport_port_streaming_presigning_and_body_overflow() {let signer = signer(config("s3"));let valid = "https://bucket.s3.amazonaws.com/key";for uri in [@@ -109,7 +217,25 @@ fn rejects_wrong_transport_scope_streaming_and_nonempty_bodies() {"https://bucket.s3.amazonaws.com/key?X-Amz-Signature=guest",] {let req = Request::builder().uri(uri).body(Body::empty()).unwrap();- assert!(resign(&signer, req, "host;x-amz-date").is_err(), "{uri}");+ assert!(+ resign(&signer, req, "host;x-amz-date").await.is_err(),+ "{uri}"+ );+ }+ for (name, value) in [+ ("content-encoding", "aws-chunked"),+ ("x-amz-content-sha256", "STREAMING-AWS4-HMAC-SHA256-PAYLOAD"),+ ("content-length", "1"),+ ] {+ let req = Request::builder()+ .uri(valid)+ .header(name, value)+ .body(Body::from("abc"))+ .unwrap();+ assert!(+ resign(&signer, req, "host;x-amz-date").await.is_err(),+ "{name}"+ );}let auth = guest_authorization("s3", "host;x-amz-date");for value in [@@ -136,6 +262,73 @@ fn rejects_wrong_transport_scope_streaming_and_nonempty_bodies() {Body::empty().with_trailer_headers(HeaderMap::new()),] {let req = Request::builder().uri(valid).body(body).unwrap();- assert!(resign(&signer, req, "host;x-amz-date").is_err());+ assert!(resign(&signer, req, "host;x-amz-date").await.is_err());+ }+ let stalled = rama_core::futures::stream::pending::<std::io::Result<rama_core::bytes::Bytes>>();+ let mut req = Request::builder()+ .uri(valid)+ .body(Body::from_stream(stalled))+ .unwrap();+ // Other tests use the process-wide pool on real clocks.+ let _permit = crate::body_budget::reserve(&mut req).await.unwrap();+ tokio::time::pause();+ let start = tokio::time::Instant::now();+ let signing = resign(&signer, req, "host;x-amz-date");+ let result = tokio::time::timeout(Duration::from_secs(31), signing)+ .await+ .expect("signer must enforce its own deadline");+ let error = result.unwrap_err();+ assert_eq!(error.to_string(), "AWS signing body read timed out");+ assert!(start.elapsed() >= Duration::from_secs(30));+}++#[test]+fn credentials_are_required_and_configured_limits_are_bounded() {+ assert!(+ config("s3")+ .compile(&|_| None, &|_| panic!("unexpected file"))+ .is_err()+ );+ let mut config = config("s3");+ config.max_body_bytes = 16 * 1024 * 1024 + 1;+ assert_eq!(+ config.validate().unwrap_err().to_string(),+ "AWS signing body limit exceeds 16 MiB"+ );+ config.port = 0;+ assert_eq!(+ config.validate().unwrap_err().to_string(),+ "invalid AWS signing port"+ );+}++#[tokio::test]+async fn sdk_trace_does_not_log_canonical_secret_headers() {+ use tracing::instrument::WithSubscriber;+ let capture = tempfile::NamedTempFile::new().unwrap();+ let subscriber = tracing_subscriber::fmt()+ .with_ansi(false)+ .with_max_level(tracing::Level::TRACE)+ .with_writer(std::sync::Arc::new(capture.reopen().unwrap()))+ .finish();+ let request = Request::builder()+ .uri("https://example.com/")+ .header("x-api-key", "secret-header-value")+ .body(Body::empty())+ .unwrap();+ let mut config = config("execute-api");+ config.session_token = Some(ProxySecretSource::EnvVar("SESSION_TOKEN".into()));+ async {+ tracing::trace!("proxy audit remains enabled");+ resign(&signer(config), request, "host;x-amz-date;x-api-key")+ .await+ .unwrap();}+ .with_subscriber(subscriber)+ .await;+ let logs = std::fs::read_to_string(capture.path()).unwrap();+ assert!(logs.contains("proxy audit remains enabled"));+ assert!(!logs.contains("secret-header-value"));+ assert!(!logs.contains("secret-session-token"));+ assert!(!logs.contains("EXAMPLEKEY"));}diff --git a/codex-rs/network-proxy/src/body_budget.rs b/codex-rs/network-proxy/src/body_budget.rsindex fb90b1fafa..f00e148ac2 100644--- a/codex-rs/network-proxy/src/body_budget.rs+++ b/codex-rs/network-proxy/src/body_budget.rs@@ -1,6 +1,60 @@-//! Validate original HTTP framing and the declared length for AWS signing.+//! Shared leases bound buffers across quota checks, secret substitution, and signing.+//! Eight requests each reserve space for a 16 MiB input and 16 MiB transformed output.+use anyhow::Result;+use anyhow::anyhow;+use rama_core::bytes::Bytes;+use rama_core::extensions::ExtensionsMut;+use rama_core::extensions::ExtensionsRef;+use rama_http::Body;use rama_http::HeaderMap;+use rama_http::Request;+use rama_http::body::Frame;+use rama_http::body::SizeHint;+use rama_http::body::StreamingBody;+use rama_http::body::util::BodyExt;+use std::pin::Pin;+use std::sync::Arc;+use std::sync::LazyLock;+use std::sync::Weak;+use std::task::Context;+use std::task::Poll;+use std::time::Duration;+use tokio::sync::OwnedSemaphorePermit;+use tokio::sync::Semaphore;++const BUFFER_SLOT_COUNT: usize = 8;+static BUFFER_SLOTS: LazyLock<Arc<Semaphore>> =+ LazyLock::new(|| Arc::new(Semaphore::new(BUFFER_SLOT_COUNT)));++// Rama clones request metadata through response headers. Keep ownership in the transform or body.+#[derive(Debug, Clone)]+struct BufferLease(Weak<OwnedSemaphorePermit>);++pub(crate) async fn reserve(req: &mut Request) -> Result<Arc<OwnedSemaphorePermit>> {+ reserve_in(req, &BUFFER_SLOTS).await+}++async fn reserve_in(+ req: &mut Request,+ slots: &Arc<Semaphore>,+) -> Result<Arc<OwnedSemaphorePermit>> {+ if let Some(permit) = req+ .extensions()+ .get::<BufferLease>()+ .and_then(|lease| lease.0.upgrade())+ {+ return Ok(permit);+ }+ let permit = tokio::time::timeout(Duration::from_secs(5), slots.clone().acquire_owned())+ .await+ .map_err(|_| anyhow!("request buffer capacity unavailable"))?+ .map_err(|_| anyhow!("request buffer budget closed"))?;+ let permit = Arc::new(permit);+ req.extensions_mut()+ .insert(BufferLease(Arc::downgrade(&permit)));+ Ok(permit)+}pub(crate) fn is_amazon_event_stream(headers: &HeaderMap) -> bool {headers.get_all("content-type").iter().any(|value| {@@ -43,3 +97,99 @@ pub(crate) fn content_length_matches(headers: &HeaderMap, size: usize) -> bool {}}}++/// Copy frames as they arrive so fragmented bodies cannot retain per-frame allocations.+pub(crate) async fn collect_body(+ mut body: Body,+ max_bytes: usize,+) -> Result<(Bytes, Option<HeaderMap>)> {+ let mut bytes = Vec::new();+ let mut trailers: Option<HeaderMap> = None;+ while let Some(frame) = body.frame().await {+ let frame = frame.map_err(|_| anyhow!("cannot read request body"))?;+ if trailers.is_some() {+ return Err(anyhow!("unexpected request frame after trailers"));+ }+ match frame.into_data() {+ Ok(data) => {+ if data.len() > max_bytes - bytes.len() {+ return Err(anyhow!("request body exceeds configured limit"));+ }+ let len = bytes.len() + data.len();+ if len > bytes.capacity() {+ // Grow geometrically without reserving beyond the configured byte limit.+ let capacity = max_bytes.min(bytes.capacity().saturating_mul(2).max(len));+ bytes+ .try_reserve_exact(capacity - bytes.len())+ .map_err(|_| anyhow!("request body buffer allocation failed"))?;+ }+ bytes.extend_from_slice(&data);+ }+ Err(frame) => trailers = frame.into_trailers().ok(),+ }+ }+ Ok((Bytes::from(bytes), trailers))+}++struct RetainedBody {+ body: Body,+ lease: Option<Arc<OwnedSemaphorePermit>>,+}++struct LeasedBytes {+ bytes: Bytes,+ _lease: Arc<OwnedSemaphorePermit>,+}++impl AsRef<[u8]> for LeasedBytes {+ fn as_ref(&self) -> &[u8] {+ &self.bytes+ }+}++impl StreamingBody for RetainedBody {+ type Data = Bytes;+ type Error = <Body as StreamingBody>::Error;++ fn poll_frame(+ mut self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {+ match Pin::new(&mut self.body).poll_frame(cx) {+ Poll::Ready(Some(Ok(frame))) => {+ let lease = self.lease.clone();+ Poll::Ready(Some(Ok(frame.map_data(|bytes| match lease {+ Some(lease) => Bytes::from_owner(LeasedBytes {+ bytes,+ _lease: lease,+ }),+ None => bytes,+ }))))+ }+ other => other,+ }+ }++ fn is_end_stream(&self) -> bool {+ self.body.is_end_stream()+ }++ fn size_hint(&self) -> SizeHint {+ self.body.size_hint()+ }+}++pub(crate) fn retain(req: Request) -> Request {+ let (parts, body) = req.into_parts();+ let lease = parts+ .extensions+ .get::<BufferLease>()+ .and_then(|lease| lease.0.upgrade());+ // Keep exact sizing, and retain the lease in data frames queued after the body is dropped.+ let body = Body::new(RetainedBody { body, lease });+ Request::from_parts(parts, body)+}++#[cfg(test)]+#[path = "body_budget_tests.rs"]+mod tests;diff --git a/codex-rs/network-proxy/src/body_budget_tests.rs b/codex-rs/network-proxy/src/body_budget_tests.rsnew file mode 100644index 0000000000..1336742ed1--- /dev/null+++ b/codex-rs/network-proxy/src/body_budget_tests.rs@@ -0,0 +1,94 @@+//! Reservations survive request metadata disposal and are reused across transform stages.++use super::*;+use pretty_assertions::assert_eq;+use rama_core::futures::stream;+use std::sync::atomic::AtomicUsize;+use std::sync::atomic::Ordering;++#[tokio::test]+async fn fragmented_body_collection_releases_chunks_and_enforces_the_byte_limit() {+ struct Chunk {+ bytes: [u8; 1],+ live: Arc<AtomicUsize>,+ }++ impl AsRef<[u8]> for Chunk {+ fn as_ref(&self) -> &[u8] {+ &self.bytes+ }+ }++ impl Drop for Chunk {+ fn drop(&mut self) {+ self.live.fetch_sub(1, Ordering::SeqCst);+ }+ }++ for max_bytes in [1024, 1023] {+ let live = Arc::new(AtomicUsize::new(0));+ let chunks = (0..1024).map({+ let live = live.clone();+ move |_| {+ assert_eq!(+ live.fetch_add(1, Ordering::SeqCst),+ 0,+ "the collector retained a previous chunk"+ );+ Ok::<_, std::io::Error>(Bytes::from_owner(Chunk {+ bytes: *b"x",+ live: live.clone(),+ }))+ }+ });+ let result = collect_body(Body::from_stream(stream::iter(chunks)), max_bytes).await;+ assert_eq!(live.load(Ordering::SeqCst), 0);+ if max_bytes == 1024 {+ assert_eq!(result.unwrap(), (Bytes::from(vec![b'x'; 1024]), None));+ } else {+ assert!(result.is_err());+ }+ }+}++#[tokio::test]+async fn body_keeps_buffer_lease_and_nested_stages_reuse_it() {+ let mut request = Request::new(Body::from("payload"));+ let slots = Arc::new(Semaphore::new(BUFFER_SLOT_COUNT));+ let permit = reserve_in(&mut request, &slots).await.unwrap();+ let lease = Arc::downgrade(&permit);+ let nested = reserve_in(&mut request, &slots).await.unwrap();+ assert!(Arc::ptr_eq(&permit, &nested));+ let request = retain(request);+ drop(nested);+ drop(permit);+ let metadata = request.extensions().clone();+ let (parts, mut body) = request.into_parts();+ assert_eq!(body.size_hint().exact(), Some(7));+ drop(parts);+ assert!(lease.upgrade().is_some());+ let frame = body.frame().await.expect("body frame").expect("body data");+ drop(body);+ assert!(lease.upgrade().is_some());+ let bytes = frame.into_data().expect("data frame");+ assert_eq!(bytes.as_ref(), b"payload");+ let queued = bytes.clone();+ drop(bytes);+ assert!(lease.upgrade().is_some());+ let mut held = Vec::new();+ for _ in 1..8 {+ let permit = slots+ .clone()+ .try_acquire_owned()+ .expect("eight buffer slots");+ held.push(permit);+ }+ let mut ninth = Request::new(Body::empty());+ let reservation = reserve_in(&mut ninth, &slots);+ tokio::pin!(reservation);+ assert!(rama_core::futures::poll!(&mut reservation).is_pending());+ drop(queued);+ assert!(lease.upgrade().is_none());+ let _permit = reservation.await.expect("released buffer slot");+ drop(metadata);+}diff --git a/codex-rs/network-proxy/src/mitm.rs b/codex-rs/network-proxy/src/mitm.rsindex 9d0a475187..7c21a85a56 100644--- a/codex-rs/network-proxy/src/mitm.rs+++ b/codex-rs/network-proxy/src/mitm.rs@@ -370,7 +370,7 @@ async fn forward_request(req: Request, request_ctx: &MitmRequestContext) -> Resulet mut upstream_req = Request::from_parts(parts, body);if let Some((signer, guest)) = signing {- let Ok(signed) = signer.sign(upstream_req, &guest) else {+ let Ok(signed) = signer.sign(upstream_req, &guest).await else {return Ok(request_ctx.policy.deny_hook(&method, client).await);};upstream_req = signed;