diff --git a/.github/workflows/i686.yml b/.github/workflows/i686.yml new file mode 100644 index 0000000..94115c1 --- /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 diff --git a/src/header.rs b/src/header.rs index a14be28..859d016 100644 --- a/src/header.rs +++ b/src/header.rs @@ -15,17 +15,21 @@ 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 => { - 1u32.encode(buf)?; - self.kind.encode(buf)?; + let too_large = || Error::TooLarge(self.kind); - // Have to include the size of this extra field - ((size + 8) as u64).encode(buf) - } + match self.size { Some(size) => { - (size as u32).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)?; @@ -42,12 +46,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 +78,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..])?; + r.read_exact(&mut buf[n..8])?; - 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])?; - 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)?; - - 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 +164,98 @@ 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] { + 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] + #[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 - 15), + }; + assert!(matches!( + header.encode(&mut Vec::new()), + Err(Error::TooLarge(KIND)) + )); + } +} diff --git a/src/tokio/header.rs b/src/tokio/header.rs index f0152d2..edd79e5 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))); } }