Files
craft-libs/crates/raw/tests/it/robust.rs
FredApps a99c8f8e36 raw: leave LinearizationTable unapplied when OpcodeList1 is present
DNG chapter 7 runs OpcodeList1 on the stored codes, then the
LinearizationTable maps them to sensor values. decode was applying the
table first, so a develop pipeline that later applied list 1 saw already
linearized samples.

When list 1 is present the table is now carried on RawImage and left
unapplied (`linearized` stays false). apply_linearization maps it after
the list. Files without list 1 are unchanged.

The dng-only build already compiles on main (d16ee792 gated
cr3::orientation). A comment at that gate records the E0433 failure
mode.

Part of #778.
2026-11-15 21:26:02 +01:00

162 lines
6.4 KiB
Rust
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Malformed-input robustness: decoding random or corrupted files must never panic.
use craft_raw::{BlackLevel, Cfa, ColorData, DngCompression, DngWriteOptions, Limits, OpcodeLists, Orientation, RawData, RawFormat, RawImage, Rect};
use proptest::prelude::*;
fn sample(comp: DngCompression) -> Vec<u8> {
let (w, h) = (24usize, 16usize);
let data: Vec<u16> = (0..w * h).map(|i| (i * 97 % 4000) as u16).collect();
let raw = RawImage {
format: RawFormat::Dng,
width: w,
height: h,
cpp: 1,
data: RawData::U16(data),
cfa: Some(Cfa::bayer("RGGB").unwrap()),
bits: 12,
black: BlackLevel::uniform(64.0),
white: vec![4095.0],
active_area: Rect::new(0, 0, w, h),
crop: Rect::new(0, 0, w, h),
orientation: Orientation::Normal,
color: ColorData::default(),
wb_multipliers: None,
linearized: false,
linearization_table: None,
pixel_aspect: 1.0,
opcodes: OpcodeLists::default(),
camera: Default::default(),
cinema: Default::default(),
lens_metadata: Default::default(),
level_sources: Default::default(),
notices: craft_raw::RawNotices::default(),
};
craft_raw::write_dng(&raw, &DngWriteOptions { compression: comp, ..Default::default() }).unwrap()
}
/// Everything the crate does with a file. A decoded image is internally consistent, and the header probe
/// succeeds whenever the decode does.
fn exercise(bytes: &[u8]) {
let _ = craft_raw::probe(bytes);
let _ = craft_raw::embedded_preview(bytes);
let _ = craft_raw::embedded_preview_covering(bytes, 256);
let _ = craft_raw::embedded_preview_color_space(bytes);
let _ = craft_raw::semantic_masks(bytes);
let _ = craft_raw::decode_reduced(bytes, 64, &Limits::default());
let info = craft_raw::probe_info(bytes);
if let Ok(img) = craft_raw::decode(bytes) {
img.validate().expect("a decoded image validates");
assert_eq!(info.as_ref().ok(), Some(&img.info()), "the header probe describes the decoded image");
}
}
const COMPRESSIONS: [DngCompression; 3] =
[DngCompression::Uncompressed, DngCompression::Lj92 { tile: 16 }, DngCompression::Deflate { tile: 16, half: false }];
proptest! {
#![proptest_config(ProptestConfig { cases: 400, .. ProptestConfig::default() })]
#[test]
fn mutated_dngs_never_panic(flips in proptest::collection::vec((any::<usize>(), any::<u8>()), 1..24), cut in any::<usize>(), comp in 0usize..3) {
let mut data = sample(COMPRESSIONS[comp]);
for (i, v) in flips {
let n = data.len();
data[i % n] = v;
}
let keep = if cut % 3 == 0 { cut % data.len() } else { data.len() };
exercise(&data[..keep]);
}
#[test]
fn random_tiff_like_bytes_never_panic(mut data in proptest::collection::vec(any::<u8>(), 8..700), kind in 0usize..4) {
let heads: [&[u8]; 4] = [b"II*\0\x08\0\0\0", b"MM\0*\0\0\0\x08", b"II*\0\x10\0\0\0CR\x02\0", b"II+\0\x08\0\0\0"];
let h = heads[kind];
let n = h.len().min(data.len());
data[..n].copy_from_slice(&h[..n]);
exercise(&data);
}
#[test]
fn random_lj92_never_panics(data in proptest::collection::vec(any::<u8>(), 0..400)) {
let mut s = vec![0xff, 0xd8, 0xff, 0xc3, 0, 11, 12, 0, 8, 0, 8, 1, 1, 0x11, 0];
s.extend_from_slice(&data);
let _ = craft_raw::ljpeg::decode(&s, 1 << 20);
let _ = craft_raw::ljpeg::decode_hasselblad(&s, 1 << 20);
let _ = craft_raw::ljpeg::decode_subsampled(&s, 1 << 20, craft_raw::ljpeg::Prediction::Sequential);
}
#[test]
fn random_opcode_lists_and_gain_maps_never_panic(data in proptest::collection::vec(any::<u8>(), 0..300), count in 0u32..6, id in 0u32..16) {
let mut list = count.to_be_bytes().to_vec();
list.extend_from_slice(&id.to_be_bytes());
list.extend_from_slice(&data);
let parsed = craft_raw::opcodes::parse_list(&list);
prop_assert_eq!(craft_raw::opcodes::parse_list(&craft_raw::opcodes::write_list(&parsed)), parsed);
for order in [craft_tiff::ByteOrder::Little, craft_tiff::ByteOrder::Big] {
for v2 in [false, true] {
let _ = craft_raw::gaintable::GainTableMap::parse(&data, order, v2);
}
}
}
#[cfg(feature = "crw")]
#[test]
fn random_ciff_like_bytes_never_panic(data in proptest::collection::vec(any::<u8>(), 0..600), big in any::<bool>()) {
let mut f = if big { b"MM".to_vec() } else { b"II".to_vec() };
f.extend_from_slice(&[26, 0, 0, 0]);
f.extend_from_slice(b"HEAPCCDR");
f.extend_from_slice(&data);
prop_assert_eq!(craft_raw::probe(&f), Some(RawFormat::Crw));
exercise(&f);
}
}
#[test]
fn truncation_at_every_length() {
for comp in COMPRESSIONS {
let d = sample(comp);
assert!(craft_raw::decode(&d).is_ok());
for n in 0..d.len() {
exercise(&d[..n]);
}
}
}
#[test]
fn every_single_byte_mutation_of_the_header_is_safe() {
// the IFD and its values sit at the end of the file the writer makes: flip every byte of the last 600
let d = sample(DngCompression::Uncompressed);
for i in d.len().saturating_sub(600)..d.len() {
for v in [0x00, 0xff, d[i] ^ 0x80, d[i].wrapping_add(1)] {
let mut m = d.clone();
m[i] = v;
exercise(&m);
}
}
for i in 0..8 {
let mut m = d.clone();
m[i] ^= 0xff;
exercise(&m);
}
}
#[test]
fn hostile_dimensions_are_rejected_quickly() {
// a DNG claiming a 60000 × 60000 16-bit image with 10 bytes of data
use craft_tiff::tags as t;
use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value};
let mut ifd = IfdBuilder::new();
ifd.set(t::DNG_VERSION, Value::Byte(vec![1, 4, 0, 0]));
ifd.set(t::IMAGE_WIDTH, Value::Long(vec![60000]));
ifd.set(t::IMAGE_LENGTH, Value::Long(vec![60000]));
ifd.set(t::BITS_PER_SAMPLE, Value::Short(vec![16]));
ifd.set(t::PHOTOMETRIC, Value::Short(vec![32803]));
ifd.set(t::CFA_PATTERN_EP, Value::Byte(vec![0, 1, 1, 2]));
ifd.set(t::COMPRESSION, Value::Short(vec![7]));
ifd.set_image(ImageData::Tiles { tile_width: 60000, tile_height: 60000, tiles: vec![vec![0xff, 0xd8, 0xff, 0xd9]] });
let bytes = TiffWriter::default().write(&[ifd]).unwrap();
let t0 = std::time::Instant::now();
assert!(craft_raw::decode(&bytes).is_err());
assert!(t0.elapsed().as_secs_f64() < 2.0);
}