From a124cadc433c043b21e7a00d6829da50085b6035 Mon Sep 17 00:00:00 2001 From: Ayoazeez26 <44169294+Ayoazeez26@users.noreply.github.com> Date: Fri, 23 Oct 2026 10:05:54 +0100 Subject: [PATCH] Rename known_length to padded BHTTP req length "Known length" is ambiguous: it reads like the BHTTP known-length framing mode rather than the size each inner request is padded to. Name it after what it sets. This is a breaking change to OhttpClient and WasmOhttpClient, and to the field of Error::KnownLengthTooSmall. Suggested in https://github.com/fungi-protocol/fungi/pull/141#discussion_r4315020605 Closes #8 --- src/error.rs | 9 +++++++-- src/lib.rs | 40 ++++++++++++++++++++++------------------ src/wasm.rs | 6 +++--- tests/e2e.rs | 4 ++-- 4 files changed, 34 insertions(+), 25 deletions(-) diff --git a/src/error.rs b/src/error.rs index 672da94..3db18bb 100644 --- a/src/error.rs +++ b/src/error.rs @@ -11,8 +11,13 @@ pub enum Error { Url(#[from] url::ParseError), #[error("getrandom: {0}")] GetRandom(#[from] getrandom::Error), - #[error("bhttp payload ({needed} bytes) exceeds known length ({known_length})")] - KnownLengthTooSmall { needed: usize, known_length: usize }, + #[error( + "bhttp payload ({needed} bytes) exceeds known padded bhttp request length ({known_padded_bhttp_req_length})" + )] + KnownLengthTooSmall { + needed: usize, + known_padded_bhttp_req_length: usize, + }, #[error("no key config found in response")] NoKeyConfig, #[error("inner message is not a response")] diff --git a/src/lib.rs b/src/lib.rs index 077081a..1ad65c4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -167,7 +167,7 @@ pub struct OhttpClient { relay: Url, /// Origin plus an optional base path. target: Url, - known_length: Option, + known_padded_bhttp_req_length: Option, } impl OhttpClient { @@ -178,15 +178,15 @@ impl OhttpClient { relay, target, key_config, - known_length: None, + known_padded_bhttp_req_length: None, } } - /// Pad each BHTTP inner request to `known_length` bytes with random - /// trailing bytes. Encapsulation fails with [`Error::KnownLengthTooSmall`] - /// if a request is longer. - pub fn known_length(mut self, known_length: usize) -> Self { - self.known_length = Some(known_length); + /// Pad each BHTTP inner request to `known_padded_bhttp_req_length` bytes + /// with random trailing bytes. Encapsulation fails with + /// [`Error::KnownLengthTooSmall`] if a request is longer. + pub fn known_padded_bhttp_req_length(mut self, known_padded_bhttp_req_length: usize) -> Self { + self.known_padded_bhttp_req_length = Some(known_padded_bhttp_req_length); self } @@ -227,7 +227,7 @@ impl OhttpClient { if let Some(body) = body { inner.write_content(body); } - let bhttp_bytes = write_bhttp_payload(&inner, self.known_length)?; + let bhttp_bytes = write_bhttp_payload(&inner, self.known_padded_bhttp_req_length)?; let (encapsulated, ctx) = match &self.key_config.0 { KeyConfigInner::Ohttp(config) => { @@ -307,17 +307,20 @@ fn append_paths(base: &str, path: &str) -> String { } /// Serialize `inner` as known-length BHTTP, padded with random bytes to -/// `known_length` if set. -fn write_bhttp_payload(inner: &Message, known_length: Option) -> Result, Error> { +/// `known_padded_bhttp_req_length` if set. +fn write_bhttp_payload( + inner: &Message, + known_padded_bhttp_req_length: Option, +) -> Result, Error> { let mut msg = Vec::new(); inner.write_bhttp(Mode::KnownLength, &mut msg)?; - let Some(len) = known_length else { + let Some(len) = known_padded_bhttp_req_length else { return Ok(msg); }; if msg.len() > len { return Err(Error::KnownLengthTooSmall { needed: msg.len(), - known_length: len, + known_padded_bhttp_req_length: len, }); } let mut buf = vec![0u8; len]; @@ -711,8 +714,9 @@ mod tests { #[test] fn encapsulate_pads_to_known_length() { let server = ohttp::Server::new(test_key_config()).unwrap(); - let known_length = 512; - let client = test_client(server.config().clone()).known_length(known_length); + let known_padded_bhttp_req_length = 512; + let client = test_client(server.config().clone()) + .known_padded_bhttp_req_length(known_padded_bhttp_req_length); let (req, _) = client .encapsulate( @@ -725,26 +729,26 @@ mod tests { .unwrap(); let (inner_bytes, _) = server.decapsulate(&req.body).unwrap(); - assert_eq!(inner_bytes.len(), known_length); + assert_eq!(inner_bytes.len(), known_padded_bhttp_req_length); let mut cursor = Cursor::new(&inner_bytes[..]); let inner = Message::read_bhttp(&mut cursor).unwrap(); assert_eq!(inner.content(), b"hello"); let msg_len = cursor.position() as usize; - assert!(msg_len < known_length); + assert!(msg_len < known_padded_bhttp_req_length); // Trailing padding is random, not zero-filled. assert!(inner_bytes[msg_len..].iter().any(|&b| b != 0)); } #[test] fn encapsulate_rejects_known_length_too_small() { - let client = test_client(test_key_config()).known_length(1); + let client = test_client(test_key_config()).known_padded_bhttp_req_length(1); let result = client.encapsulate("POST", "/", &[], &[], Some(b"hello")); assert!(matches!( result, Err(Error::KnownLengthTooSmall { needed, - known_length: 1 + known_padded_bhttp_req_length: 1 }) if needed > 1 )); } diff --git a/src/wasm.rs b/src/wasm.rs index a5725ce..77fcb4f 100644 --- a/src/wasm.rs +++ b/src/wasm.rs @@ -27,9 +27,9 @@ impl WasmOhttpClient { }) } - /// See [`OhttpClient::known_length`]. - pub fn known_length(mut self, n: usize) -> WasmOhttpClient { - self.inner = self.inner.known_length(n); + /// See [`OhttpClient::known_padded_bhttp_req_length`]. + pub fn known_padded_bhttp_req_length(mut self, n: usize) -> WasmOhttpClient { + self.inner = self.inner.known_padded_bhttp_req_length(n); self } diff --git a/tests/e2e.rs b/tests/e2e.rs index b9d284a..935b844 100644 --- a/tests/e2e.rs +++ b/tests/e2e.rs @@ -61,13 +61,13 @@ fn e2e_with_known_length_padding() { assert_eq!(keys_res.status_code, 200); let key_config = parse_key_config(keys_res.as_bytes()).unwrap(); - let known_length = 1024; + let known_padded_bhttp_req_length = 1024; let client = OhttpClient::new( Url::parse(harness.relay_url()).unwrap(), Url::parse(harness.target_url()).unwrap(), key_config.clone(), ) - .known_length(known_length); + .known_padded_bhttp_req_length(known_padded_bhttp_req_length); let (req, ctx) = client .encapsulate(