EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
WAV markers: read RF64 files and bound the adtl list
Kristian Myram620d340d1577
diff --git a/crates/media/src/wav_markers.rs b/crates/media/src/wav_markers.rsindex f7c1bb84d..ca40824b6 100644--- a/crates/media/src/wav_markers.rs+++ b/crates/media/src/wav_markers.rs@@ -7,8 +7,13 @@//! one entry per marker (`xmpDM:startTime`, `xmpDM:duration`, `xmpDM:name`), counted in frames//! of `xmpDM:frameRate` (`f44100` for samples at 44.1 kHz).//!+//! RF64 files (WAVs over 4 GB) carry a `0xFFFFFFFF` size for a chunk too big for 32 bits and give its real size in a+//! `ds64` chunk; those sizes are resolved so the chunks after the audio are still found.+//!//! The file is untrusted input: every read is bounds-checked, sizes use checked arithmetic, and-//! the number of markers and the size of the XMP packet are capped.+//! the number of markers, of `adtl` sub-chunks looked at and the size of the XMP packet are capped.++use std::collections::{HashMap, HashSet};use effectcraft_color::Label;use effectcraft_project::Marker;@@ -18,12 +23,21 @@ use effectcraft_time::Tick;pub const MAX_MARKERS: usize = 10_000;/// Largest XMP packet read (bytes).const MAX_XMP: usize = 4 << 20;+/// Most `adtl` sub-chunks (`labl`, `note`, `ltxt`) looked at in one file: a few per cue point is plenty.+const MAX_ADTL_RECORDS: usize = 4 * MAX_MARKERS;+/// Most entries read from an RF64 file's `ds64` size table.+const MAX_DS64_TABLE: usize = 1_024;fn u32_at(b: &[u8], at: usize) -> Option<u32> {let s = b.get(at..at.checked_add(4)?)?;Some(u32::from_le_bytes(s.try_into().ok()?))}+fn u64_at(b: &[u8], at: usize) -> Option<u64> {+ let s = b.get(at..at.checked_add(8)?)?;+ Some(u64::from_le_bytes(s.try_into().ok()?))+}+/// The text of a NUL-terminated label (the rest of the chunk), lossily decoded.fn label(b: &[u8]) -> String {let end = b.iter().position(|&c| c == 0).unwrap_or(b.len());@@ -39,14 +53,55 @@ pub fn is_wav(bytes: &[u8]) -> bool {matches!(bytes.get(0..4), Some(b"RIFF" | b"RF64")) && bytes.get(8..12) == Some(b"WAVE")}+/// The sizes an RF64 file's `ds64` chunk gives for chunks too big for the 32-bit size field.+struct Ds64 {+ /// The `data` chunk's size.+ data: u64,+ /// Other chunks: `(id, size)`.+ table: Vec<([u8; 4], u64)>,+}++impl Ds64 {+ /// The real size of chunk `id`, when the file says.+ fn size_of(&self, id: &[u8; 4]) -> Option<u64> {+ if id == b"data" { Some(self.data) } else { self.table.iter().find(|(t, _)| t == id).map(|(_, size)| *size) }+ }+}++/// The `ds64` chunk of an RF64 file (`RF64`, size, `WAVE`, then `ds64`); `None` for any other file or one whose+/// `ds64` doesn't fit.+fn ds64(bytes: &[u8]) -> Option<Ds64> {+ if bytes.get(0..4) != Some(b"RF64") || bytes.get(12..16) != Some(b"ds64") {+ return None;+ }+ let size = usize::try_from(u32_at(bytes, 16)?).ok()?;+ let body = bytes.get(20..20usize.checked_add(size)?)?;+ // riff size (8), data size (8), sample count (8), table length (4), then `(id, size)` entries of 12 bytes+ let data = u64_at(body, 8)?;+ let entries = usize::try_from(u32_at(body, 24)?).ok()?;+ let mut table = Vec::new();+ for i in 0..entries.min(MAX_DS64_TABLE) {+ let at = 28usize.checked_add(i.checked_mul(12)?)?;+ let id = <[u8; 4]>::try_from(body.get(at..at.checked_add(4)?)?).ok()?;+ table.push((id, u64_at(body, at + 4)?));+ }+ Some(Ds64 { data, table })+}+/// The chunks of a WAVE file as `(id, body)`, stopping at the first one that doesn't fit.fn chunks(bytes: &[u8]) -> Vec<([u8; 4], &[u8])> {+ let big = ds64(bytes);let mut out = Vec::new();let mut at = 12usize;while let Some(head) = bytes.get(at..at.saturating_add(8)) {- let (Ok(id), Some(size)) = (<[u8; 4]>::try_from(&head[..4]), u32_at(head, 4)) else { break };+ let (Ok(id), Some(field)) = (<[u8; 4]>::try_from(&head[..4]), u32_at(head, 4)) else { break };+ // In an RF64 file a size field of 0xFFFFFFFF stands for the size `ds64` gives.+ let size = match &big {+ Some(d) if field == u32::MAX => d.size_of(&id).unwrap_or(u64::from(field)),+ _ => u64::from(field),+ };let start = at.saturating_add(8);- let Some(end) = start.checked_add(size as usize) else { break };+ let Some(end) = usize::try_from(size).ok().and_then(|n| start.checked_add(n)) else { break };let Some(body) = bytes.get(start..end) else { break };out.push((id, body));// Chunks are padded to an even size.@@ -64,9 +119,10 @@ pub fn read(bytes: &[u8]) -> Vec<Marker> {let rate = chunks.iter().find(|(id, _)| id == b"fmt ").and_then(|(_, b)| u32_at(b, 4)).map_or(0.0, f64::from);let mut out = cue_markers(&chunks, rate);if let Some((_, xmp)) = chunks.iter().find(|(id, _)| id == b"_PMX") {+ // Tools that write both encodings repeat each marker.+ let mut seen: HashSet<(String, Tick)> = out.iter().map(|o| (o.comment.clone(), o.time)).collect();for m in xmp_markers(xmp, rate) {- // Tools that write both encodings repeat each marker.- if !out.iter().any(|o| o.comment == m.comment && o.time == m.time) {+ if seen.insert((m.comment.clone(), m.time)) {out.push(m);}}@@ -80,43 +136,57 @@ pub fn read(bytes: &[u8]) -> Vec<Marker> {fn cue_markers(chunks: &[([u8; 4], &[u8])], rate: f64) -> Vec<Marker> {let Some((_, cue)) = chunks.iter().find(|(id, _)| id == b"cue ") else { return Vec::new() };let count = (u32_at(cue, 0).unwrap_or(0) as usize).min(MAX_MARKERS);- // Cue id -> (name, length in samples).- let mut names: Vec<(u32, String)> = Vec::new();- let mut lengths: Vec<(u32, u32)> = Vec::new();- for (_, list) in chunks.iter().filter(|(id, b)| id == b"LIST" && b.get(0..4) == Some(b"adtl")) {+ // The cue points first: `(id, offset in samples)`.+ let mut points = Vec::new();+ for i in 0..count {+ let Some(point) = cue.get(4usize.saturating_add(i.saturating_mul(24))..) else { break };+ let (Some(id), Some(offset)) = (u32_at(point, 0), u32_at(point, 20)) else { break };+ points.push((id, offset));+ }+ // Only the names and lengths of those ids are kept, so a hostile `adtl` list cannot grow them past the cue count,+ // and each record is a lookup, not a scan.+ let wanted: HashSet<u32> = points.iter().map(|(id, _)| *id).collect();+ let mut names: HashMap<u32, String> = HashMap::new();+ let mut lengths: HashMap<u32, u32> = HashMap::new();+ let mut records = 0usize;+ 'lists: for (_, list) in chunks.iter().filter(|(id, b)| id == b"LIST" && b.get(0..4) == Some(b"adtl")) {let mut at = 4usize;while let Some(head) = list.get(at..at.saturating_add(8)) {let (Ok(id), Some(size)) = (<[u8; 4]>::try_from(&head[..4]), u32_at(head, 4)) else { break };let start = at.saturating_add(8);let Some(end) = start.checked_add(size as usize) else { break };let Some(body) = list.get(start..end) else { break };- if let Some(cue_id) = u32_at(body, 0) {+ records += 1;+ if records > MAX_ADTL_RECORDS {+ break 'lists;+ }+ if let Some(cue_id) = u32_at(body, 0).filter(|c| wanted.contains(c)) {match &id {- b"labl" | b"note" => {- let text = label(body.get(4..).unwrap_or_default());- // A `labl` is the name; a `note` only when there is none.- let known = names.iter().any(|(c, _)| *c == cue_id);- if &id == b"labl" || !known {- names.retain(|(c, _)| *c != cue_id);- names.push((cue_id, text));- }+ // A `labl` is the name; a `note` only when there is none.+ b"labl" => {+ names.insert(cue_id, label(body.get(4..).unwrap_or_default()));+ }+ b"note" => {+ names.entry(cue_id).or_insert_with(|| label(body.get(4..).unwrap_or_default()));+ }+ // The first `ltxt` of a cue point gives its length.+ b"ltxt" => {+ lengths.entry(cue_id).or_insert_with(|| u32_at(body, 4).unwrap_or(0));}- b"ltxt" => lengths.push((cue_id, u32_at(body, 4).unwrap_or(0))),_ => {}}}at = end.saturating_add(end & 1);}}- let mut out = Vec::new();- for i in 0..count {- let Some(point) = cue.get(4usize.saturating_add(i.saturating_mul(24))..) else { break };- let (Some(id), Some(offset)) = (u32_at(point, 0), u32_at(point, 20)) else { break };- let comment = names.iter().find(|(c, _)| *c == id).map(|(_, t)| t.clone()).unwrap_or_default();- let length = lengths.iter().find(|(c, _)| *c == id).map_or(0, |(_, l)| *l);- out.push(Marker { time: secs(f64::from(offset), rate), duration: secs(f64::from(length), rate), comment, label: Label::None, ..Default::default() });- }- out+ points+ .into_iter()+ .map(|(id, offset)| {+ let comment = names.get(&id).cloned().unwrap_or_default();+ let length = lengths.get(&id).copied().unwrap_or(0);+ Marker { time: secs(f64::from(offset), rate), duration: secs(f64::from(length), rate), comment, label: Label::None, ..Default::default() }+ })+ .collect()}/// The text of `name` in an XMP entry, as an attribute (`name="v"`) or an element@@ -347,4 +417,101 @@ mod tests {let m = read(&wav(&[cue(&[(1, 44100)])]));assert_eq!(m[0].time, Tick::ZERO);}++ /// A chunk whose size field says `field` (an RF64 file's `0xFFFFFFFF`) while its body is `body`.+ fn chunk_with_size_field(id: &[u8; 4], field: u32, body: &[u8]) -> Vec<u8> {+ let mut v = id.to_vec();+ v.extend(field.to_le_bytes());+ v.extend(body);+ if body.len() % 2 == 1 {+ v.push(0);+ }+ v+ }++ /// An RF64 `ds64` chunk: the `data` chunk's size and a table of other chunks' sizes.+ fn ds64_chunk(data_size: u64, table: &[([u8; 4], u64)]) -> Vec<u8> {+ let mut b = 0u64.to_le_bytes().to_vec(); // riff size (not used)+ b.extend(data_size.to_le_bytes());+ b.extend(0u64.to_le_bytes()); // sample count+ b.extend((table.len() as u32).to_le_bytes());+ for (id, size) in table {+ b.extend(id);+ b.extend(size.to_le_bytes());+ }+ chunk(b"ds64", &b)+ }++ fn rf64(chunks: &[Vec<u8>]) -> Vec<u8> {+ let body: Vec<u8> = chunks.iter().flatten().copied().collect();+ let mut v = b"RF64".to_vec();+ v.extend(u32::MAX.to_le_bytes());+ v.extend(b"WAVE");+ v.extend(body);+ v+ }++ #[test]+ fn rf64_markers_after_a_data_chunk_of_sentinel_size_are_read() {+ let audio = [0u8; 8];+ let file = rf64(&[+ ds64_chunk(audio.len() as u64, &[]),+ fmt(44100),+ chunk_with_size_field(b"data", u32::MAX, &audio),+ cue(&[(1, 44100)]),+ adtl(&[labl(b"labl", 1, "After the audio")]),+ ]);+ let m = read(&file);+ assert_eq!(m.len(), 1);+ assert_eq!((m[0].comment.as_str(), m[0].time), ("After the audio", Tick::from_seconds_f64(1.0)));+ }++ #[test]+ fn rf64_sizes_of_other_chunks_come_from_the_ds64_table() {+ let junk = [7u8; 6];+ let tail = || [cue(&[(1, 8000)]), adtl(&[labl(b"labl", 1, "Found")])].concat();+ let with_entry = rf64(&[ds64_chunk(0, &[(*b"junk", junk.len() as u64)]), fmt(8000), chunk_with_size_field(b"junk", u32::MAX, &junk), tail()]);+ assert_eq!(read(&with_entry)[0].comment, "Found");+ // Without the table entry the sentinel is all there is, and what follows is not reached.+ let without = rf64(&[ds64_chunk(0, &[]), fmt(8000), chunk_with_size_field(b"junk", u32::MAX, &junk), tail()]);+ assert!(read(&without).is_empty());+ }++ #[test]+ fn hostile_rf64_size_tables_read_as_far_as_they_go_without_panicking() {+ // sizes that overflow when added to an offset+ for data in [u64::MAX, u64::MAX - 7, 1 << 63] {+ let file = rf64(&[ds64_chunk(data, &[(*b"junk", u64::MAX)]), fmt(8000), chunk_with_size_field(b"data", u32::MAX, &[0; 4]), cue(&[(1, 0)])]);+ assert!(read(&file).is_empty());+ }+ // a table that claims far more entries than its chunk holds+ let mut liar = ds64_chunk(0, &[]);+ liar[8 + 24..8 + 28].copy_from_slice(&u32::MAX.to_le_bytes());+ let _ = read(&rf64(&[liar, fmt(8000), cue(&[(1, 0)])]));+ // every truncation of a good RF64 file is safe+ let good =+ rf64(&[ds64_chunk(4, &[]), fmt(44100), chunk_with_size_field(b"data", u32::MAX, &[0; 4]), cue(&[(1, 44100)]), adtl(&[labl(b"labl", 1, "Kept")])]);+ assert_eq!(read(&good).len(), 1);+ for n in 0..good.len() {+ let _ = read(&good[..n]);+ }+ }++ #[test]+ fn a_huge_adtl_list_is_read_in_linear_time_and_only_for_the_cue_points_that_exist() {+ // Records for ids that have no cue point are skipped, not stored, and the number looked at is capped.+ let junk = |n: u32| (1000..1000 + n).map(|id| labl(b"labl", id, "n")).collect::<Vec<_>>();+ let started = std::time::Instant::now();+ // the real label comes first: read+ let mut subs = vec![labl(b"labl", 1, "Real")];+ subs.extend(junk(100_000));+ let m = read(&wav(&[fmt(44100), cue(&[(1, 44100)]), adtl(&subs)]));+ assert_eq!(m[0].comment, "Real");+ // it comes after more records than are looked at: not read, and the marker is still there+ let mut subs = junk(MAX_ADTL_RECORDS as u32 + 10);+ subs.push(labl(b"labl", 1, "Too late"));+ let m = read(&wav(&[fmt(44100), cue(&[(1, 44100)]), adtl(&subs)]));+ assert_eq!((m.len(), m[0].comment.as_str()), (1, ""));+ assert!(started.elapsed() < std::time::Duration::from_secs(5), "took {:?}", started.elapsed());+ }}