Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
fix: validate fragmented media from its sample tables
Richie McIlroy0453d35d9f30
diff --git a/crates/enc-ffmpeg/src/mux/fragment_metadata.rs b/crates/enc-ffmpeg/src/mux/fragment_metadata.rsindex d9b3159a2..aaebf5d5e 100644--- a/crates/enc-ffmpeg/src/mux/fragment_metadata.rs+++ b/crates/enc-ffmpeg/src/mux/fragment_metadata.rs@@ -13,6 +13,17 @@ pub(super) struct FragmentMetadata {pub(super) fn read_fragment_metadata(path: &Path) -> io::Result<FragmentMetadata> {let mut file = File::open(path)?;let file_size = file.metadata()?.len();+ let init = path.with_file_name("init.mp4");+ if init.exists() {+ let prefix = super::fragment_prefix::read_fragment_prefix(&init, path)?;+ if prefix.length != file_size {+ return Err(invalid_fragment("Fragment contains incomplete media"));+ }+ return Ok(FragmentMetadata {+ duration: prefix.duration,+ file_size,+ });+ }read_metadata(&mut file, file_size)}diff --git a/crates/enc-ffmpeg/src/mux/fragment_prefix.rs b/crates/enc-ffmpeg/src/mux/fragment_prefix.rsnew file mode 100644index 000000000..b8afe53b0--- /dev/null+++ b/crates/enc-ffmpeg/src/mux/fragment_prefix.rs@@ -0,0 +1,587 @@+use std::{+ fs::File,+ io::{self, BufReader, Read, Seek, SeekFrom},+ path::Path,+ time::Duration,+};++struct Reader {+ input: BufReader<File>,+ position: u64,+}++impl Reader {+ fn open(path: &Path) -> io::Result<Self> {+ Ok(Self {+ input: BufReader::new(File::open(path)?),+ position: 0,+ })+ }++ fn len(&self) -> io::Result<u64> {+ Ok(self.input.get_ref().metadata()?.len())+ }+}++impl Read for Reader {+ fn read(&mut self, bytes: &mut [u8]) -> io::Result<usize> {+ let read = self.input.read(bytes)?;+ self.position += read as u64;+ Ok(read)+ }+}++impl Seek for Reader {+ fn seek(&mut self, position: SeekFrom) -> io::Result<u64> {+ if let SeekFrom::Current(0) = position {+ return Ok(self.position);+ }+ self.position = self.input.seek(position)?;+ Ok(self.position)+ }+}++#[derive(Clone, Copy)]+struct BoxHeader {+ kind: [u8; 4],+ start: u64,+ payload: u64,+ end: u64,+}++#[derive(Default)]+struct Track {+ id: u32,+ timescale: u32,+ duration: u32,+ size: u32,+ flags: u32,+}++struct Run {+ start: u64,+ end: u64,+}++struct Fragment {+ decode_time: u64,+ duration: u64,+ runs: Vec<Run>,+ starts_with_keyframe: bool,+}++pub struct FragmentPrefix {+ pub length: u64,+ pub duration: Duration,+}++fn invalid() -> io::Error {+ io::Error::new(+ io::ErrorKind::InvalidData,+ "Invalid fragmented MP4 sample table",+ )+}++fn u32_at(reader: &mut (impl Read + Seek), end: u64) -> io::Result<u32> {+ if reader+ .stream_position()?+ .checked_add(4)+ .ok_or_else(invalid)?+ > end+ {+ return Err(invalid());+ }+ let mut bytes = [0; 4];+ reader.read_exact(&mut bytes)?;+ Ok(u32::from_be_bytes(bytes))+}++fn u64_at(reader: &mut (impl Read + Seek), end: u64) -> io::Result<u64> {+ Ok((u64::from(u32_at(reader, end)?) << 32) | u64::from(u32_at(reader, end)?))+}++fn skip(reader: &mut (impl Read + Seek), bytes: u64, end: u64) -> io::Result<()> {+ let position = reader+ .stream_position()?+ .checked_add(bytes)+ .ok_or_else(invalid)?;+ if position > end {+ return Err(invalid());+ }+ reader.seek(SeekFrom::Start(position))?;+ Ok(())+}++fn header(reader: &mut (impl Read + Seek), end: u64) -> io::Result<Option<BoxHeader>> {+ let start = reader.stream_position()?;+ if start == end {+ return Ok(None);+ }+ let size = u32_at(reader, end)?;+ let kind = u32_at(reader, end)?.to_be_bytes();+ let size = match size {+ 0 => return Err(invalid()),+ 1 => u64_at(reader, end)?,+ size => u64::from(size),+ };+ let payload = reader.stream_position()?;+ let box_end = start.checked_add(size).ok_or_else(invalid)?;+ if box_end < payload || box_end > end {+ return Err(invalid());+ }+ Ok(Some(BoxHeader {+ kind,+ start,+ payload,+ end: box_end,+ }))+}++fn track_in(reader: &mut (impl Read + Seek), end: u64, track: &mut Track) -> io::Result<()> {+ while let Some(item) = header(reader, end)? {+ match &item.kind {+ b"trak" | b"mdia" => track_in(reader, item.end, track)?,+ b"tkhd" => {+ let version = u32_at(reader, item.end)? >> 24;+ skip(+ reader,+ match version {+ 0 => 8,+ 1 => 16,+ _ => return Err(invalid()),+ },+ item.end,+ )?;+ track.id = u32_at(reader, item.end)?;+ }+ b"mdhd" => {+ let version = u32_at(reader, item.end)? >> 24;+ skip(+ reader,+ match version {+ 0 => 8,+ 1 => 16,+ _ => return Err(invalid()),+ },+ item.end,+ )?;+ track.timescale = u32_at(reader, item.end)?;+ }+ _ => {}+ }+ reader.seek(SeekFrom::Start(item.end))?;+ }+ Ok(())+}++fn read_track(path: &Path) -> io::Result<Track> {+ let mut reader = Reader::open(path)?;+ let end = reader.len()?;+ let mut track = Track::default();+ let mut defaults = Vec::new();+ while let Some(item) = header(&mut reader, end)? {+ if item.kind == *b"moov" {+ while let Some(child) = header(&mut reader, item.end)? {+ match &child.kind {+ b"trak" => {+ if track.id != 0 {+ return Err(invalid());+ }+ track_in(&mut reader, child.end, &mut track)?;+ }+ b"mvex" => {+ while let Some(entry) = header(&mut reader, child.end)? {+ if entry.kind == *b"trex" {+ if u32_at(&mut reader, entry.end)? != 0 {+ return Err(invalid());+ }+ let id = u32_at(&mut reader, entry.end)?;+ let _description = u32_at(&mut reader, entry.end)?;+ defaults.push((+ id,+ u32_at(&mut reader, entry.end)?,+ u32_at(&mut reader, entry.end)?,+ u32_at(&mut reader, entry.end)?,+ ));+ }+ reader.seek(SeekFrom::Start(entry.end))?;+ }+ }+ _ => {}+ }+ reader.seek(SeekFrom::Start(child.end))?;+ }+ }+ reader.seek(SeekFrom::Start(item.end))?;+ }+ if track.id == 0 || track.timescale == 0 {+ return Err(invalid());+ }+ let mut matching = defaults.into_iter().filter(|(id, ..)| *id == track.id);+ if let Some((_, duration, size, flags)) = matching.next() {+ track.duration = duration;+ track.size = size;+ track.flags = flags;+ }+ if matching.next().is_some() {+ return Err(invalid());+ }+ Ok(track)+}++fn read_fragment(+ reader: &mut (impl Read + Seek),+ moof: BoxHeader,+ track: &Track,+) -> io::Result<Fragment> {+ let mut traf = None;+ while let Some(item) = header(reader, moof.end)? {+ if item.kind == *b"traf" && traf.replace(item).is_some() {+ return Err(invalid());+ }+ reader.seek(SeekFrom::Start(item.end))?;+ }+ let traf = traf.ok_or_else(invalid)?;+ reader.seek(SeekFrom::Start(traf.payload))?;+ let mut base = moof.start;+ let mut default_duration = track.duration;+ let mut default_size = track.size;+ let mut default_flags = track.flags;+ let mut decode_time = None;+ let mut has_header = false;+ let mut runs = Vec::new();+ while let Some(item) = header(reader, traf.end)? {+ match &item.kind {+ b"tfhd" => {+ if has_header {+ return Err(invalid());+ }+ has_header = true;+ let flags = u32_at(reader, item.end)?;+ if flags & !0x02003b != 0 || u32_at(reader, item.end)? != track.id {+ return Err(invalid());+ }+ if flags & 1 != 0 {+ base = u64_at(reader, item.end)?;+ }+ if flags & 2 != 0 {+ let _description = u32_at(reader, item.end)?;+ }+ if flags & 8 != 0 {+ default_duration = u32_at(reader, item.end)?;+ }+ if flags & 16 != 0 {+ default_size = u32_at(reader, item.end)?;+ }+ if flags & 32 != 0 {+ default_flags = u32_at(reader, item.end)?;+ }+ }+ b"tfdt" => {+ if decode_time.is_some() {+ return Err(invalid());+ }+ decode_time = Some(match u32_at(reader, item.end)? {+ 0 => u64::from(u32_at(reader, item.end)?),+ 0x01000000 => u64_at(reader, item.end)?,+ _ => return Err(invalid()),+ });+ }+ b"trun" => runs.push(item),+ _ => {}+ }+ reader.seek(SeekFrom::Start(item.end))?;+ }+ if !has_header || runs.is_empty() {+ return Err(invalid());+ }+ let mut fragment = Fragment {+ decode_time: decode_time.ok_or_else(invalid)?,+ duration: 0,+ runs: Vec::new(),+ starts_with_keyframe: false,+ };+ let mut next_data = base;+ for run in runs {+ reader.seek(SeekFrom::Start(run.payload))?;+ let flags = u32_at(reader, run.end)?;+ if flags & !0x01000f05 != 0 || flags >> 24 > 1 {+ return Err(invalid());+ }+ let count = u32_at(reader, run.end)?;+ if count == 0 {+ return Err(invalid());+ }+ if flags & 1 != 0 {+ let offset = u32_at(reader, run.end)? as i32;+ next_data = base+ .checked_add_signed(i64::from(offset))+ .ok_or_else(invalid)?;+ }+ let first_flags = if flags & 4 != 0 {+ u32_at(reader, run.end)?+ } else {+ default_flags+ };+ let per_sample = (flags & 0xf00).count_ones() as u64 * 4;+ if per_sample+ .checked_mul(u64::from(count))+ .ok_or_else(invalid)?+ > run.end - reader.stream_position()?+ {+ return Err(invalid());+ }+ let start = next_data;+ if per_sample == 0 {+ if default_duration == 0 || default_size == 0 {+ return Err(invalid());+ }+ if fragment.runs.is_empty() {+ fragment.starts_with_keyframe = first_flags & 0x10000 == 0;+ }+ fragment.duration = fragment+ .duration+ .checked_add(u64::from(default_duration) * u64::from(count))+ .ok_or_else(invalid)?;+ next_data = next_data+ .checked_add(u64::from(default_size) * u64::from(count))+ .ok_or_else(invalid)?;+ }+ for index in 0..if per_sample == 0 { 0 } else { count } {+ let duration = if flags & 0x100 != 0 {+ u32_at(reader, run.end)?+ } else {+ default_duration+ };+ let size = if flags & 0x200 != 0 {+ u32_at(reader, run.end)?+ } else {+ default_size+ };+ let sample_flags = if flags & 0x400 != 0 {+ u32_at(reader, run.end)?+ } else if index == 0 {+ first_flags+ } else {+ default_flags+ };+ if flags & 0x800 != 0 {+ let _composition_offset = u32_at(reader, run.end)?;+ }+ if duration == 0 || size == 0 {+ return Err(invalid());+ }+ if fragment.runs.is_empty() && index == 0 {+ fragment.starts_with_keyframe = sample_flags & 0x10000 == 0;+ }+ fragment.duration = fragment+ .duration+ .checked_add(u64::from(duration))+ .ok_or_else(invalid)?;+ next_data = next_data.checked_add(u64::from(size)).ok_or_else(invalid)?;+ }+ if reader.stream_position()? != run.end {+ return Err(invalid());+ }+ fragment.runs.push(Run {+ start,+ end: next_data,+ });+ }+ Ok(fragment)+}++pub fn read_fragment_prefix(init: &Path, media: &Path) -> io::Result<FragmentPrefix> {+ let track = read_track(init)?;+ let mut reader = Reader::open(media)?;+ let end = reader.len()?;+ let mut pending = None;+ let mut prefix = 0;+ let mut first_time = None;+ let mut end_time = 0;+ let result = (|| -> io::Result<()> {+ while let Some(item) = header(&mut reader, end)? {+ match &item.kind {+ b"moof" => {+ if pending.is_some() {+ return Err(invalid());+ }+ pending = Some(read_fragment(&mut reader, item, &track)?);+ }+ b"mdat" => {+ let fragment: Fragment = pending.take().ok_or_else(invalid)?;+ if fragment+ .runs+ .iter()+ .any(|run| run.start < item.payload || run.end > item.end)+ || fragment+ .runs+ .windows(2)+ .any(|pair| pair[0].end != pair[1].start)+ || fragment+ .runs+ .first()+ .is_none_or(|run| run.start != item.payload)+ || fragment.runs.last().is_none_or(|run| run.end != item.end)+ {+ return Err(invalid());+ }+ if first_time.is_none() {+ if !fragment.starts_with_keyframe {+ return Err(invalid());+ }+ first_time = Some(fragment.decode_time);+ } else if fragment.decode_time != end_time {+ return Err(invalid());+ }+ end_time = fragment+ .decode_time+ .checked_add(fragment.duration)+ .ok_or_else(invalid)?;+ prefix = item.end;+ }+ b"styp" | b"sidx" | b"emsg" | b"prft" | b"free" => {+ if pending.is_some() {+ return Err(invalid());+ }+ }+ _ => return Err(invalid()),+ }+ reader.seek(SeekFrom::Start(item.end))?;+ }+ Ok(())+ })();+ if prefix == 0 {+ result?;+ return Err(invalid());+ }+ let ticks = end_time+ .checked_sub(first_time.ok_or_else(invalid)?)+ .ok_or_else(invalid)?;+ let timescale = u64::from(track.timescale);+ Ok(FragmentPrefix {+ length: prefix,+ duration: Duration::new(+ ticks / timescale,+ ((ticks % timescale) * 1_000_000_000 / timescale) as u32,+ ),+ })+}++#[cfg(test)]+mod tests {+ use super::*;++ fn boxed(kind: &[u8; 4], data: &[u8]) -> Vec<u8> {+ let mut bytes = ((data.len() + 8) as u32).to_be_bytes().to_vec();+ bytes.extend(kind);+ bytes.extend(data);+ bytes+ }++ fn words(values: &[u32]) -> Vec<u8> {+ values+ .iter()+ .flat_map(|value| value.to_be_bytes())+ .collect()+ }++ fn init() -> Vec<u8> {+ let tkhd = boxed(b"tkhd", &words(&[0, 0, 0, 1]));+ let mdhd = boxed(b"mdhd", &words(&[0, 0, 0, 30]));+ let trak = boxed(b"trak", &[tkhd, boxed(b"mdia", &mdhd)].concat());+ let defaults = boxed(b"mvex", &boxed(b"trex", &words(&[0, 1, 1, 1, 4, 0])));+ boxed(b"moov", &[trak, defaults].concat())+ }++ fn media(time: u32, keyframe: bool, count: u32) -> Vec<u8> {+ let tfhd = boxed(b"tfhd", &words(&[0x20000, 1]));+ let tfdt = boxed(b"tfdt", &words(&[0, time]));+ let make_moof = |offset| {+ let trun = boxed(+ b"trun",+ &words(&[5, count, offset, if keyframe { 0 } else { 0x10000 }]),+ );+ boxed(+ b"moof",+ &boxed(b"traf", &[tfhd.clone(), tfdt.clone(), trun].concat()),+ )+ };+ let moof = make_moof(make_moof(0).len() as u32 + 8);+ [moof, boxed(b"mdat", &vec![42; count as usize * 4])].concat()+ }++ fn parse(init: &[u8], media: &[u8]) -> io::Result<FragmentPrefix> {+ let directory = tempfile::tempdir()?;+ let init_path = directory.path().join("init.mp4");+ let media_path = directory.path().join("segment.m4s");+ std::fs::write(&init_path, init)?;+ std::fs::write(&media_path, media)?;+ read_fragment_prefix(&init_path, &media_path)+ }++ #[test]+ fn accepts_multiple_fragments_without_indexes_and_with_multiple_indexes() {+ for indexed in [false, true] {+ let mut bytes = boxed(b"styp", &[0; 16]);+ for index in 0..3 {+ if indexed {+ bytes.extend(boxed(b"sidx", &[0; 24]));+ }+ bytes.extend(media(index * 60, index == 0, 60));+ }+ let prefix = parse(&init(), &bytes).unwrap();+ assert_eq!(prefix.length, bytes.len() as u64);+ assert_eq!(prefix.duration, Duration::from_secs(6));+ }+ }++ #[test]+ fn every_truncated_tail_keeps_only_preceding_complete_samples() {+ let first = media(0, true, 60);+ let second = media(60, false, 60);+ for cut in 0..second.len() {+ let bytes = [&first[..], &second[..cut]].concat();+ let prefix = parse(&init(), &bytes).unwrap();+ assert_eq!(prefix.length, first.len() as u64, "cut {cut}");+ assert_eq!(prefix.duration, Duration::from_secs(2));+ }+ for cut in 0..first.len() {+ assert!(parse(&init(), &first[..cut]).is_err(), "cut {cut}");+ }+ }++ #[test]+ fn requires_keyframe_at_segment_start_and_contiguous_decode_times() {+ assert!(parse(&init(), &media(0, false, 60)).is_err());+ for time in [0, 59, 61] {+ let first = media(0, true, 60);+ let bytes = [first.clone(), media(time, false, 60)].concat();+ assert_eq!(parse(&init(), &bytes).unwrap().length, first.len() as u64);+ }+ }++ #[test]+ fn rejects_invalid_track_and_sample_ranges() {+ let original = media(0, true, 60);+ for (needle, delta, value) in [+ (b"tfhd", 8, 2),+ (b"trun", 8, 0),+ (b"trun", 12, 0),+ (b"trun", 8, u32::MAX),+ ] {+ let mut bytes = original.clone();+ let offset = bytes.windows(4).position(|slice| slice == needle).unwrap() + delta;+ bytes[offset..offset + 4].copy_from_slice(&value.to_be_bytes());+ assert!(parse(&init(), &bytes).is_err());+ }+ let mut invalid_init = init();+ let offset = invalid_init+ .windows(4)+ .position(|slice| slice == b"mdhd")+ .unwrap()+ + 16;+ invalid_init[offset..offset + 4].fill(0);+ assert!(parse(&invalid_init, &original).is_err());+ }+}diff --git a/crates/enc-ffmpeg/src/mux/fragmented_mp4.rs b/crates/enc-ffmpeg/src/mux/fragmented_mp4.rsindex 3361d0777..a12623736 100644--- a/crates/enc-ffmpeg/src/mux/fragmented_mp4.rs+++ b/crates/enc-ffmpeg/src/mux/fragmented_mp4.rs@@ -1,3 +1,4 @@+pub use super::fragment_prefix::{FragmentPrefix, read_fragment_prefix};use std::{fs::File,io::{Read, Seek, SeekFrom},diff --git a/crates/enc-ffmpeg/src/mux/mod.rs b/crates/enc-ffmpeg/src/mux/mod.rsindex 24e53ac50..c31ea535e 100644--- a/crates/enc-ffmpeg/src/mux/mod.rs+++ b/crates/enc-ffmpeg/src/mux/mod.rs@@ -2,6 +2,7 @@ pub mod dash_audio;mod dash_output;pub mod fragment_manifest;mod fragment_metadata;+mod fragment_prefix;pub mod fragmented_audio;pub mod fragmented_mp4;pub mod mov;