diff --git a/crates/metadata/src/cr3.rs b/crates/metadata/src/cr3.rs index 56ce61f93..630e16ba3 100644 --- a/crates/metadata/src/cr3.rs +++ b/crates/metadata/src/cr3.rs @@ -361,28 +361,47 @@ fn trak(bytes: &[u8], t: &BoxRef, budget: &mut usize) -> Option { // Only the first sample is exposed. It must map chunk 1 to // the first sample description; don't trust offsets without // that mapping, or a damaged/raw track could become a JPEG. - mapping = None; - let count = be32(body, 4)? as usize; - if be32(body, 0)? == 0 && count > 0 && count <= body.len().saturating_sub(8) / 12 { - mapping = Some((be32(body, 8)?, be32(body, 12)?, be32(body, 16)?)); - } + // A malformed mapping invalidates sample data, not the track's + // identity: dropping the largest raw track could select a reduced + // raw successfully and disguise corruption in the main image. + mapping = (|| { + let count = be32(body, 4)? as usize; + if be32(body, 0)? != 0 || count == 0 || count > body.len().saturating_sub(8) / 12 { + return None; + } + Some((be32(body, 8)?, be32(body, 12)?, be32(body, 16)?)) + })(); } // version/flags, sample_size (0 = per-sample table), count, sizes b"stsz" => { - sample_count = be32(body, 8)?; - size = match be32(body, 4)? { + // A truncated size table invalidates data without hiding a known track. + sample_count = be32(body, 8).unwrap_or(0); + size = match be32(body, 4) { // A first entry cannot justify an incomplete per-sample // table, nor an impossible constant-size sample count. - 0 if sample_count > 0 && sample_count as usize <= body.len().saturating_sub(12) / 4 => be32(body, 12), - 0 => None, - n if sample_count > 0 && u64::from(n).checked_mul(u64::from(sample_count)).is_some_and(|total| total <= bytes.len() as u64) => { + Some(0) if sample_count > 0 && sample_count as usize <= body.len().saturating_sub(12) / 4 => be32(body, 12), + Some(n) + if n > 0 + && sample_count > 0 + && u64::from(n).checked_mul(u64::from(sample_count)).is_some_and(|total| total <= bytes.len() as u64) => + { Some(n) } _ => None, } } - b"co64" if be32(body, 4)? > 0 => offset = be64(body, 8).and_then(|v| usize::try_from(v).ok()), - b"stco" if be32(body, 4)? > 0 => offset = be32(body, 8).map(|v| v as usize), + // Missing offset-table counts deny sample access, but the known + // track must remain available to the largest-raw-track selector. + b"co64" => match be32(body, 4) { + Some(count) if count > 0 => offset = be64(body, 8).and_then(|v| usize::try_from(v).ok()), + None => offset = None, + _ => {} + }, + b"stco" => match be32(body, 4) { + Some(count) if count > 0 => offset = be32(body, 8).map(|v| v as usize), + None => offset = None, + _ => {} + }, _ => {} } } @@ -514,6 +533,13 @@ mod tests { bx(b"CRAW", &b) } fn trak(entry: Vec, offset: u64, size: u32) -> Vec { + let stsc = [1u32, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::>(); + trak_with_mapping(entry, offset, size, &stsc) + } + fn trak_with_mapping(entry: Vec, offset: u64, size: u32, mapping: &[u8]) -> Vec { + trak_with_table(entry, offset, size, b"stsc", mapping) + } + fn trak_with_table(entry: Vec, offset: u64, size: u32, table: &[u8; 4], payload: &[u8]) -> Vec { let mut stsd = 1u32.to_be_bytes().to_vec(); stsd.extend(entry); let mut stsz = 0u32.to_be_bytes().to_vec(); @@ -522,7 +548,14 @@ mod tests { let mut co64 = 1u32.to_be_bytes().to_vec(); co64.extend(offset.to_be_bytes()); let stsc = [1u32, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::>(); - let stbl = [full(b"stsd", &stsd), full(b"stsc", &stsc), full(b"stsz", &stsz), full(b"co64", &co64)].concat(); + let offsets = if table == b"stco" { full(b"stco", payload) } else { full(b"co64", if table == b"co64" { payload } else { &co64 }) }; + let stbl = [ + full(b"stsd", &stsd), + full(b"stsc", if table == b"stsc" { payload } else { &stsc }), + full(b"stsz", if table == b"stsz" { payload } else { &stsz }), + offsets, + ] + .concat(); bx(b"trak", &bx(b"mdia", &bx(b"minf", &bx(b"stbl", &stbl)))) } fn tiff_with(tag: u16, v: craft_tiff::Value) -> Vec { @@ -582,7 +615,9 @@ mod tests { damaged[offset..offset + 4].copy_from_slice(&value.to_be_bytes()); let bytes = file(damaged); let parsed = parse_cr3(&bytes).unwrap(); - assert!(parsed.tracks.is_empty() || parsed.tracks[0].data.is_none()); + assert_eq!(parsed.tracks.len(), 1, "invalid mapping must not erase an identifiable track"); + assert_eq!(parsed.tracks[0].kind, Cr3TrackKind::Jpeg); + assert!(parsed.tracks[0].data.is_none()); } for entry in [craw(16, 16, &[]), craw(16, 16, &bx(b"CMP1", &[0xff, 0x10, 0, 0x30]))] { let bytes = file(trak(entry, 4096, 16)); @@ -591,6 +626,51 @@ mod tests { } } + #[test] + fn truncated_sample_mapping_preserves_larger_raw_track_identity_and_valid_reduced_track() { + let reduced = trak(craw(4, 4, &bx(b"CMP1", &compression_payload(0))), 4096, 16); + for table in [b"stsc", b"stsz", b"co64", b"stco"] { + for payload in [Vec::new(), vec![0; 4], 1u32.to_be_bytes().to_vec()] { + // full() supplies version/flags; an empty payload leaves only + // those four bytes, with the table's required count missing. + let main = trak_with_table(craw(8, 4, &bx(b"CMP1", &compression_payload(0))), 4112, 32, table, &payload); + for main_first in [false, true] { + let tracks = if main_first { [main.clone(), reduced.clone()].concat() } else { [reduced.clone(), main.clone()].concat() }; + let mut file = bx(b"ftyp", b"crx \0\0\0\x01crx isom"); + file.extend(bx(b"moov", &tracks)); + file.resize(4144, 0); + let parsed = parse_cr3(&file).unwrap(); + assert_eq!(parsed.tracks.len(), 2, "truncated {table:?} cannot hide the larger track"); + let (main, reduced) = if main_first { (&parsed.tracks[0], &parsed.tracks[1]) } else { (&parsed.tracks[1], &parsed.tracks[0]) }; + assert!(matches!(reduced.kind, Cr3TrackKind::Raw { width: 4, height: 4, .. })); + assert_eq!(reduced.data, Some((4096, 16))); + assert!(matches!(main.kind, Cr3TrackKind::Raw { width: 8, height: 4, cmp1: Some(_), .. })); + assert!(main.data.is_none()); + assert!(main.compression(&file).is_some(), "only sample location is invalid"); + } + } + let mut offsets = 1u32.to_be_bytes().to_vec(); + offsets.extend(4112u64.to_be_bytes()); + let valid = match table { + b"stsc" => [1u32, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::>(), + b"stsz" => [0u32, 1, 32].into_iter().flat_map(u32::to_be_bytes).collect(), + b"stco" => [1u32, 4112].into_iter().flat_map(u32::to_be_bytes).collect(), + _ => offsets, + }; + let main = trak_with_table(craw(8, 4, &bx(b"CMP1", &compression_payload(0))), 4112, 32, table, &valid); + for main_first in [false, true] { + let tracks = if main_first { [main.clone(), reduced.clone()].concat() } else { [reduced.clone(), main.clone()].concat() }; + let mut file = bx(b"ftyp", b"crx \0\0\0\x01crx isom"); + file.extend(bx(b"moov", &tracks)); + file.resize(4144, 0); + let parsed = parse_cr3(&file).unwrap(); + assert_eq!(parsed.tracks.len(), 2); + let main = &parsed.tracks[if main_first { 0 } else { 1 }]; + assert_eq!(main.data, Some((4112, 32)), "complete valid {table:?} stays usable"); + } + } + } + #[test] fn first_sample_size_requires_a_complete_bounded_sample_table() { let valid = trak(craw(16, 16, &bx(b"JPEG", &[0; 4])), 4096, 16); @@ -778,7 +858,10 @@ mod tests { let mut file = bx(b"ftyp", b"crx \0\0\0\x01crx isom"); file.extend(bx(b"moov", &bx(b"trak", &bx(b"mdia", &bx(b"minf", &bx(b"stbl", &stbl)))))); file.resize(512, 0); - assert!(parse_cr3(&file).unwrap().tracks.is_empty()); + let parsed = parse_cr3(&file).unwrap(); + assert_eq!(parsed.tracks.len(), 1, "a truncated table must not hide the identifiable raw track"); + assert!(matches!(parsed.tracks[0].kind, Cr3TrackKind::Raw { width: 16, height: 16, .. })); + assert!(parsed.tracks[0].data.is_none(), "the empty stsz must not borrow size bytes from the following co64 box"); } #[test] diff --git a/crates/raw/src/arw.rs b/crates/raw/src/arw.rs index 3d531ec30..1b25aacda 100644 --- a/crates/raw/src/arw.rs +++ b/crates/raw/src/arw.rs @@ -734,11 +734,11 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result= (w * h * 2) as u64 { 14 } else { out_bits }; - let cfa = match (raw.u64s(t::CFA_REPEAT_PATTERN_DIM).as_deref(), raw.bytes(t::CFA_PATTERN_EP)) { + let (cfa, assumed_cfa) = match (raw.u64s(t::CFA_REPEAT_PATTERN_DIM).as_deref(), raw.bytes(t::CFA_PATTERN_EP)) { (Some([2, 2]), Some(p)) if p.len() == 4 && p.iter().all(|&c| c <= 2) => { - Cfa { width: 2, height: 2, pattern: p.to_vec(), origin_x: 0, origin_y: 0 } + (Cfa { width: 2, height: 2, pattern: p.to_vec(), origin_x: 0, origin_y: 0 }, false) } - _ => Cfa::bayer_static("RGGB"), + _ => (Cfa::bayer_static("RGGB"), true), }; let curve_black = (info.compression == 32767 && one_byte_per_sample) .then(|| declared_curve.as_ref().and_then(|curve| code_curve(curve).get(256).copied()).map(f32::from)) @@ -859,7 +859,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result Vec { + arw_with_strip_and_cfa(strip, None) + } + + fn arw_with_strip_and_cfa(strip: usize, cfa: Option<(Vec, Vec)>) -> Vec { use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; let mut raw = IfdBuilder::new(); raw.set(t::MAKE, Value::Ascii("SONY".into())); @@ -939,11 +945,37 @@ mod tests { raw.set(t::SAMPLES_PER_PIXEL, Value::Short(vec![1])); raw.set(t::PHOTOMETRIC, Value::Short(vec![photometric::CFA])); raw.set(t::COMPRESSION, Value::Short(vec![32767])); + if let Some((dimensions, pattern)) = cfa { + raw.set(t::CFA_REPEAT_PATTERN_DIM, Value::Short(dimensions)); + raw.set(t::CFA_PATTERN_EP, Value::Byte(pattern)); + } raw.set(TONE_CURVE, Value::Short(vec![8000, 10400, 12900, 14100])); raw.set_image(ImageData::Strips { rows_per_strip: 4, strips: vec![vec![0u8; strip]] }); TiffWriter::default().write(&[raw]).unwrap() } + #[test] + fn cfa_fallback_notices_follow_missing_malformed_and_valid_source_tags() { + for (tags, expected, assumed) in [ + (None, "RGGB", true), + (Some((vec![1, 4], vec![0, 1, 1, 2])), "RGGB", true), + (Some((vec![2, 2], vec![0, 1, 3, 2])), "RGGB", true), + (Some((vec![2, 2], vec![0, 1, 2])), "RGGB", true), + (Some((vec![2, 2], vec![1, 0, 2, 1])), "GRBG", false), + ] { + let file = arw_with_strip_and_cfa(32 * 4, tags); + let header = decode(&file, Mode::Header, &Limits::default()).unwrap(); + let full = decode(&file, Mode::Full, &Limits::default()).unwrap(); + assert_eq!(header.info(), full.info()); + for image in [&header, &full] { + assert_eq!(image.cfa.as_ref().unwrap().name(), expected); + assert_eq!(image.notices.assumed_cfa, assumed); + } + assert!(header.data.is_empty()); + assert_eq!(full.data.len(), 32 * 4); + } + } + /// Strip byte counts that add up past `u64::MAX` (LONG8 `[u64::MAX, 1]`) are an error or a picture, not an overflow. #[test] fn strip_byte_counts_past_u64_max_do_not_overflow() { diff --git a/crates/raw/src/cr2.rs b/crates/raw/src/cr2.rs index de851339a..4cfdbf56e 100644 --- a/crates/raw/src/cr2.rs +++ b/crates/raw/src/cr2.rs @@ -113,7 +113,7 @@ fn fallback_cfa(data: &[u16], width: usize, area: Rect, black: f32, white: f32, let green_first = [0x8000_0218, 0x8000_0250, 0x8000_0270, 0x8000_0286, 0x8000_0327].into_iter().any(|id| model == Some(id)); let measured = measured_red_row(data, width, area, black, white); let row = measured.unwrap_or(usize::from(green_first)); - (Cfa::bayer_static(if row == 1 { "GBRG" } else { "RGGB" }), measured.is_none() && !green_first) + (Cfa::bayer_static(if row == 1 { "GBRG" } else { "RGGB" }), measured.is_none()) } /// The 16-bit words of a maker-note array. Canon writes `ColorData` as SHORT in most models, but as UNDEFINED @@ -511,12 +511,41 @@ pub(crate) mod tests { let data = vec![512; 64 * 32]; let area = Rect::new(0, 0, 64, 32); assert_eq!(fallback_cfa(&data, 64, area, 512.0, 16000.0, Some(0x8000_0250)).0.name(), "GBRG"); + assert!(fallback_cfa(&data, 64, area, 512.0, 16000.0, Some(0x8000_0250)).1); assert_eq!(fallback_cfa(&data, 64, area, 512.0, 16000.0, None).0.name(), "RGGB"); + assert!(fallback_cfa(&data, 64, area, 512.0, 16000.0, None).1); for (width, area) in [(0, area), (64, Rect::new(usize::MAX, usize::MAX, 3, 3)), (64, Rect::new(63, 31, 1, 1))] { assert_eq!(measured_red_row(&data, width, area, 512.0, 16000.0), None); } } + #[test] + fn model_cfa_fallback_is_disclosed_in_header_and_full_decodes() { + // A single inline LONG maker-note entry needs no external offsets. + let mut note = Vec::new(); + note.extend_from_slice(&1u16.to_le_bytes()); + note.extend_from_slice(&CANON_MODEL_ID.to_le_bytes()); + note.extend_from_slice(&4u16.to_le_bytes()); + note.extend_from_slice(&1u32.to_le_bytes()); + note.extend_from_slice(&0x8000_0250u32.to_le_bytes()); + note.extend_from_slice(&0u32.to_le_bytes()); + let samples = vec![512u16; 64 * 32]; + let mut bytes = synthetic_cr2_of(&samples, 64, 32, None, Some(note)); + let marker = [0xe0, 0xc5, 4, 0, 1, 0, 0, 0]; + let at = bytes.windows(marker.len()).position(|b| b == marker).unwrap(); + // Remove only the CFA tag; the model ID and encoded samples stay intact. + bytes[at..at + 2].copy_from_slice(&0xc5dfu16.to_le_bytes()); + let header = decode(&bytes, Mode::Header, &Limits::default()).unwrap(); + let full = decode(&bytes, Mode::Full, &Limits::default()).unwrap(); + for image in [&header, &full] { + assert_eq!(image.cfa.as_ref().unwrap().name(), "GBRG"); + assert!(image.notices.assumed_cfa); + } + assert_eq!(header.info(), full.info()); + assert_eq!(full.data, RawData::U16(samples)); + assert!(header.data.is_empty()); + } + #[test] fn wb_probe() { let mut v = vec![0u64; 120]; diff --git a/crates/raw/src/cr3.rs b/crates/raw/src/cr3.rs index f875cbff1..14bec6132 100644 --- a/crates/raw/src/cr3.rs +++ b/crates/raw/src/cr3.rs @@ -405,6 +405,15 @@ mod tests { } fn track(entry: &[u8], offset: u64, size: u32) -> Vec { + let mapping = [0u32, 1, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::>(); + track_with_mapping(entry, offset, size, &mapping) + } + + fn track_with_mapping(entry: &[u8], offset: u64, size: u32, mapping: &[u8]) -> Vec { + track_with_table(entry, offset, size, b"stsc", mapping) + } + + fn track_with_table(entry: &[u8], offset: u64, size: u32, table: &[u8; 4], payload: &[u8]) -> Vec { let mut stsd = vec![0u8; 4]; stsd.extend(1u32.to_be_bytes()); stsd.extend(entry); @@ -414,8 +423,15 @@ mod tests { let mut co64 = vec![0u8; 4]; co64.extend(1u32.to_be_bytes()); co64.extend(offset.to_be_bytes()); - let stsc = [0u32, 1, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::>(); - let tables = [box_bytes(b"stsd", &stsd), box_bytes(b"stsc", &stsc), box_bytes(b"stsz", &stsz), box_bytes(b"co64", &co64)].concat(); + let mapping = [0u32, 1, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::>(); + let offsets = if table == b"stco" { box_bytes(b"stco", payload) } else { box_bytes(b"co64", if table == b"co64" { payload } else { &co64 }) }; + let tables = [ + box_bytes(b"stsd", &stsd), + box_bytes(b"stsc", if table == b"stsc" { payload } else { &mapping }), + box_bytes(b"stsz", if table == b"stsz" { payload } else { &stsz }), + offsets, + ] + .concat(); box_bytes(b"trak", &box_bytes(b"mdia", &box_bytes(b"minf", &box_bytes(b"stbl", &tables)))) } @@ -638,6 +654,105 @@ mod tests { assert!(matches!(decode(&missing, Mode::Header, &Limits::default()), Err(RawError::Corrupt(_)))); } + /// Independently framed constant-value CRX: each 4x4 tile has four 2x2 + /// planes whose one-byte 0x1e entropy streams reconstruct sensor value8193. + fn flat_raw_track(tiles: u32) -> (Vec, Vec) { + let mut sample = Vec::new(); + let marker = |out: &mut Vec, code: u16, size: u32, flags: u32| { + out.extend(code.to_be_bytes()); + out.extend(8u16.to_be_bytes()); + out.extend(size.to_be_bytes()); + out.extend(flags.to_be_bytes()); + }; + for tile in 0..tiles { + marker(&mut sample, 0xff01, 4, tile << 16); + for plane in 0..4 { + marker(&mut sample, 0xff02, 1, (plane << 28) | 0x0800_0000); + marker(&mut sample, 0xff03, 1, 0x0020_0000); + } + } + let header_size = sample.len() as u32; + sample.extend(std::iter::repeat_n(0x1e, tiles as usize * 4)); + let mut coding = vec![0u8; 52]; + coding[..2].copy_from_slice(&0xff00u16.to_be_bytes()); + coding[2..4].copy_from_slice(&48u16.to_be_bytes()); + coding[4..6].copy_from_slice(&0x100u16.to_be_bytes()); + for (offset, value) in [(8, tiles * 4), (12, 4), (16, 4), (20, 4), (28, header_size)] { + coding[offset..offset + 4].copy_from_slice(&value.to_be_bytes()); + } + coding[24] = 14; + coding[25] = 0x40; + let mut entry = vec![0u8; 82]; + entry[24..26].copy_from_slice(&((tiles * 4) as u16).to_be_bytes()); + entry[26..28].copy_from_slice(&4u16.to_be_bytes()); + entry.extend(box_bytes(b"CMP1", &coding)); + (box_bytes(b"CRAW", &entry), sample) + } + + #[test] + fn truncated_main_sample_mapping_cannot_silently_select_a_valid_reduced_raw() { + let mapping = [0u32, 1, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::>(); + let (reduced_entry, reduced_sample) = flat_raw_track(1); + let (main_entry, main_sample) = flat_raw_track(2); + let main_offset = 4096 + reduced_sample.len(); + let file = |main_table: Option<(&[u8; 4], &[u8])>, main_first: bool| { + let reduced = track_with_mapping(&reduced_entry, 4096, reduced_sample.len() as u32, &mapping); + let tracks = if let Some((table, payload)) = main_table { + let main = track_with_table(&main_entry, main_offset as u64, main_sample.len() as u32, table, payload); + if main_first { [main, reduced].concat() } else { [reduced, main].concat() } + } else { + reduced + }; + let mut bytes = box_bytes(b"ftyp", b"crx \0\0\0\x01crx isom"); + bytes.extend(box_bytes(b"moov", &tracks)); + assert!(bytes.len() < 4096); + bytes.resize(4096, 0); + bytes.extend_from_slice(&reduced_sample); + bytes.extend_from_slice(&main_sample); + bytes + }; + let mut co64 = vec![0u8; 4]; + co64.extend(1u32.to_be_bytes()); + co64.extend((main_offset as u64).to_be_bytes()); + let valid_tables = [ + (b"stsc", mapping.clone()), + (b"stsz", [0u32, main_sample.len() as u32, 1].into_iter().flat_map(u32::to_be_bytes).collect()), + (b"co64", co64), + (b"stco", [0u32, 1, main_offset as u32].into_iter().flat_map(u32::to_be_bytes).collect()), + ]; + for mode in [Mode::Header, Mode::Full] { + // The smaller source is genuinely decodable, so dropping the larger + // track would return success rather than merely a different failure. + let reduced = decode(&file(None, false), mode, &Limits::default()).unwrap(); + assert_eq!((reduced.width, reduced.height), (4, 4)); + if mode == Mode::Full { + assert_eq!(reduced.data, RawData::U16(vec![8193; 16])); + } + for main_first in [false, true] { + for (table, payload) in &valid_tables { + let valid = decode(&file(Some((table, payload)), main_first), mode, &Limits::default()).unwrap(); + assert_eq!((valid.width, valid.height), (8, 4)); + if mode == Mode::Full { + assert_eq!(valid.data, RawData::U16(vec![8193; 32])); + } + for truncated in [vec![], vec![0; 4], vec![0, 0, 0, 0, 0, 0, 0, 1]] { + let bytes = file(Some((table, &truncated)), main_first); + let container = parse_cr3(&bytes).unwrap(); + assert_eq!(container.tracks.len(), 2, "mapping damage cannot erase the main track"); + let selected = main_track(&container.tracks).unwrap(); + assert!(matches!(selected.kind, Cr3TrackKind::Raw { width: 8, height: 4, .. })); + assert!(selected.data.is_none()); + assert!(selected.compression(&bytes).is_some()); + assert!( + matches!(decode(&bytes, mode, &Limits::default()), Err(RawError::Corrupt(message)) if message.contains("sample")), + "{mode:?}/{table:?}: main mapping damage cannot decode the reduced source" + ); + } + } + } + } + } + #[test] fn color_data_uses_versioned_as_shot_offsets() { for (version, wb_at, black_at, white_at) in diff --git a/crates/raw/src/orf.rs b/crates/raw/src/orf.rs index 68e0b66bb..566e56fed 100644 --- a/crates/raw/src/orf.rs +++ b/crates/raw/src/orf.rs @@ -315,6 +315,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result Rect::new(0, 0, w, h), }; + let assumed_cfa = stated.is_none(); let cfa = stated.unwrap_or_else(|| cfa_from_data(samples, w, active)); let (black, black_source) = match ip.as_ref().and_then(|i| i.f64s(BLACK)).as_deref() { Some(v @ [_, _, _, _]) => { @@ -361,7 +362,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result = strip.as_chunks::<2>().0.iter().map(|word| u16::from_le_bytes(*word)).collect(); + for (tag, assumed, pattern) in [ + (None, true, "RGGB"), + (Some(&[2, 0, 2, 0, 0, 1][..]), true, "RGGB"), + (Some(&[2, 0, 2, 0, 0, 1, 1, 3][..]), true, "RGGB"), + (Some(BGGR), false, "BGGR"), + (Some(GRBG), false, "GRBG"), + ] { + let bytes = orf_with(w as u32, h as u32, 16, strip.clone(), tag); + for mode in [Mode::Header, Mode::Full] { + let image = decode(&bytes, mode, &Limits::default()).unwrap(); + assert_eq!(image.cfa, Some(Cfa::bayer_static(pattern))); + assert_eq!(image.data, RawData::U16(expected.clone()), "word16 samples remain unchanged"); + assert_eq!(image.notices, crate::RawNotices { assumed_cfa: assumed, ..Default::default() }); + } + } + } + #[test] fn packed_12_bit_probe_agrees_with_decode() { let (w, h) = (16usize, 4usize); diff --git a/crates/raw/src/pef.rs b/crates/raw/src/pef.rs index e48e4ba64..9dc3a89f1 100644 --- a/crates/raw/src/pef.rs +++ b/crates/raw/src/pef.rs @@ -194,6 +194,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result r, None => dark_trimmed(samples, w, hgt, black_point.as_deref().map(|v| v.iter().sum::() / 4.0), white), }; + let mut assumed_cfa = false; let cfa = match (ifd0.u64s(t::CFA_REPEAT_PATTERN_DIM).as_deref(), ifd0.bytes(t::CFA_PATTERN_EP)) { (Some([2, 2]), Some(p)) if p.len() == 4 && p.iter().all(|&c| c <= 2) => { Cfa { width: 2, height: 2, pattern: p.to_vec(), origin_x: 0, origin_y: 0 } @@ -202,7 +203,10 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result cfa_from_exif(&tiff).unwrap_or_else(|| Cfa::bayer_static("BGGR")), + _ => cfa_from_exif(&tiff).unwrap_or_else(|| { + assumed_cfa = true; + Cfa::bayer_static("BGGR") + }), }; let black = match black_point.as_deref() { Some(v @ [_, _, _, _]) => { @@ -240,7 +244,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result = (0..16).map(|i| 100 + i * 7).collect(); + let valid_exif = &[2, 0, 2, 0, 1, 0, 2, 1][..]; + let invalid_exif = &[2, 0, 2, 0, 1, 0][..]; + for (primary, exif, assumed, pattern) in [ + (None, None, true, "BGGR"), + (Some([0, 1, 1, 3]), None, true, "BGGR"), + (None, Some(invalid_exif), true, "BGGR"), + (Some([0, 1, 1, 3]), Some(invalid_exif), true, "BGGR"), + (Some([0, 1, 1, 3]), Some(valid_exif), false, "GRBG"), + (None, Some(valid_exif), false, "GRBG"), + (Some([0, 1, 1, 2]), None, false, "RGGB"), + (Some([0, 1, 1, 2]), Some(valid_exif), false, "RGGB"), + ] { + let mut raw = IfdBuilder::new(); + raw.set(t::IMAGE_WIDTH, Value::Long(vec![4])); + raw.set(t::IMAGE_LENGTH, Value::Long(vec![4])); + raw.set(t::BITS_PER_SAMPLE, Value::Short(vec![16])); + raw.set(t::COMPRESSION, Value::Short(vec![1])); + raw.set(t::PHOTOMETRIC, Value::Short(vec![32803])); + raw.set(t::MAKE, Value::Ascii("PENTAX Corporation".into())); + if let Some(pattern) = primary { + raw.set(t::CFA_REPEAT_PATTERN_DIM, Value::Short(vec![2, 2])); + raw.set(t::CFA_PATTERN_EP, Value::Byte(pattern.to_vec())); + } + if let Some(pattern) = exif { + raw.set_child(t::EXIF_IFD, IfdBuilder::new().with(crate::EXIF_CFA_PATTERN, Value::Undefined(pattern.to_vec()))); + } + raw.set_image(ImageData::Strips { rows_per_strip: 4, strips: vec![expected.iter().flat_map(|value| value.to_be_bytes()).collect()] }); + let bytes = TiffWriter::new(ByteOrder::Big, false).write(&[raw]).unwrap(); + for mode in [Mode::Header, Mode::Full] { + let image = decode(&bytes, mode, &Limits::default()).unwrap(); + assert_eq!(image.cfa, Some(Cfa::bayer_static(pattern))); + assert_eq!(image.data, RawData::U16(expected.clone())); + assert_eq!(image.notices, crate::RawNotices { assumed_cfa: assumed, ..Default::default() }); + } + } + } + /// A `w x h` big-endian 14-bit PEF of plain 16-bit words without area tags, whose maker note has only a /// BlackPoint of `black`, with `px(x, y)` as the samples. fn pef_with_black_point(w: usize, h: usize, black: u16, px: impl Fn(usize, usize) -> u16) -> Vec { diff --git a/crates/raw/src/raf.rs b/crates/raw/src/raf.rs index 2a7e75202..a3e407454 100644 --- a/crates/raw/src/raf.rs +++ b/crates/raw/src/raf.rs @@ -136,7 +136,9 @@ fn cfa(h: &Header) -> Result { } let Some(l) = record(h, 0x0130) else { return Ok(Cfa::bayer_static("RGGB")) }; let cfa = Cfa { width: 2, height: 2, pattern: l.iter().rev().map(|&c| if c & 3 == 3 { 1 } else { c & 3 }).collect(), origin_x: 0, origin_y: 0 }; - if l.len() != 4 || !cfa.is_bayer() { + // Colour counts alone also accept adjacent green sites; the two greens + // must occupy opposite corners of the 2x2 Bayer repeat. + if l.len() != 4 || !matches!(cfa.pattern.as_slice(), [0, 1, 1, 2] | [2, 1, 1, 0] | [1, 0, 2, 1] | [1, 2, 0, 1]) { return Err(RawError::Unsupported("Fujifilm RAF with an unknown Bayer layout".into())); } Ok(cfa) @@ -612,12 +614,48 @@ pub(super) mod tests { #[test] fn invalid_declared_cfa_layouts_are_not_silently_replaced() { - for (tag, data) in [(0x0130, vec![8, 8, 10, 10]), (0x0131, vec![3; 36])] { + for (tag, data) in [(0x0130, vec![8, 8, 10, 10]), (0x0130, vec![1, 2, 1, 0]), (0x0131, vec![3; 36])] { let header = Header { jpeg: None, records: vec![(tag, data.as_slice())], raw: None }; assert!(matches!(cfa(&header), Err(RawError::Unsupported(_)))); } } + fn with_bayer_record(mut bytes: Vec, pattern: [u8; 4]) -> Vec { + let (dir_at, raw_at) = (be32(&bytes, 92).unwrap(), be32(&bytes, 100).unwrap()); + let mut records = bytes[dir_at..raw_at].to_vec(); + let count = u32::from_be_bytes(records[..4].try_into().unwrap()) + 1; + records[..4].copy_from_slice(&count.to_be_bytes()); + records.extend_from_slice(&[0x01, 0x30, 0, 4]); + records.extend_from_slice(&pattern); + bytes.splice(dir_at..raw_at, records.clone()); + bytes[96..100].copy_from_slice(&(records.len() as u32).to_be_bytes()); + bytes[100..104].copy_from_slice(&((raw_at + 8) as u32).to_be_bytes()); + bytes + } + + #[test] + fn non_bayer_geometry_is_rejected_in_header_and_full_modes() { + // Reversal gives RGBG: correct colour counts, but both greens in one column. + let bytes = with_bayer_record(raf(6, 4, 16, pack(&[1000; 24], 16), None, &[]), [1, 2, 1, 0]); + for mode in [Mode::Header, Mode::Full] { + assert!(matches!(decode(&bytes, mode, &Limits::default()), Err(RawError::Unsupported(why)) if why.contains("Bayer layout"))); + } + } + + #[test] + fn all_four_bayer_geometries_preserve_the_stored_samples() { + let pixels: Vec = (0..24).map(|i| 123 + i * 977).collect(); + for (stored, expected) in [([2, 1, 1, 0], "RGGB"), ([0, 1, 1, 2], "BGGR"), ([1, 2, 0, 1], "GRBG"), ([1, 0, 2, 1], "GBRG")] { + let bytes = with_bayer_record(raf(6, 4, 16, pack(&pixels, 16), None, &[]), stored); + for mode in [Mode::Header, Mode::Full] { + let image = decode(&bytes, mode, &Limits::default()).unwrap(); + assert_eq!((image.width, image.height), (6, 4)); + assert_eq!(image.cfa.as_ref().unwrap().name(), expected); + assert_eq!(image.data, RawData::U16(if mode == Mode::Full { pixels.clone() } else { Vec::new() })); + } + } + } + #[test] fn compressed_bayer_requires_the_layout_assumed_by_its_predictor() { let strip = b"IS\x01\x00\x0e\0\x12\x06\0\x03\x0c\x03\0\x02\0\x03".to_vec(); diff --git a/crates/raw/src/rw2.rs b/crates/raw/src/rw2.rs index 6e57566c2..1dc1a885e 100644 --- a/crates/raw/src/rw2.rs +++ b/crates/raw/src/rw2.rs @@ -622,7 +622,11 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result= 0.0)); let tags = read.map(|v| v.unwrap_or(0.0) as f32); let offset = match encoding { @@ -674,7 +678,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result = (0..72).map(|i| 17 + i * 113).collect(); + let payload = pack(&pixels, 14); + for (code, expected, assumed) in [ + (None, "RGGB", true), + (Some(0), "RGGB", true), + (Some(5), "RGGB", true), + (Some(u16::MAX), "RGGB", true), + (Some(1), "RGGB", false), + (Some(2), "GRBG", false), + (Some(3), "GBRG", false), + (Some(4), "BGGR", false), + ] { + let mut tags = vec![short(BITS, 14), short(RAW_FORMAT, 7)]; + if let Some(code) = code { + tags.push(short(CFA_PATTERN, code)); + } + let bytes = file(18, 4, &tags, &payload, &|off| vec![(RAW_OFFSET, Value::Long(vec![off]))]); + for mode in [Mode::Header, Mode::Full] { + let image = decode(&bytes, mode, &Limits::default()).unwrap(); + assert_eq!((image.width, image.height), (18, 4)); + assert_eq!(image.cfa.as_ref().unwrap().name(), expected, "code {code:?}"); + assert_eq!(image.notices, crate::RawNotices { assumed_cfa: assumed, ..Default::default() }, "code {code:?}, {mode:?}"); + assert_eq!(samples(&image), if mode == Mode::Full { pixels.as_slice() } else { &[] }); + } + } + } + #[test] fn lossless_packed_formats_preserve_zero_codes_inside_the_active_area() { let (w, h) = (90usize, 12usize); diff --git a/crates/svg/src/tree.rs b/crates/svg/src/tree.rs index ecea12706..aa4ca7503 100644 --- a/crates/svg/src/tree.rs +++ b/crates/svg/src/tree.rs @@ -462,9 +462,24 @@ fn embedded(used: &Used, limits: &Limits, data: &[u8], options: &usvg::Options<' return None; } }; + // The raw/inflated bytes can fit while UTF-16/Latin-1 decoding expands + // beyond the aggregate allowance. A refusal consumes the remaining work. + if text.len() > left { + used.bytes.fetch_add(left, Ordering::Relaxed); + used.svg_limit.fetch_add(1, Ordering::Relaxed); + used.svg_resource_limit.fetch_add(1, Ordering::Relaxed); + return None; + } used.bytes.fetch_add(text.len(), Ordering::Relaxed); let xml = match checked(&text, limits) { Ok(xml) => xml, + // Decoding UTF-16 or Latin-1 can exceed the text cap after the + // raw/inflated bytes fitted. This is a resource refusal, not invalid XML. + Err(Error::Text(svgz::Error::TooLarge(_))) => { + used.svg_limit.fetch_add(1, Ordering::Relaxed); + used.svg_resource_limit.fetch_add(1, Ordering::Relaxed); + return None; + } Err(_) => { used.invalid_svg.fetch_add(1, Ordering::Relaxed); return None; diff --git a/crates/svg/src/tree/tests.rs b/crates/svg/src/tree/tests.rs index dd645381a..80681cad4 100644 --- a/crates/svg/src/tree/tests.rs +++ b/crates/svg/src/tree/tests.rs @@ -269,6 +269,93 @@ mod resource_limit_usage { (found, resolver.usage()) } + fn expanding_encoded_children() -> Vec<(&'static str, Vec)> { + let latin = + format!("{}", svg(&format!("{}", "é".repeat(100)))); + let latin = latin.chars().map(|c| u8::try_from(u32::from(c)).unwrap()).collect(); + let wide = svg(&format!("{}", "ࠀ".repeat(400))); + let mut little = vec![0xff, 0xfe]; + little.extend(wide.encode_utf16().flat_map(u16::to_le_bytes)); + let mut big = vec![0xfe, 0xff]; + big.extend(wide.encode_utf16().flat_map(u16::to_be_bytes)); + vec![("Latin-1", latin), ("UTF-16LE", little), ("UTF-16BE", big)] + } + + #[test] + fn decoded_text_expansion_is_a_resource_refusal_for_plain_and_gzip_children() { + for (encoding, raw) in expanding_encoded_children() { + let decoded = svgz::decode(&raw).unwrap(); + let cap = raw.len(); + assert!(decoded.len() > cap, "{encoding} fixture must expand after inflation"); + for gzip in [false, true] { + let data = if gzip { svgz::compress(&raw) } else { raw.clone() }; + assert_eq!(svgz::inflate(&data, cap).unwrap().len(), cap, "raw bytes fit exactly"); + assert_eq!(svgz::text(&data, cap).unwrap().len(), decoded.len(), "decoding itself succeeds"); + let limits = Limits { bytes: cap, embedded_bytes: decoded.len(), ..shallow() }; + assert!(matches!(checked(&decoded, &limits), Err(Error::Text(svgz::Error::TooLarge(n))) if n == cap)); + let image = data_image(&data); + let (found, usage) = resolved(&svg(&image), limits, 1); + assert!(found.is_empty(), "{encoding}, gzip {gzip}"); + assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (1, 1, 0)); + assert_eq!(usage.embedded_svg_bytes, decoded.len(), "spent decoded work remains charged"); + let (found, usage) = resolved(&svg(&format!("{image}{image}")), limits, 1); + assert!(found.is_empty()); + assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (2, 2, 0)); + assert_eq!(usage.embedded_svg_bytes, decoded.len(), "a refused sibling cannot repeat exhausted work"); + } + } + } + + #[test] + fn decoded_text_expansion_respects_aggregate_bytes_even_when_each_child_fits() { + for (encoding, raw) in expanding_encoded_children() { + let decoded = svgz::decode(&raw).unwrap(); + let limits = Limits { bytes: decoded.len(), embedded_bytes: raw.len(), ..shallow() }; + assert!(decoded.len() > limits.embedded_bytes); + checked(&decoded, &limits).unwrap(); // The independent per-image cap allows this complete XML. + for gzip in [false, true] { + let data = if gzip { svgz::compress(&raw) } else { raw.clone() }; + assert_eq!(svgz::inflate(&data, limits.embedded_bytes).unwrap().len(), raw.len()); + let image = data_image(&data); + let (found, usage) = resolved(&svg(&image), limits, 1); + assert!(found.is_empty(), "{encoding}, gzip {gzip}"); + assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (1, 1, 0)); + assert_eq!(usage.embedded_svg_bytes, limits.embedded_bytes, "refusal consumes exactly the remaining allowance"); + let (found, usage) = resolved(&svg(&format!("{image}{image}")), limits, 1); + assert!(found.is_empty()); + assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (2, 2, 0)); + assert_eq!(usage.embedded_svg_bytes, limits.embedded_bytes, "a later child cannot repeat exhausted work"); + let (found, usage) = resolved(&svg(&image), Limits { embedded_bytes: decoded.len(), ..limits }, 1); + assert_eq!(found, [true]); + assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (0, 0, 0)); + assert_eq!(usage.embedded_svg_bytes, decoded.len()); + } + } + } + + #[test] + fn decoded_text_expansion_at_the_cap_is_valid_and_malformed_xml_stays_invalid() { + for (encoding, raw) in expanding_encoded_children() { + let decoded = svgz::decode(&raw).unwrap(); + for gzip in [false, true] { + let data = if gzip { svgz::compress(&raw) } else { raw.clone() }; + let limits = Limits { bytes: decoded.len(), embedded_bytes: decoded.len(), ..shallow() }; + let (found, usage) = resolved(&svg(&data_image(&data)), limits, 1); + assert_eq!(found, [true], "{encoding}, gzip {gzip}"); + assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (0, 0, 0)); + assert_eq!(usage.embedded_svg_bytes, decoded.len()); + // Preserve the declared/BOM encoding when making the XML malformed; + // re-encoding Latin-1 text as UTF-8 would test a second expansion instead. + let closing_bytes = if encoding == "Latin-1" { 6 } else { 12 }; + let malformed = &raw[..raw.len() - closing_bytes]; + let data = if gzip { svgz::compress(malformed) } else { malformed.to_vec() }; + let (found, usage) = resolved(&svg(&data_image(&data)), limits, 1); + assert!(found.is_empty()); + assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (0, 0, 1)); + } + } + } + #[test] fn embedded_chain_caps_are_explicit_resource_refusals_for_plain_and_gzip_children() { for gzip in [false, true] {