Merge pull request #1596 from storytold/extract/tga-metadata-bounds

tga: reuse FilmCraft metadata boundaries before decoder cutover
This commit is contained in:
FredApps authored and GitHub committed 2026-11-16 02:19:13 +01:00
commit 6253fff31f
4 files changed
+594 -13

No files matched your search

+1
View File
@@ -101,4 +101,5 @@ and the exact transfer revision are recorded in each vendored crate's SOURCE.jso
`crates/plist` is extracted from `storytold/craft-anything` (`crates/formats/src/plist.rs` and checked byte reads), at source main `88d1d9cac852aec1c7fd97886db451e005e49d2a`. MIT OR Apache-2.0; source license texts are retained in the crate. Primary import Git authors preserve Brandon Thomas, BFlat, RRFZ and Afloat. Regression imports preserve BFlat. XML, JSON projection, calendar formatting and app policy were not imported into the public API.
`crates/tga/src/metadata_tests.rs` and metadata-boundary helpers in `crates/tga/src/lib.rs` are adapted from nuclearspike's FilmCraft #1932 at `e7842f76f887005c460c64a8ab51d59d086e6f27` (MIT OR Apache-2.0). Synthetic fixtures are original contributor test data; primary Git author retained.
The XML reader in `crates/plist/src/xml.rs` and its base64 compatibility helper are ported from Craft Anything `8f3b775157d331dd31cfa4da911e26d8856b8c77` (same MIT OR Apache-2.0 source licenses). Brandon Thomas is the primary import author; retained hardening credits include Afloat, BFlat, Rahul, RRFZ and NetterSilver. The finite-real fix preserves gmrmad1 as author from Craft Anything #1905 (`d85e104f`); quoted-attribute/line-ending regressions preserve RRFZ. Bounds/adaptation and bounded entity scanning are subsequent Dylan M. Taylor changes. App-specific JSON projections and keyed-archive interpretation remain outside this crate.
+134 -11
View File
@@ -21,6 +21,8 @@
/// Uncompressed RGBA8-to-Targa encoding.
pub mod rgba8_raw;
#[cfg(test)]
mod metadata_tests;
#[cfg(test)]
mod tests;
@@ -60,11 +62,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 }
}
}
@@ -183,6 +187,102 @@ impl Stored {
}
}
fn metadata_offset(body: &[u8], offset: usize, first_pixel: usize) -> Option<usize> {
// Optional metadata cannot replace the header, image ID, or colour map.
(offset >= first_pixel && offset < body.len()).then_some(offset)
}
/// The start of every developer-directory payload with a nonzero length, from the directory at
/// `directory` in `body` (none when that offset holds no readable directory).
fn developer_payload_starts(body: &[u8], directory: usize) -> Vec<usize> {
let Some(count) =
body.get(directory..directory.saturating_add(2)).and_then(|v| v.first_chunk::<2>()).map(|v| usize::from(u16::from_le_bytes(*v)))
else {
return Vec::new();
};
let Some(fields) = body.get(directory.saturating_add(2)..) else { return Vec::new() };
fields
.chunks(10)
.take(count)
.filter_map(|field| {
let start = field.get(2..6).and_then(|v| v.first_chunk::<4>()).map(|v| u32::from_le_bytes(*v) as usize)?;
let length = field.get(6..10).and_then(|v| v.first_chunk::<4>()).map(|v| u32::from_le_bytes(*v))?;
(length != 0).then_some(start)
})
.collect()
}
fn image_data_end(bytes: &[u8], first_pixel: usize) -> Result<usize> {
if !bytes.ends_with(SIGNATURE) {
return Ok(bytes.len());
}
// A TGA 2.0 footer cannot begin inside the mandatory header. A legacy image
// may end with the same signature as pixel bytes.
let Some(footer) = bytes.len().checked_sub(SIGNATURE.len() + 8).filter(|&at| at >= HEADER) else {
return Ok(bytes.len());
};
let offsets = bytes.get(footer..footer + 8).and_then(|b| b.first_chunk::<8>()).ok_or(Error::Malformed("truncated footer"))?;
let extension = offsets.first_chunk::<4>().map(|v| u32::from_le_bytes(*v) as usize).ok_or(Error::Malformed("truncated footer"))?;
let directory =
offsets.get(4..).and_then(|v| v.first_chunk::<4>()).map(|v| u32::from_le_bytes(*v) as usize).ok_or(Error::Malformed("truncated footer"))?;
let body = bytes.get(..footer).ok_or(Error::Malformed("truncated footer"))?;
let mut end = footer;
if let Some(offset) = metadata_offset(body, extension, first_pixel) {
// An in-body reference is a conservative image boundary, even if it overlaps
// required pixels. Those bytes cannot be distinguished from a truncated image
// whose missing pixels are supplied by metadata.
end = end.min(offset);
// TGA 2.0 extension fields at byte offsets 482, 486 and 490 point to the colour
// correction, postage-stamp and scan-line tables. The record's first two bytes give
// its size (495 in TGA 2.0); a shorter record has no such fields, and a record never
// reaches into a developer directory that follows it, so those bytes are not read as
// table offsets. Tables may precede the record.
let declared =
body.get(offset..offset.saturating_add(2)).and_then(|v| v.first_chunk::<2>()).map_or(0, |v| usize::from(u16::from_le_bytes(*v)));
let mut record_end = offset.saturating_add(declared.min(495));
// The developer directory and its payloads may sit anywhere after the pixels, a payload
// before its directory included; whichever starts first after the extension ends it.
// A directory offset of zero means there is none: the header is not read as one.
let payloads = metadata_offset(body, directory, first_pixel).map(|d| developer_payload_starts(body, d)).unwrap_or_default();
for next in std::iter::once(directory).chain(payloads) {
if next > offset {
record_end = record_end.min(next);
}
}
if let Some(area) = body.get(offset..record_end.min(body.len())) {
for field in [482, 486, 490] {
if let Some(value) = area.get(field..field + 4).and_then(|v| v.first_chunk::<4>())
&& let Some(table) = metadata_offset(body, u32::from_le_bytes(*value) as usize, first_pixel)
{
end = end.min(table);
}
}
}
}
if let Some(offset) = metadata_offset(body, directory, first_pixel) {
end = end.min(offset);
if let Some(count) =
body.get(offset..offset.saturating_add(2)).and_then(|v| v.first_chunk::<2>()).map(|v| usize::from(u16::from_le_bytes(*v)))
&& let Some(fields) = body.get(offset.saturating_add(2)..)
{
// A corrupt count or final entry does not hide earlier payload offsets. Each
// entry has a 2-byte tag followed by a 4-byte offset and 4-byte length.
for field in fields.chunks(10).take(count) {
if let Some(value) = field.get(2..6).and_then(|v| v.first_chunk::<4>())
&& let Some(length) = field.get(6..10).and_then(|v| v.first_chunk::<4>())
&& u32::from_le_bytes(*length) != 0
&& let Some(payload) = metadata_offset(body, u32::from_le_bytes(*value) as usize, first_pixel)
{
end = end.min(payload);
}
}
}
}
Ok(end)
}
/// Decodes a Targa file to straight-alpha RGBA8, top row first.
pub fn decode(bytes: &[u8], limits: &Limits) -> Result<Picture> {
let err = Error::Malformed;
@@ -211,13 +311,14 @@ pub fn decode(bytes: &[u8], limits: &Limits) -> Result<Picture> {
} else {
None
};
let mut at = HEADER + id_len;
if let Some(l) = map_entry {
let end = at + map_len * l.bytes();
let map = bytes.get(at..end).ok_or(err("truncated colour map"))?;
palette = map.chunks_exact(l.bytes()).map(|e| l.rgba(e)).collect();
at = end;
}
let map_start = HEADER + id_len;
let first_pixel = match map_entry {
Some(layout) => map_start.checked_add(map_len * layout.bytes()).ok_or(err("colour map"))?,
None => map_start,
};
let end = image_data_end(bytes, first_pixel)?;
let bytes = bytes.get(..end).ok_or(err("truncated image data"))?;
let at = first_pixel;
let (stored_as, mapped) = match kind & 7 {
1 => {
if map_type != 1 || !matches!(depth, 8 | 16) {
@@ -235,14 +336,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 };
@@ -286,7 +408,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;
+425
View File
@@ -0,0 +1,425 @@
//! Metadata-boundary regressions ported from FilmCraft #1932 (nuclearspike).
use super::*;
fn header(kind: u8, w: u16, h: u16, depth: u8, descriptor: u8) -> Vec<u8> {
let mut b = vec![0, 0, kind, 0, 0, 0, 0, 0, 0, 0, 0, 0];
b.extend_from_slice(&w.to_le_bytes());
b.extend_from_slice(&h.to_le_bytes());
b.extend_from_slice(&[depth, descriptor]);
b
}
fn dec(bytes: &[u8]) -> Result<Picture> {
decode(bytes, &Limits::default())
}
#[test]
fn legacy_pixels_that_end_in_signature_are_not_a_footer_before_header() {
for prefix in [0usize, 7] {
let width = (prefix + SIGNATURE.len()) as u16;
let mut file = header(3, width, 1, 8, 0x20);
file.extend(vec![0; prefix]);
file.extend_from_slice(SIGNATURE);
let image = dec(&file).unwrap();
assert_eq!((image.width, image.height), (u32::from(width), 1));
let pixels: Vec<u8> = std::iter::repeat_n(0, prefix).chain(SIGNATURE.iter().copied()).flat_map(|gray| [gray, gray, gray, 255]).collect();
assert_eq!(image.rgba, pixels);
let source = dec(&file).unwrap();
assert_eq!(source.rgba, pixels);
}
}
#[test]
fn short_extension_followed_by_a_developer_payload_keeps_the_pixels() {
// a 482-byte extension whose size field still says 495, then a developer payload whose
// first bytes land where a full extension keeps its colour-correction offset, then the
// directory that points back at that payload
let mut file = header(2, 1, 1, 24, 0x20);
file.extend_from_slice(&[10, 20, 30]);
let extension = file.len() as u32;
let mut area = vec![0; 482];
area[..2].copy_from_slice(&495u16.to_le_bytes());
file.extend_from_slice(&area);
let payload = file.len() as u32;
file.extend_from_slice(&18u32.to_le_bytes());
file.extend_from_slice(&[0; 14]);
let directory = file.len() as u32;
file.extend_from_slice(&1u16.to_le_bytes());
file.extend_from_slice(&0u16.to_le_bytes());
file.extend_from_slice(&payload.to_le_bytes());
file.extend_from_slice(&18u32.to_le_bytes());
file.extend_from_slice(&extension.to_le_bytes());
file.extend_from_slice(&directory.to_le_bytes());
file.extend_from_slice(SIGNATURE);
let source = dec(&file).expect("the image decodes");
assert_eq!((source.width, source.height), (1, 1));
assert_eq!(source.rgba, vec![30, 20, 10, 255]);
}
#[test]
fn a_footer_without_a_directory_does_not_read_the_header_as_one() {
// no developer directory (offset 0). Read as one, the header's three-byte image ID
// length is an entry count, and the third "entry" is the first words of a colour
// correction table that sits right after a short pixel area; the extension points at
// that table, so the image is incomplete and must stay so.
let mut file = header(2, 2, 1, 24, 0x20);
file[0] = 3;
file.extend_from_slice(&[7, 8, 9]);
file.extend_from_slice(&[0, 0, 255]);
let table = file.len() as u32;
let mut words = vec![0; 2048];
words[..4].copy_from_slice(&2074u32.to_le_bytes());
words[4..8].copy_from_slice(&1u32.to_le_bytes());
file.extend_from_slice(&words);
let extension = file.len() as u32;
let mut area = vec![0; 495];
area[..2].copy_from_slice(&495u16.to_le_bytes());
area[482..486].copy_from_slice(&table.to_le_bytes());
file.extend_from_slice(&area);
file.extend_from_slice(&extension.to_le_bytes());
file.extend_from_slice(&0u32.to_le_bytes());
file.extend_from_slice(SIGNATURE);
let decoded = dec(&file);
assert!(decoded.is_err(), "the second pixel is missing");
}
#[test]
fn short_extension_followed_by_a_developer_directory_keeps_the_pixels() {
// a complete 1x1 image, a 482-byte extension (its size says so) and right after it a
// developer directory whose entry's length lands where a full extension keeps its
// scan-line table offset; reading it as one would move the image end into the header
let mut file = header(2, 1, 1, 24, 0x20);
file.extend_from_slice(&[10, 20, 30]);
let extension = file.len() as u32;
let mut area = vec![0; 482];
area[..2].copy_from_slice(&482u16.to_le_bytes());
file.extend_from_slice(&area);
let directory = file.len() as u32;
let payload = directory + 2 + 10;
file.extend_from_slice(&1u16.to_le_bytes());
file.extend_from_slice(&0u16.to_le_bytes());
file.extend_from_slice(&payload.to_le_bytes());
file.extend_from_slice(&18u32.to_le_bytes());
file.extend_from_slice(&[0; 18]);
file.extend_from_slice(&extension.to_le_bytes());
file.extend_from_slice(&directory.to_le_bytes());
file.extend_from_slice(SIGNATURE);
let source = dec(&file).expect("the image decodes");
assert_eq!((source.width, source.height), (1, 1));
}
#[test]
fn importing_truncated_pixels_does_not_consume_tga_footer() {
for (kind, data) in [(2, vec![0, 0, 255]), (10, vec![0x80, 0, 0, 255])] {
for metadata in [None, Some(0usize), Some(1)] {
let mut file = header(kind, 2, 1, 24, 0x20);
file.extend_from_slice(&data); // only the first of two pixels
let mut offsets = [0u8; 8];
if let Some(field) = metadata {
let offset = file.len() as u32;
offsets[field * 4..field * 4 + 4].copy_from_slice(&offset.to_le_bytes());
let mut area = vec![0; 495];
if field == 0 {
area[..2].copy_from_slice(&495u16.to_le_bytes());
}
file.extend_from_slice(&area); // optional metadata is not pixel data
}
file.extend_from_slice(&offsets);
file.extend_from_slice(SIGNATURE);
let result = dec(&file);
assert!(result.is_err(), "kind {kind}, metadata {metadata:?}: metadata is not a second pixel");
}
}
for kind in [1, 9] {
let mut file = header(kind, 1, 1, 8, 0x20);
file[1] = 1;
file[5] = 1;
file[7] = 24;
file.extend_from_slice(&[0, 0]); // missing third palette byte and the index
file.extend_from_slice(&[0; 8]);
file.extend_from_slice(SIGNATURE);
let result = dec(&file);
assert!(result.is_err(), "kind {kind}: the footer is not colour-map data");
}
}
#[test]
fn complete_tga_footer_and_metadata_do_not_change_pixels() {
for metadata in [None, Some(0usize), Some(1)] {
let mut file = header(2, 1, 1, 24, 0x20);
file.extend_from_slice(&[0, 0, 255]);
let mut offsets = [0u8; 8];
if let Some(field) = metadata {
let offset = file.len() as u32;
offsets[field * 4..field * 4 + 4].copy_from_slice(&offset.to_le_bytes());
let mut area = vec![0; 495];
if field == 0 {
area[..2].copy_from_slice(&495u16.to_le_bytes());
}
file.extend_from_slice(&area);
}
file.extend_from_slice(&offsets);
file.extend_from_slice(SIGNATURE);
let source = dec(&file).unwrap();
assert_eq!(source.rgba, [255, 0, 0, 255]);
}
}
fn preceding_metadata(complete: bool, metadata: usize) -> Vec<u8> {
assert!(metadata <= 3, "test metadata selector must be 0..=3");
let mut file = header(2, if complete { 1 } else { 2 }, 1, 24, 0x20);
file.extend_from_slice(&[0, 0, 255]);
let payload_offset = file.len() as u32;
let mut offsets = [0u8; 8];
if metadata == 0 {
file.extend_from_slice(&[0, 255, 0]);
let directory_offset = file.len() as u32;
file.extend_from_slice(&1u16.to_le_bytes());
file.extend_from_slice(&1u16.to_le_bytes());
file.extend_from_slice(&payload_offset.to_le_bytes());
file.extend_from_slice(&3u32.to_le_bytes());
offsets[4..].copy_from_slice(&directory_offset.to_le_bytes());
} else {
match metadata {
1 => file.extend_from_slice(&[0; 2048]),
2 => file.extend_from_slice(&[1, 1, 0, 255, 0]),
3 => file.extend_from_slice(&18u32.to_le_bytes()),
_ => {}
}
let extension_offset = file.len() as u32;
let mut extension = [0; 495];
extension[..2].copy_from_slice(&495u16.to_le_bytes());
let field = [0, 482, 486, 490][metadata];
extension[field..field + 4].copy_from_slice(&payload_offset.to_le_bytes());
file.extend_from_slice(&extension);
offsets[..4].copy_from_slice(&extension_offset.to_le_bytes());
}
file.extend_from_slice(&offsets);
file.extend_from_slice(SIGNATURE);
file
}
#[test]
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 result.is_ok() {
accepted.push(metadata);
}
}
assert!(accepted.is_empty(), "metadata payloads supplied missing pixels: {accepted:?}");
}
#[test]
fn complete_pixels_before_metadata_keep_their_colour() {
for metadata in 0..4 {
let source = dec(&preceding_metadata(true, metadata)).unwrap();
assert_eq!(source.rgba, [255, 0, 0, 255], "metadata {metadata}");
}
let mut file = preceding_metadata(true, 1);
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(&496u16.to_le_bytes());
file.insert(footer, 0);
let source = dec(&file).unwrap();
assert_eq!(source.rgba, [255, 0, 0, 255], "larger complete extensions preserve pixels");
}
#[test]
fn malformed_optional_metadata_keeps_complete_pixels_readable() {
let accept = |file: Vec<u8>| {
let source = dec(&file).unwrap();
assert_eq!(source.rgba, [255, 0, 0, 255]);
};
for field in [0, 4] {
let mut file = preceding_metadata(true, 0);
let footer = file.len() - SIGNATURE.len() - 8;
file[footer + field..footer + field + 4].copy_from_slice(&u32::MAX.to_le_bytes());
accept(file);
}
for metadata in 1..4 {
let mut file = preceding_metadata(true, metadata);
let footer = file.len() - SIGNATURE.len() - 8;
let extension = u32::from_le_bytes(file[footer..footer + 4].try_into().unwrap()) as usize;
let field = [0, 482, 486, 490][metadata];
file[extension + field..extension + field + 4].copy_from_slice(&u32::MAX.to_le_bytes());
accept(file);
}
let mut file = preceding_metadata(true, 0);
let footer = file.len() - SIGNATURE.len() - 8;
let directory = u32::from_le_bytes(file[footer + 4..footer + 8].try_into().unwrap()) as usize;
file.drain(directory + 2..footer);
accept(file);
let mut file = preceding_metadata(true, 0);
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());
accept(file);
let mut file = preceding_metadata(true, 0);
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());
accept(file);
// A zero-length entry cannot mark a payload boundary, even if its offset overlaps pixels.
let mut file = preceding_metadata(true, 0);
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 + 4..directory + 8].copy_from_slice(&19u32.to_le_bytes());
file[directory + 8..directory + 12].copy_from_slice(&0u32.to_le_bytes());
accept(file);
let mut file = preceding_metadata(true, 2);
file[21..23].copy_from_slice(&[255, 255]);
accept(file);
let mut file = preceding_metadata(true, 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());
accept(file);
let mut file = preceding_metadata(true, 2);
let footer = file.len() - SIGNATURE.len() - 8;
file.remove(footer - 1); // extension is physically short, but its postage offset remains
accept(file);
}
#[test]
fn malformed_metadata_offsets_inside_id_or_palette_keep_complete_pixels() {
let mut file = header(1, 1, 1, 8, 0x20);
file[0] = 4; // image ID length
file[1] = 1; // colour map present
file[5..7].copy_from_slice(&1u16.to_le_bytes());
file[7] = 24; // one BGR palette entry
file.extend_from_slice(&[7, 8, 9, 10]); // image ID
file.extend_from_slice(&[0, 0, 255]); // red palette entry
file.push(0); // palette index
for (field, offset) in [(0, HEADER + 1), (4, HEADER + 4 + 1)] {
let mut candidate = file.clone();
let mut footer_offsets = [0u8; 8];
footer_offsets[field..field + 4].copy_from_slice(&(offset as u32).to_le_bytes());
candidate.extend_from_slice(&footer_offsets);
candidate.extend_from_slice(SIGNATURE);
let image = dec(&candidate).unwrap();
assert_eq!(image.rgba, [255, 0, 0, 255], "footer field {field}");
}
}
#[test]
fn malformed_optional_metadata_cannot_supply_missing_pixels() {
let mut file = preceding_metadata(false, 0);
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!(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.
let mut file = preceding_metadata(false, 0);
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!(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!(dec(&file).is_err());
let mut file = preceding_metadata(false, 2);
let footer = file.len() - SIGNATURE.len() - 8;
file.remove(footer - 1);
assert!(dec(&file).is_err());
}
#[test]
fn valid_developer_directory_with_overlapping_payload_rejects_pixels() {
let mut file = preceding_metadata(true, 0);
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());
let mut extra = [0u8; 10];
extra[..2].copy_from_slice(&2u16.to_le_bytes());
extra[2..6].copy_from_slice(&(HEADER as u32).to_le_bytes());
extra[6..10].copy_from_slice(&1u32.to_le_bytes());
file.splice(footer..footer, extra);
let moved_footer = file.len() - SIGNATURE.len() - 8;
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!(dec(&file).is_err());
}
#[test]
fn nonempty_developer_reference_inside_pixels_rejects_the_whole_image() {
let mut file = header(2, 2, 1, 24, 0x20);
file.extend_from_slice(&[0, 0, 255, 0, 255, 0]);
let directory = file.len() as u32;
file.extend_from_slice(&1u16.to_le_bytes());
file.extend_from_slice(&1u16.to_le_bytes());
file.extend_from_slice(&(HEADER as u32 + 3).to_le_bytes());
file.extend_from_slice(&1u32.to_le_bytes());
file.extend_from_slice(&0u32.to_le_bytes());
file.extend_from_slice(&directory.to_le_bytes());
file.extend_from_slice(SIGNATURE);
assert!(dec(&file).is_err(), "an overlapping reference must not return a partial image");
}
#[test]
fn inflated_developer_count_scans_the_next_chunk_as_an_entry_and_rejects_its_pixel_payload() {
// a directory claiming two entries over one real entry: the ten bytes after it, scanned as
// the second entry, name a payload inside the pixels, which is refused like any other
let mut file = header(2, 2, 1, 24, 0x20);
file.extend_from_slice(&[0, 0, 255, 0, 255, 0]);
let directory = file.len() as u32;
file.extend_from_slice(&2u16.to_le_bytes());
file.extend_from_slice(&1u16.to_le_bytes());
file.extend_from_slice(&(directory + 22).to_le_bytes());
file.extend_from_slice(&0u32.to_le_bytes());
file.extend_from_slice(&2u16.to_le_bytes());
file.extend_from_slice(&(HEADER as u32 + 3).to_le_bytes());
file.extend_from_slice(&1u32.to_le_bytes());
file.extend_from_slice(&0u32.to_le_bytes());
file.extend_from_slice(&directory.to_le_bytes());
file.extend_from_slice(SIGNATURE);
assert!(dec(&file).is_err(), "a scanned entry's payload inside the pixels is refused");
}
#[test]
fn legacy_pixels_that_end_in_signature_at_or_after_the_header_are_read_as_a_footer() {
// a footerless 36×1 grayscale image whose last 26 bytes happen to be eight zeros and the
// signature: the putative trailer begins at byte 28, so it is taken for a footer and the
// image, left with 10 pixel bytes, is rejected as truncated (the ambiguity the body states)
let prefix = 18usize;
let width = (prefix + SIGNATURE.len()) as u16;
let mut file = header(3, width, 1, 8, 0x20);
file.extend(vec![0; prefix]);
file.extend_from_slice(SIGNATURE);
assert!(dec(&file).is_err());
}
#[test]
fn mutated_tga_footer_files_never_panic() {
let mut file = header(2, 2, 1, 24, 0x20);
file.extend_from_slice(&[0, 0, 255, 0, 255, 0]);
file.extend_from_slice(&[0; 8]);
file.extend_from_slice(SIGNATURE);
for end in 0..file.len() {
assert!(std::panic::catch_unwind(|| dec(&file[..end])).is_ok(), "truncation at {end}");
}
for at in 0..file.len() {
let mut mutated = file.clone();
mutated[at] ^= 0xFF;
assert!(std::panic::catch_unwind(|| dec(&mutated)).is_ok(), "mutation at {at}");
}
for metadata in 0..4 {
let file = preceding_metadata(true, metadata);
assert!(dec(&file).is_ok());
let footer = file.len() - SIGNATURE.len() - 8;
for end in 0..footer {
let mut truncated = file[..end].to_vec();
truncated.extend_from_slice(&file[footer..]);
assert!(std::panic::catch_unwind(|| dec(&truncated)).is_ok(), "metadata {metadata}, footer-preserving truncation at {end}");
}
for at in 0..file.len() {
let mut mutated = file.clone();
mutated[at] ^= 0xFF;
assert!(std::panic::catch_unwind(|| dec(&mutated)).is_ok(), "metadata {metadata}, mutation at {at}");
}
}
}
+34 -2
View File
@@ -92,6 +92,11 @@ fn hostile_headers_fail_without_allocating() {
assert_eq!(dec(&f), Err(Error::LimitExceeded("pixel count")));
let mut f = header(10, 16384, 16384, 32, 0);
f.extend_from_slice(&[0xFF, 1, 2, 3, 4]);
// The aggregate decoded-storage budget rejects this before any allocation.
assert_eq!(dec(&f), Err(Error::LimitExceeded("decode allocation bytes")));
// Under budget, an incomplete RLE stream must still fail as truncated.
let mut f = header(10, 16, 16, 32, 0);
f.extend_from_slice(&[0xFF, 1, 2, 3, 4]); // only 128 of 256 pixels
assert_eq!(dec(&f), Err(Error::Malformed("truncated run-length data")));
let mut f = header(2, 4, 4, 24, 0);
f.extend_from_slice(&[0; 10]);
@@ -116,8 +121,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 +240,30 @@ 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 { max_decoded_bytes: 2047, ..Limits::default() };
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 { max_decoded_bytes: 8, ..Limits::default() };
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]);
}