fix(tga): bound aggregate decoder storage and reserve fallibly

This commit is contained in:
Dylan M. Taylor committed 2026-11-15 10:14:40 -05:00
1 parent e555cc0afe
commit d2bb64c4ac
3 files changed
+70 -21

No files matched your search

+28 -8
View File
@@ -59,11 +59,13 @@ pub type Result<T> = std::result::Result<T, Error>;
pub struct Limits {
/// Most pixels (width × height) a picture may have. Default 2^28 (16384 × 16384).
pub max_pixels: u64,
/// Maximum combined palette, stored-pixel and RGBA allocation bytes. Default 256 MiB.
pub max_decoded_bytes: usize,
}
impl Default for Limits {
fn default() -> Self {
Self { max_pixels: 1 << 28 }
Self { max_pixels: 1 << 28, max_decoded_bytes: 256 << 20 }
}
}
@@ -313,10 +315,6 @@ pub fn decode(bytes: &[u8], limits: &Limits) -> Result<Picture> {
};
let end = image_data_end(bytes, first_pixel)?;
let bytes = bytes.get(..end).ok_or(err("truncated image data"))?;
if let Some(layout) = map_entry {
let map = bytes.get(map_start..first_pixel).ok_or(err("truncated colour map"))?;
palette = map.chunks_exact(layout.bytes()).map(|entry| layout.rgba(entry)).collect();
}
let at = first_pixel;
let (stored_as, mapped) = match kind & 7 {
1 => {
@@ -335,14 +333,35 @@ pub fn decode(bytes: &[u8], limits: &Limits) -> Result<Picture> {
};
let data = bytes.get(at..).unwrap_or_default();
let bpp = stored_as.bytes();
let stored_bytes = pixels.checked_mul(bpp).ok_or(Error::LimitExceeded("image size"))?;
let rgba_bytes = pixels.checked_mul(4).ok_or(Error::LimitExceeded("image size"))?;
let palette_bytes = if map_entry.is_some() { map_len * 4 } else { 0 };
let aggregate =
stored_bytes.checked_add(rgba_bytes).and_then(|n| n.checked_add(palette_bytes)).ok_or(Error::LimitExceeded("decode allocation bytes"))?;
if aggregate > limits.max_decoded_bytes {
return Err(Error::LimitExceeded("decode allocation bytes"));
}
if let Some(layout) = map_entry {
let map = bytes.get(map_start..first_pixel).ok_or(err("truncated colour map"))?;
palette.try_reserve_exact(map_len).map_err(|_| Error::LimitExceeded("allocation failed"))?;
palette.extend(map.chunks_exact(layout.bytes()).map(|entry| layout.rgba(entry)));
}
// The stored values, in file order.
let stored: Vec<u8> = if rle {
unpack_rle(data, pixels, bpp)?
} else {
let n = pixels.checked_mul(bpp).ok_or(Error::LimitExceeded("image size"))?;
data.get(..n).ok_or(err("truncated pixel data"))?.to_vec()
{
let source = data.get(..n).ok_or(err("truncated pixel data"))?;
let mut values = Vec::new();
values.try_reserve_exact(n).map_err(|_| Error::LimitExceeded("allocation failed"))?;
values.extend_from_slice(source);
values
}
};
let mut rgba = vec![0u8; pixels.checked_mul(4).ok_or(Error::LimitExceeded("image size"))?];
let mut rgba = Vec::new();
rgba.try_reserve_exact(rgba_bytes).map_err(|_| Error::LimitExceeded("allocation failed"))?;
rgba.resize(rgba_bytes, 0u8);
for (i, v) in stored.chunks_exact(bpp).enumerate().take(pixels) {
let (x, y) = (i % w, i / w);
let x = if right_to_left { w - 1 - x } else { x };
@@ -386,7 +405,8 @@ fn unpack_rle(mut data: &[u8], pixels: usize, bpp: usize) -> Result<Vec<u8>> {
return Err(short);
}
let total = pixels.checked_mul(bpp).ok_or(Error::LimitExceeded("image size"))?;
let mut out = Vec::with_capacity(total);
let mut out = Vec::new();
out.try_reserve_exact(total).map_err(|_| Error::LimitExceeded("allocation failed"))?;
while out.len() < total {
let (&head, rest) = data.split_first().ok_or(short.clone())?;
let count = usize::from(head & 0x7F) + 1;
+11 -11
View File
@@ -124,7 +124,7 @@ fn importing_truncated_pixels_does_not_consume_tga_footer() {
file.extend_from_slice(&offsets);
file.extend_from_slice(SIGNATURE);
let result = dec(&file);
assert!(matches!(result, Err(_)), "kind {kind}, metadata {metadata:?}: metadata is not a second pixel");
assert!(result.is_err(), "kind {kind}, metadata {metadata:?}: metadata is not a second pixel");
}
}
for kind in [1, 9] {
@@ -136,7 +136,7 @@ fn importing_truncated_pixels_does_not_consume_tga_footer() {
file.extend_from_slice(&[0; 8]);
file.extend_from_slice(SIGNATURE);
let result = dec(&file);
assert!(matches!(result, Err(_)), "kind {kind}: the footer is not colour-map data");
assert!(result.is_err(), "kind {kind}: the footer is not colour-map data");
}
}
@@ -200,7 +200,7 @@ fn preceding_metadata_cannot_supply_missing_pixels() {
let mut accepted = Vec::new();
for metadata in 0..4 {
let result = dec(&preceding_metadata(false, metadata));
if !matches!(result, Err(_)) {
if result.is_ok() {
accepted.push(metadata);
}
}
@@ -305,7 +305,7 @@ fn malformed_optional_metadata_cannot_supply_missing_pixels() {
let footer = file.len() - SIGNATURE.len() - 8;
let directory = u32::from_le_bytes(file[footer + 4..footer + 8].try_into().unwrap()) as usize;
file[directory + 8..directory + 12].copy_from_slice(&u32::MAX.to_le_bytes());
assert!(matches!(dec(&file), Err(_)));
assert!(dec(&file).is_err());
// The declared entry count exceeds the bytes before the footer, but the first entry's
// payload still precedes the directory and cannot be used as a second pixel.
@@ -313,17 +313,17 @@ fn malformed_optional_metadata_cannot_supply_missing_pixels() {
let footer = file.len() - SIGNATURE.len() - 8;
let directory = u32::from_le_bytes(file[footer + 4..footer + 8].try_into().unwrap()) as usize;
file[directory..directory + 2].copy_from_slice(&2u16.to_le_bytes());
assert!(matches!(dec(&file), Err(_)));
assert!(dec(&file).is_err());
let mut file = preceding_metadata(false, 2);
let footer = file.len() - SIGNATURE.len() - 8;
let extension = u32::from_le_bytes(file[footer..footer + 4].try_into().unwrap()) as usize;
file[extension..extension + 2].copy_from_slice(&494u16.to_le_bytes());
assert!(matches!(dec(&file), Err(_)));
assert!(dec(&file).is_err());
let mut file = preceding_metadata(false, 2);
let footer = file.len() - SIGNATURE.len() - 8;
file.remove(footer - 1);
assert!(matches!(dec(&file), Err(_)));
assert!(dec(&file).is_err());
}
#[test]
@@ -341,7 +341,7 @@ fn valid_developer_directory_with_overlapping_payload_rejects_pixels() {
assert_eq!(u32::from_le_bytes(file[moved_footer + 4..moved_footer + 8].try_into().unwrap()), directory as u32);
assert_eq!(u16::from_le_bytes(file[directory..directory + 2].try_into().unwrap()), 2);
assert_eq!(&file[directory + 12..directory + 22], &extra);
assert!(matches!(dec(&file), Err(_)));
assert!(dec(&file).is_err());
}
#[test]
@@ -356,7 +356,7 @@ fn nonempty_developer_reference_inside_pixels_rejects_the_whole_image() {
file.extend_from_slice(&0u32.to_le_bytes());
file.extend_from_slice(&directory.to_le_bytes());
file.extend_from_slice(SIGNATURE);
assert!(matches!(dec(&file), Err(_)), "an overlapping reference must not return a partial image");
assert!(dec(&file).is_err(), "an overlapping reference must not return a partial image");
}
#[test]
@@ -376,7 +376,7 @@ fn inflated_developer_count_scans_the_next_chunk_as_an_entry_and_rejects_its_pix
file.extend_from_slice(&0u32.to_le_bytes());
file.extend_from_slice(&directory.to_le_bytes());
file.extend_from_slice(SIGNATURE);
assert!(matches!(dec(&file), Err(_)), "a scanned entry's payload inside the pixels is refused");
assert!(dec(&file).is_err(), "a scanned entry's payload inside the pixels is refused");
}
#[test]
@@ -389,7 +389,7 @@ fn legacy_pixels_that_end_in_signature_at_or_after_the_header_are_read_as_a_foot
let mut file = header(3, width, 1, 8, 0x20);
file.extend(vec![0; prefix]);
file.extend_from_slice(SIGNATURE);
assert!(matches!(dec(&file), Err(_)));
assert!(dec(&file).is_err());
}
#[test]
+31 -2
View File
@@ -116,8 +116,8 @@ fn hostile_headers_fail_without_allocating() {
fn the_pixel_limit_is_checked() {
let mut f = header(3, 2, 2, 8, 0);
f.extend_from_slice(&[0; 4]);
assert!(decode(&f, &Limits { max_pixels: 4 }).is_ok());
assert_eq!(decode(&f, &Limits { max_pixels: 3 }), Err(Error::LimitExceeded("pixel count")));
assert!(decode(&f, &Limits { max_pixels: 4, ..Limits::default() }).is_ok());
assert_eq!(decode(&f, &Limits { max_pixels: 3, ..Limits::default() }), Err(Error::LimitExceeded("pixel count")));
}
#[test]
@@ -235,3 +235,32 @@ fn written_files_read_back() {
assert_eq!(r.rgba, want, "{layout:?}");
}
}
#[test]
fn aggregate_decode_budget_applies_before_rle_expansion() {
let mut file = header(10, 16, 16, 32, 0x28);
file.extend_from_slice(&[255, 0, 0, 255, 255, 255, 0, 0, 255, 255]);
let mut limits = Limits::default();
limits.max_decoded_bytes = 2047;
assert_eq!(decode(&file, &limits), Err(Error::LimitExceeded("decode allocation bytes")));
limits.max_decoded_bytes = 2048;
assert_eq!(decode(&file, &limits).unwrap().rgba.len(), 1024);
}
#[test]
fn default_budget_rejects_large_rle_header_without_large_fixture() {
let file = header(10, 16384, 16384, 32, 0x28);
assert_eq!(decode(&file, &Limits::default()), Err(Error::LimitExceeded("decode allocation bytes")));
}
#[test]
fn aggregate_decode_budget_counts_raw_and_palette_storage() {
let mut file = header(1, 1, 1, 8, 0x20);
file[1] = 1;
file[5] = 1;
file[7] = 24;
file.extend_from_slice(&[0, 0, 255, 0]);
let mut limits = Limits::default();
limits.max_decoded_bytes = 8;
assert_eq!(decode(&file, &limits), Err(Error::LimitExceeded("decode allocation bytes")));
limits.max_decoded_bytes = 9;
assert_eq!(decode(&file, &limits).unwrap().rgba, [255, 0, 0, 255]);
}