From 407bc35aae1ba773b797cdd46a29ede116a5b89b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 6 Nov 2026 13:59:31 -0800 Subject: [PATCH 1/4] fix: reject box sizes that overflow usize Box header sizes were cast from u64 to usize with `as`. On 32-bit targets a 64-bit extended size above 4 GiB wrapped to a small value and misframed the data that followed. All three header parsers (Decode, ReadFrom, AsyncReadFrom) now share Header::decode, which converts the size with usize::try_from and returns Error::TooLarge when it doesn't fit. Encode uses checked arithmetic for the header length so a huge size can't overflow either. Co-Authored-By: Claude Opus 5.5 --- src/header.rs | 139 +++++++++++++++++++++++++++++++++++--------- src/tokio/header.rs | 58 ++++++++++++------ 2 files changed, 151 insertions(+), 46 deletions(-) diff --git a/src/header.rs b/src/header.rs index a14be28c..320a2ba1 100644 --- a/src/header.rs +++ b/src/header.rs @@ -15,16 +15,19 @@ pub struct Header { impl Encode for Header { fn encode(&self, buf: &mut B) -> Result<()> { - match self.size.map(|size| size + 8) { - Some(size) if size > u32::MAX as usize => { + let too_large = || Error::TooLarge(self.kind); + + match self.size { + Some(size) if size > u32::MAX as usize - 8 => { 1u32.encode(buf)?; self.kind.encode(buf)?; // Have to include the size of this extra field - ((size + 8) as u64).encode(buf) + let size = size.checked_add(16).ok_or_else(too_large)?; + u64::try_from(size).map_err(|_| too_large())?.encode(buf) } Some(size) => { - (size as u32).encode(buf)?; + (size as u32 + 8).encode(buf)?; self.kind.encode(buf) } None => { @@ -42,12 +45,9 @@ impl Decode for Header { let size = match size { 0 => None, - 1 => { - // Read another 8 bytes - let size = u64::decode(buf)?; - Some(size.checked_sub(16).ok_or(Error::InvalidSize)? as usize) - } - _ => Some(size.checked_sub(8).ok_or(Error::InvalidSize)? as usize), + // The real size follows in another 8 bytes. + 1 => Some(body_size(kind, u64::decode(buf)?, 16)?), + _ => Some(body_size(kind, size.into(), 8)?), }; Ok(Self { kind, size }) @@ -77,34 +77,36 @@ impl ReadFrom for Header { impl ReadFrom for Option
{ fn read_from(r: &mut R) -> Result { - let mut buf = [0u8; 8]; - let n = r.read(&mut buf)?; + let mut buf = [0u8; 16]; + let n = r.read(&mut buf[..8])?; if n == 0 { return Ok(None); } - r.read_exact(&mut buf[n..])?; - - let size = u32::from_be_bytes(buf[0..4].try_into().unwrap()); - let kind = u32::from_be_bytes(buf[4..8].try_into().unwrap()).into(); + r.read_exact(&mut buf[n..8])?; - let size = match size { - 0 => None, - 1 => { - // Read another 8 bytes - r.read_exact(&mut buf)?; - let size = u64::from_be_bytes(buf); - let size = size.checked_sub(16).ok_or(Error::InvalidSize)?; + // A size of 1 means the real size follows in another 8 bytes. + let len = header_len(&buf); + r.read_exact(&mut buf[8..len])?; - Some(size as usize) - } - _ => Some(size.checked_sub(8).ok_or(Error::InvalidSize)? as usize), - }; + Header::decode(&mut &buf[..len]).map(Some) + } +} - Ok(Some(Header { kind, size })) +/// The length of a header, given its first 8 bytes. +pub(crate) fn header_len(buf: &[u8]) -> usize { + match buf[0..4] { + [0, 0, 0, 1] => 16, + _ => 8, } } +/// Convert the size of an atom, as stored in its header, into the size of its body. +fn body_size(kind: FourCC, size: u64, header_len: u64) -> Result { + let size = size.checked_sub(header_len).ok_or(Error::InvalidSize)?; + usize::try_from(size).map_err(|_| Error::TooLarge(kind)) +} + // Utility methods impl Header { pub(crate) fn read_body(&self, r: &mut R) -> Result>> { @@ -161,3 +163,84 @@ impl Header { Ok(Cursor::new(buf)) } } + +#[cfg(test)] +mod tests { + use super::*; + + const KIND: FourCC = FourCC::new(b"free"); + + #[test] + fn body_size_subtracts_header() { + assert_eq!(body_size(KIND, 8, 8).unwrap(), 0); + assert_eq!(body_size(KIND, 24, 16).unwrap(), 8); + assert!(matches!(body_size(KIND, 7, 8), Err(Error::InvalidSize))); + assert!(matches!(body_size(KIND, 15, 16), Err(Error::InvalidSize))); + } + + #[test] + #[cfg(target_pointer_width = "32")] + fn body_size_rejects_usize_overflow() { + let size = u32::MAX as u64 + 17; + assert!(matches!( + body_size(KIND, size, 16), + Err(Error::TooLarge(KIND)) + )); + } + + #[test] + fn decode_large_size() { + let mut buf: &[u8] = &[0, 0, 0, 1, b'f', b'r', b'e', b'e', 0, 0, 0, 0, 0, 0, 0, 24]; + let header = Header::decode(&mut buf).unwrap(); + assert_eq!(header.size, Some(8)); + + let mut buf: &[u8] = &[0, 0, 0, 1, b'f', b'r', b'e', b'e', 0, 0, 0, 0, 0, 0, 0, 15]; + assert!(matches!(Header::decode(&mut buf), Err(Error::InvalidSize))); + } + + #[test] + fn read_from_matches_decode() { + let cases: &[&[u8]] = &[ + &[0, 0, 0, 0, b'f', b'r', b'e', b'e'], + &[0, 0, 0, 16, b'f', b'r', b'e', b'e'], + &[0, 0, 0, 1, b'f', b'r', b'e', b'e', 0, 0, 0, 0, 0, 0, 0, 24], + ]; + + for case in cases { + let decoded = Header::decode(&mut &case[..]).unwrap(); + let read =
::read_from(&mut &case[..]).unwrap(); + assert_eq!(decoded.kind, read.kind); + assert_eq!(decoded.size, read.size); + } + + let empty: &[u8] = &[]; + assert!( as ReadFrom>::read_from(&mut &empty[..]) + .unwrap() + .is_none()); + } + + #[test] + fn encode_size_boundary() { + for size in [0, u32::MAX as usize - 8, u32::MAX as usize - 7] { + let header = Header { + kind: KIND, + size: Some(size), + }; + let mut buf = Vec::new(); + header.encode(&mut buf).unwrap(); + assert_eq!(Header::decode(&mut &buf[..]).unwrap().size, Some(size)); + } + } + + #[test] + fn encode_rejects_overflow() { + let header = Header { + kind: KIND, + size: Some(usize::MAX - 8), + }; + assert!(matches!( + header.encode(&mut Vec::new()), + Err(Error::TooLarge(KIND)) + )); + } +} diff --git a/src/tokio/header.rs b/src/tokio/header.rs index f0152d20..edd79e56 100644 --- a/src/tokio/header.rs +++ b/src/tokio/header.rs @@ -1,4 +1,4 @@ -use crate::{Error, Header, Result}; +use crate::{header::header_len, Decode, Error, Header, Result}; use super::*; @@ -14,30 +14,52 @@ impl AsyncReadFrom for Header { impl AsyncReadFrom for Option
{ async fn read_from(r: &mut R) -> Result { - let mut buf = [0u8; 8]; - let n = r.read(&mut buf).await?; + let mut buf = [0u8; 16]; + let n = r.read(&mut buf[..8]).await?; if n == 0 { return Ok(None); } - r.read_exact(&mut buf[n..]).await?; + r.read_exact(&mut buf[n..8]).await?; - let size = u32::from_be_bytes(buf[0..4].try_into().unwrap()); - let kind = u32::from_be_bytes(buf[4..8].try_into().unwrap()).into(); + // A size of 1 means the real size follows in another 8 bytes. + let len = header_len(&buf); + r.read_exact(&mut buf[8..len]).await?; - let size = match size { - 0 => None, - 1 => { - // Read another 8 bytes - r.read_exact(&mut buf).await?; - let size = u64::from_be_bytes(buf); - let size = size.checked_sub(16).ok_or(Error::InvalidSize)?; + Header::decode(&mut &buf[..len]).map(Some) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + use std::{future::Future, pin::pin, task::*}; + + // Reading from a slice never blocks, so a single poll completes the future. + fn read(mut buf: &[u8]) -> Result> { + let fut = pin!( as AsyncReadFrom>::read_from(&mut buf)); + match fut.poll(&mut Context::from_waker(Waker::noop())) { + Poll::Ready(res) => res, + Poll::Pending => unreachable!(), + } + } + + #[test] + fn read_from() { + assert!(read(&[]).unwrap().is_none()); + + let header = read(&[0, 0, 0, 16, b'f', b'r', b'e', b'e']) + .unwrap() + .unwrap(); + assert_eq!(header.size, Some(8)); - Some(size as usize) - } - _ => Some(size.checked_sub(8).ok_or(Error::InvalidSize)? as usize), - }; + let header = read(&[0, 0, 0, 1, b'f', b'r', b'e', b'e', 0, 0, 0, 0, 0, 0, 0, 24]) + .unwrap() + .unwrap(); + assert_eq!(header.size, Some(8)); - Ok(Some(Header { kind, size })) + let res = read(&[0, 0, 0, 1, b'f', b'r', b'e', b'e', 0, 0, 0, 0, 0, 0, 0, 15]); + assert!(matches!(res, Err(Error::InvalidSize))); } } From 0761b190555f19a3508bb7f0a490766e0265a964 Mon Sep 17 00:00:00 2001 From: Brad Hards Date: Fri, 13 Nov 2026 16:44:58 +1100 Subject: [PATCH 2/4] fix: minor rewowk on header encoding to make it a bit clearer --- src/header.rs | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/header.rs b/src/header.rs index 320a2ba1..995e673e 100644 --- a/src/header.rs +++ b/src/header.rs @@ -18,17 +18,18 @@ impl Encode for Header { let too_large = || Error::TooLarge(self.kind); match self.size { - Some(size) if size > u32::MAX as usize - 8 => { - 1u32.encode(buf)?; - self.kind.encode(buf)?; - - // Have to include the size of this extra field - let size = size.checked_add(16).ok_or_else(too_large)?; - u64::try_from(size).map_err(|_| too_large())?.encode(buf) - } Some(size) => { - (size as u32 + 8).encode(buf)?; - self.kind.encode(buf) + if size > u32::MAX as usize - 8 { + 1u32.encode(buf)?; + self.kind.encode(buf)?; + + // Have to include the size of this extra field + let size = size.checked_add(16).ok_or_else(too_large)?; + u64::try_from(size).map_err(|_| too_large())?.encode(buf) + } else { + (size as u32 + 8).encode(buf)?; + self.kind.encode(buf) + } } None => { 0u32.encode(buf)?; From 887c415faa61e719d40624bb487cf190b5a36d7c Mon Sep 17 00:00:00 2001 From: Brad Hards Date: Fri, 13 Nov 2026 17:24:12 +1100 Subject: [PATCH 3/4] chore: add spectulative 32-bit CI test --- .github/workflows/i686.yml | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 .github/workflows/i686.yml diff --git a/.github/workflows/i686.yml b/.github/workflows/i686.yml new file mode 100644 index 00000000..94115c1c --- /dev/null +++ b/.github/workflows/i686.yml @@ -0,0 +1,34 @@ +name: 32 bit + +on: + pull_request: + branches: ["main"] + +env: + CARGO_TERM_COLOR: always + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v7 + + # Install Just to run CI scripts + - uses: extractions/setup-just@v4 + + - name: Install 32-bit linker dependencies + run: | + sudo apt-get update + sudo apt-get install -y gcc-multilib + + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + with: + targets: i686-unknown-linux-gnu + + - name: Build + run: cargo build --release --target i686-unknown-linux-gnu + + - name: Run tests + run: cargo test --target i686-unknown-linux-gnu From 0f997b8532748a0571cfc73fcf8434b9a830325f Mon Sep 17 00:00:00 2001 From: Brad Hards Date: Fri, 13 Nov 2026 17:36:26 +1100 Subject: [PATCH 4/4] fix: update tests to (hopefully) handle 32 bit case better --- src/header.rs | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/src/header.rs b/src/header.rs index 995e673e..859d0162 100644 --- a/src/header.rs +++ b/src/header.rs @@ -222,7 +222,7 @@ mod tests { #[test] fn encode_size_boundary() { - for size in [0, u32::MAX as usize - 8, u32::MAX as usize - 7] { + for size in [0, u32::MAX as usize - 8] { let header = Header { kind: KIND, size: Some(size), @@ -234,10 +234,24 @@ mod tests { } #[test] + #[cfg(target_pointer_width = "32")] + fn encode_rejects_overflow() { + let header = Header { + kind: KIND, + size: Some((u32::MAX - 7) as usize), + }; + assert!(matches!( + header.encode(&mut Vec::new()), + Err(Error::TooLarge(KIND)) + )); + } + + #[test] + #[cfg(target_pointer_width = "64")] fn encode_rejects_overflow() { let header = Header { kind: KIND, - size: Some(usize::MAX - 8), + size: Some(usize::MAX - 15), }; assert!(matches!( header.encode(&mut Vec::new()),