Skip to content

LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust

tiff: bound total entries across a parse (#2136)

eliets2555eb4c9fd28
diff --git a/crates/tiff/src/reader.rs b/crates/tiff/src/reader.rs
index 5f38dfad2..bd728ca9c 100644
--- a/crates/tiff/src/reader.rs
+++ b/crates/tiff/src/reader.rs
@@ -12,6 +12,15 @@ pub struct ParseOptions {
pub max_depth: usize,
/// Maximum number of entries read from one IFD.
pub max_entries: usize,
+ /// Maximum total number of entries read across all IFDs (chain + children).
+ ///
+ /// Hostile files can reuse the same bytes for up to `max_ifds` tables of `max_entries`
+ /// entries each (overlapping IFD tables via SubIFD pointers shifted by one entry), which can
+ /// allocate millions of `Entry`s from a small input (~100 KB → ~400 MB). This hard cap bounds
+ /// that amplification regardless of entry size. 65 536 is generous for real files — a 50 MB
+ /// scanned TIFF with thousands of entries across chain + children stays well under it — yet
+ /// stops a small file from allocating hundreds of megabytes of `Entry`s.
+ pub max_entries_total: usize,
/// Maximum total bytes of decoded values; `None` = `8 × input length + 1 MiB`.
pub value_budget: Option<u64>,
/// Follow `SubIFDs` / Exif / GPS / Interop pointers.
@@ -22,7 +31,15 @@ pub struct ParseOptions {
impl Default for ParseOptions {
fn default() -> Self {
- Self { max_ifds: 1024, max_depth: 10, max_entries: 8192, value_budget: None, follow_children: true, accept_raw_magic: true }
+ Self {
+ max_ifds: 1024,
+ max_depth: 10,
+ max_entries: 8192,
+ max_entries_total: 65536,
+ value_budget: None,
+ follow_children: true,
+ accept_raw_magic: true,
+ }
}
}
@@ -195,12 +212,13 @@ struct Ctx<'a> {
opts: &'a ParseOptions,
visited: HashSet<u64>,
budget: u64,
+ entries_total: usize,
}
impl<'a> Ctx<'a> {
fn new(data: &'a [u8], order: ByteOrder, big: bool, opts: &'a ParseOptions) -> Self {
let budget = opts.budget_for(data.len());
- Self { data, order, big, opts, visited: HashSet::new(), budget }
+ Self { data, order, big, opts, visited: HashSet::new(), budget, entries_total: 0 }
}
fn read_off(&self, pos: usize) -> Option<u64> {
@@ -219,6 +237,12 @@ impl<'a> Ctx<'a> {
return Err(TiffError::Invalid(format!("IFD loop at {offset}")));
}
let dir = directory_entries(self.data, offset, self.order, self.big, self.opts.max_entries)?;
+ // Bound total entries across the whole parse so overlapping IFD tables (SubIFD pointers
+ // shifted by one entry) cannot allocate millions of `Entry`s from a small input.
+ self.entries_total = self.entries_total.saturating_add(dir.read);
+ if self.entries_total > self.opts.max_entries_total {
+ return Err(TiffError::Limit("entry count"));
+ }
let mut entries = Vec::with_capacity(dir.read);
for p in dir.positions() {
if let Some(e) = self.entry(p, base) {
@@ -405,4 +429,89 @@ mod tests {
assert_eq!(tiff.ifds.len(), 1);
assert_eq!(tiff.ifds[0].u64(0x0100), Some(8));
}
+ #[test]
+ fn overlapping_ifd_tables_hit_entry_cap_instead_of_amplifying() {
+ // classic TIFF; IFDs at 8, 20, 32, ... each declaring 8192 entries whose tables overlap
+ // (next table starts one entry after the previous table's start). Without the cap, a single
+ // `Tiff::parse` would run `Vec::with_capacity(8192)` per IFD inside one `Ctx`, amplifying a
+ // small file into millions of `Entry`s; the per-`Ctx` `max_entries_total` cap rejects the
+ // 9th IFD before any allocation.
+ let mut data = vec![0u8; 200_000];
+ data[0..2].copy_from_slice(b"II");
+ data[2..4].copy_from_slice(&42u16.to_le_bytes());
+ data[4..8].copy_from_slice(&8u32.to_le_bytes()); // first IFD at 8
+
+ for k in 0..9u64 {
+ let ifd_off = (8 + 12 * k) as usize;
+ data[ifd_off..ifd_off + 2].copy_from_slice(&8192u16.to_le_bytes()); // count
+ let table = ifd_off + 2;
+ let ptr = table + 8192 * 12; // next-IFD pointer lives right after the entries
+ let next = if k + 1 < 9 { (8 + 12 * (k + 1)) as u32 } else { 0 };
+ data[ptr..ptr + 4].copy_from_slice(&next.to_le_bytes());
+ }
+
+ let tiff = Tiff::parse(&data).unwrap();
+ assert_eq!(tiff.ifds.len(), 8, "8 IFDs parsed, 9th rejected by max_entries_total before allocation");
+ }
+
+ #[test]
+ fn a_legitimate_multi_ifd_file_still_parses_under_the_entry_cap() {
+ // classic TIFF: IFD0 @8 (3 entries: value + Exif + GPS child pointers) -> IFD1 @58 chain,
+ // plus Exif child @60 and GPS child @90. Total entries = 6, far under max_entries_total.
+ let mut data = vec![0u8; 128];
+ data[0..2].copy_from_slice(b"II");
+ data[2..4].copy_from_slice(&42u16.to_le_bytes());
+ data[4..8].copy_from_slice(&8u32.to_le_bytes()); // first IFD at 8
+
+ // IFD0 @8: count 3, table @10, next-IFD @46 -> IFD1 @58
+ data[8..10].copy_from_slice(&3u16.to_le_bytes());
+ // entry0 @10: tag 0x0100, SHORT, count 1, value 8 (inline @18..22)
+ data[10..12].copy_from_slice(&0x0100u16.to_le_bytes());
+ data[12..14].copy_from_slice(&3u16.to_le_bytes());
+ data[14..18].copy_from_slice(&1u32.to_le_bytes());
+ data[18..22].copy_from_slice(&8u32.to_le_bytes());
+ // entry1 @22: tag 0x8769 ExifIFD, LONG, count 1, value 60 (inline @30..34)
+ data[22..24].copy_from_slice(&0x8769u16.to_le_bytes());
+ data[24..26].copy_from_slice(&4u16.to_le_bytes());
+ data[26..30].copy_from_slice(&1u32.to_le_bytes());
+ data[30..34].copy_from_slice(&60u32.to_le_bytes());
+ // entry2 @34: tag 0x8825 GPSIFD, LONG, count 1, value 90 (inline @42..46)
+ data[34..36].copy_from_slice(&0x8825u16.to_le_bytes());
+ data[36..38].copy_from_slice(&4u16.to_le_bytes());
+ data[38..42].copy_from_slice(&1u32.to_le_bytes());
+ data[42..46].copy_from_slice(&90u32.to_le_bytes());
+ data[46..50].copy_from_slice(&58u32.to_le_bytes()); // next IFD
+
+ // IFD1 @58: count 1, table @60, next 0
+ data[58..60].copy_from_slice(&1u16.to_le_bytes());
+ data[60..62].copy_from_slice(&0x0100u16.to_le_bytes());
+ data[62..64].copy_from_slice(&3u16.to_le_bytes());
+ data[64..68].copy_from_slice(&1u32.to_le_bytes());
+ data[68..72].copy_from_slice(&8u32.to_le_bytes());
+ data[72..76].copy_from_slice(&0u32.to_le_bytes());
+
+ // Exif child IFD @60: count 1, entry tag 0x9000 value 1, next 0
+ data[60..62].copy_from_slice(&1u16.to_le_bytes());
+ data[62..64].copy_from_slice(&0x9000u16.to_le_bytes());
+ data[64..66].copy_from_slice(&3u16.to_le_bytes());
+ data[66..70].copy_from_slice(&1u32.to_le_bytes());
+ data[70..74].copy_from_slice(&1u32.to_le_bytes());
+ data[74..78].copy_from_slice(&0u32.to_le_bytes());
+
+ // GPS child IFD @90: count 1, entry tag 0 value 1, next 0
+ data[90..92].copy_from_slice(&1u16.to_le_bytes());
+ data[92..94].copy_from_slice(&0u16.to_le_bytes());
+ data[94..96].copy_from_slice(&3u16.to_le_bytes());
+ data[96..100].copy_from_slice(&1u32.to_le_bytes());
+ data[100..104].copy_from_slice(&1u32.to_le_bytes());
+ data[104..108].copy_from_slice(&0u32.to_le_bytes());
+
+ let tiff = Tiff::parse(&data).unwrap();
+ assert_eq!(tiff.ifds.len(), 2, "chain IFDs parse fully");
+ assert_eq!(tiff.ifds[0].u64(0x0100), Some(8));
+ let exif = tiff.ifds[0].exif.as_ref().expect("Exif child present");
+ assert_eq!(exif.u64(0x9000), Some(1));
+ let gps = tiff.ifds[0].gps.as_ref().expect("GPS child present");
+ assert_eq!(gps.u64(0x0000), Some(1));
+ }
}