From d9a1b170474e28546ac7696fe67de4f33897b462 Mon Sep 17 00:00:00 2001 From: laurenspriem Date: Tue, 3 Nov 2026 11:41:14 +0530 Subject: [PATCH 1/3] Reject repeated transforms on grid tile items A grid tile item could carry up to 65,534 clap or irot associations, and preflight and decode walked every one of them for every grid reference, so decode time scaled with references times transforms (a 128x128 grid of one tile with 65,534 identity claps took about 49 s). libheif rejects a second irot, imir or clap on one item as a format rule (GHSA-7qm8-hj35-269r, v1.23.7) and libavif applies only the first of each, so resolve each distinct tile item's transforms once into at most one per type, rejecting duplicates and dropping identity rotations. Preflight and decode now do constant transform work per reference. --- src/isobmff.rs | 164 ++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 149 insertions(+), 15 deletions(-) diff --git a/src/isobmff.rs b/src/isobmff.rs index 444f64b..a819302 100644 --- a/src/isobmff.rs +++ b/src/isobmff.rs @@ -2830,6 +2830,11 @@ pub enum ExtractHeicItemDataError { item_id: u32, tile_item_id: u32, }, + DuplicateGridTileTransform { + item_id: u32, + tile_item_id: u32, + property_type: FourCc, + }, GridTileAssociationCountTooLarge { item_id: u32, total: usize, @@ -2994,6 +2999,14 @@ impl Display for ExtractHeicItemDataError { f, "primary grid item_ID {item_id} tile item_ID {tile_item_id} has multiple hvcC properties" ), + ExtractHeicItemDataError::DuplicateGridTileTransform { + item_id, + tile_item_id, + property_type, + } => write!( + f, + "primary grid item_ID {item_id} tile item_ID {tile_item_id} has multiple {property_type} properties" + ), ExtractHeicItemDataError::GridTileAssociationCountTooLarge { item_id, total } => { write!( f, @@ -4669,6 +4682,7 @@ fn resolve_grid_tile_hvcc_colr_and_transforms_indexed( let mut hvcc = None; let mut last_nclx = None; let mut last_icc = None; + let mut transform_types = Vec::new(); let mut transforms = Vec::new(); for association in associations { @@ -4704,7 +4718,24 @@ fn resolve_grid_tile_hvcc_colr_and_transforms_indexed( ColorInformation::Nclx(_) => last_nclx = Some(property_index), ColorInformation::Icc(_) => last_icc = Some(property_index), }, - CachedGridProperty::Transform(transform) => transforms.push(*transform), + CachedGridProperty::Transform(transform) => { + let property_type = property.header.box_type; + if transform_types.contains(&property_type) { + return Err(ExtractHeicItemDataError::DuplicateGridTileTransform { + item_id, + tile_item_id, + property_type, + }); + } + transform_types.push(property_type); + if !matches!( + transform, + PrimaryItemTransformProperty::Rotation(rotation) + if rotation.rotation_ccw_degrees.is_multiple_of(360) + ) { + transforms.push(*transform); + } + } CachedGridProperty::Ignored => {} } } @@ -7843,13 +7874,14 @@ mod tests { }; use super::{ ExtractHeicItemDataError, ExtractUncompressedItemDataError, FourCc, - HeicGridPrimaryItemData, HeicPrimaryItemDataWithGrid, IccColorProfile, NclxColorProfile, - ParseItemLocationBoxError, ParseItemPropertyAssociationBoxError, - PrimaryItemColorProperties, extract_primary_heic_item_data_with_grid, + HeicGridPrimaryItemData, HeicPrimaryItemDataWithGrid, IROT_BOX_TYPE, IccColorProfile, + NclxColorProfile, ParseItemLocationBoxError, ParseItemPropertyAssociationBoxError, + PrimaryItemColorProperties, PrimaryItemTransformProperty, + extract_primary_heic_item_data_with_grid, extract_primary_heic_item_data_with_grid_from_source, extract_primary_uncompressed_item_data, extract_primary_uncompressed_item_data_from_source, - merge_primary_and_grid_tile_color_properties, parse_iloc_payload, parse_ipma_payload, - primary_heic_color_properties, + merge_primary_and_grid_tile_color_properties, parse_boxes, parse_iloc_payload, + parse_ipma_payload, primary_heic_color_properties, }; use std::sync::Arc; @@ -8248,24 +8280,18 @@ mod tests { #[test] fn grid_tile_transforms_are_shared_across_duplicate_references() { - let mut tile_property_indices = vec![1_u8]; - tile_property_indices.extend([2_u8; 254]); - let rotations = [2_u8; 255]; - let extra_rotations: Vec<(u16, &[u8])> = - (0..256).map(|_| (2_u16, &rotations[..])).collect(); - let grid = resolved_grid(&minimal_heic_grid_file( (16, 16), (64, 64), &[2_u16; 256], &[0x11; 16], &[hvcc_box(), plain_box(b"irot", &[1])], - &tile_property_indices, - &extra_rotations, + &[1, 2], + &[], )); assert_eq!(grid.tiles.len(), 256); - assert_eq!(grid.tiles[0].transforms.len(), 254 + 256 * 255); + assert_eq!(grid.tiles[0].transforms.len(), 1); assert!( grid.tiles .iter() @@ -8273,6 +8299,114 @@ mod tests { ); } + fn identity_clap_box() -> Vec { + let fields: [u32; 8] = [16, 1, 16, 1, 0, 1, 0, 1]; + plain_box( + b"clap", + &fields + .iter() + .flat_map(|field| field.to_be_bytes()) + .collect::>(), + ) + } + + #[test] + fn grid_tile_repeated_transform_associations_are_rejected() { + let mut tile_property_indices = vec![1_u8]; + tile_property_indices.extend([2_u8; 254]); + let repeats = [2_u8; 255]; + let extra_repeats: Vec<(u16, &[u8])> = (0..256).map(|_| (2_u16, &repeats[..])).collect(); + + for property in [ + identity_clap_box(), + plain_box(b"irot", &[0]), + plain_box(b"imir", &[0]), + ] { + let property_type = FourCc::new(property[4..8].try_into().unwrap()); + let err = extract_primary_heic_item_data_with_grid(&minimal_heic_grid_file( + (16, 16), + (256, 256), + &[2_u16; 256], + &[0x11; 16], + &[hvcc_box(), property], + &tile_property_indices, + &extra_repeats, + )) + .expect_err("repeated tile transform must be rejected"); + assert!( + matches!( + err, + ExtractHeicItemDataError::DuplicateGridTileTransform { + tile_item_id: 2, + property_type: actual, + .. + } if actual == property_type + ), + "{property_type}: {err}" + ); + } + } + + #[test] + fn grid_tile_distinct_properties_of_one_transform_type_are_rejected() { + let err = extract_primary_heic_item_data_with_grid(&minimal_heic_grid_file( + (1, 1), + (64, 64), + &[2], + &[0x11; 16], + &[ + hvcc_box(), + plain_box(b"irot", &[0]), + identity_clap_box(), + plain_box(b"irot", &[2]), + ], + &[1, 2, 3, 4], + &[], + )) + .expect_err("second irot must be rejected"); + assert!(matches!( + err, + ExtractHeicItemDataError::DuplicateGridTileTransform { + property_type, + .. + } if property_type.as_bytes() == IROT_BOX_TYPE + )); + } + + #[test] + fn grid_tile_transforms_keep_one_per_type_and_drop_identity_rotations() { + let grid = resolved_grid(&minimal_heic_grid_file( + (16, 16), + (256, 256), + &[2_u16; 256], + &[0x11; 16], + &[ + hvcc_box(), + plain_box(b"irot", &[0]), + identity_clap_box(), + plain_box(b"imir", &[1]), + ], + &[1, 2, 3, 4], + &[], + )); + + assert_eq!( + grid.tiles[0].transforms.as_ref(), + [ + PrimaryItemTransformProperty::CleanAperture( + parse_boxes(&identity_clap_box()).unwrap()[0] + .parse_clap() + .unwrap() + ), + PrimaryItemTransformProperty::Mirror( + parse_boxes(&plain_box(b"imir", &[1])).unwrap()[0] + .parse_imir() + .unwrap() + ), + ] + ); + } + #[test] fn grid_tile_codec_configurations_are_shared_across_duplicate_references() { let nal_count = 65_535_u16; From 2df08b4d46b363f9e2b9f3ca172f398b5e1e0f39 Mon Sep 17 00:00:00 2001 From: laurenspriem Date: Tue, 3 Nov 2026 12:09:50 +0530 Subject: [PATCH 2/3] Reject repeated transforms on primary items A primary item accepted any number of clap, irot and imir associations. The per-pixel transform paths walk every step for every output pixel, so the cost scaled with transforms times pixels: a sips-encoded 1001x777 HEIC took 5.8 s with 2,550 imir associations against 0.55 s without. Apply the rule already used for grid tiles: at most one clap, irot and imir per item, matching libheif's GHSA-7qm8-hj35-269r check. Unlike grid tiles, identity rotations stay in the returned list because parse_primary_item_transform_properties is public. --- src/isobmff.rs | 134 +++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 124 insertions(+), 10 deletions(-) diff --git a/src/isobmff.rs b/src/isobmff.rs index a819302..87f8659 100644 --- a/src/isobmff.rs +++ b/src/isobmff.rs @@ -2248,6 +2248,7 @@ pub enum ParsePrimaryItemTransformPropertiesError { ImageCleanAperture(ParseImageCleanAperturePropertyError), ImageRotation(ParseImageRotationPropertyError), ImageMirror(ParseImageMirrorPropertyError), + DuplicateTransform { item_id: u32, property_type: FourCc }, } impl Display for ParsePrimaryItemTransformPropertiesError { @@ -2262,6 +2263,13 @@ impl Display for ParsePrimaryItemTransformPropertiesError { ParsePrimaryItemTransformPropertiesError::ImageCleanAperture(err) => write!(f, "{err}"), ParsePrimaryItemTransformPropertiesError::ImageRotation(err) => write!(f, "{err}"), ParsePrimaryItemTransformPropertiesError::ImageMirror(err) => write!(f, "{err}"), + ParsePrimaryItemTransformPropertiesError::DuplicateTransform { + item_id, + property_type, + } => write!( + f, + "primary item_ID {item_id} has multiple {property_type} properties" + ), } } } @@ -3371,31 +3379,44 @@ pub fn parse_primary_item_transform_properties( pub(crate) fn parse_primary_item_transform_properties_from_resolved_graph( resolved: &ResolvedPrimaryItemGraph<'_>, ) -> Result { + let mut transform_types = Vec::new(); let mut transforms = Vec::new(); for property in &resolved.primary_item.properties { let property_type = property.property.header.box_type; - if property_type.as_bytes() == CLAP_BOX_TYPE { - transforms.push(PrimaryItemTransformProperty::CleanAperture( + let transform = if property_type.as_bytes() == CLAP_BOX_TYPE { + PrimaryItemTransformProperty::CleanAperture( property .property .parse_clap() .map_err(ParsePrimaryItemTransformPropertiesError::ImageCleanAperture)?, - )); + ) } else if property_type.as_bytes() == IROT_BOX_TYPE { - transforms.push(PrimaryItemTransformProperty::Rotation( + PrimaryItemTransformProperty::Rotation( property .property .parse_irot() .map_err(ParsePrimaryItemTransformPropertiesError::ImageRotation)?, - )); + ) } else if property_type.as_bytes() == IMIR_BOX_TYPE { - transforms.push(PrimaryItemTransformProperty::Mirror( + PrimaryItemTransformProperty::Mirror( property .property .parse_imir() .map_err(ParsePrimaryItemTransformPropertiesError::ImageMirror)?, - )); + ) + } else { + continue; + }; + if transform_types.contains(&property_type) { + return Err( + ParsePrimaryItemTransformPropertiesError::DuplicateTransform { + item_id: resolved.primary_item.item_id, + property_type, + }, + ); } + transform_types.push(property_type); + transforms.push(transform); } Ok(PrimaryItemTransformProperties { @@ -7874,14 +7895,15 @@ mod tests { }; use super::{ ExtractHeicItemDataError, ExtractUncompressedItemDataError, FourCc, - HeicGridPrimaryItemData, HeicPrimaryItemDataWithGrid, IROT_BOX_TYPE, IccColorProfile, - NclxColorProfile, ParseItemLocationBoxError, ParseItemPropertyAssociationBoxError, + HeicGridPrimaryItemData, HeicPrimaryItemDataWithGrid, IMIR_BOX_TYPE, IROT_BOX_TYPE, + IccColorProfile, NclxColorProfile, ParseItemLocationBoxError, + ParseItemPropertyAssociationBoxError, ParsePrimaryItemTransformPropertiesError, PrimaryItemColorProperties, PrimaryItemTransformProperty, extract_primary_heic_item_data_with_grid, extract_primary_heic_item_data_with_grid_from_source, extract_primary_uncompressed_item_data, extract_primary_uncompressed_item_data_from_source, merge_primary_and_grid_tile_color_properties, parse_boxes, parse_iloc_payload, - parse_ipma_payload, primary_heic_color_properties, + parse_ipma_payload, parse_primary_item_transform_properties, primary_heic_color_properties, }; use std::sync::Arc; @@ -8407,6 +8429,98 @@ mod tests { ); } + #[test] + fn primary_repeated_transform_associations_are_rejected() { + let repeats = [2_u8; 255]; + let extra_repeats: Vec<(u16, &[u8])> = (0..257).map(|_| (1_u16, &repeats[..])).collect(); + + for property in [ + identity_clap_box(), + plain_box(b"irot", &[0]), + plain_box(b"imir", &[0]), + ] { + let property_type = FourCc::new(property[4..8].try_into().unwrap()); + let err = parse_primary_item_transform_properties(&minimal_heic_grid_file( + (1, 1), + (16, 16), + &[2], + &[0x11; 16], + &[hvcc_box(), property], + &[1], + &extra_repeats, + )) + .expect_err("repeated primary transform must be rejected"); + assert!( + matches!( + err, + ParsePrimaryItemTransformPropertiesError::DuplicateTransform { + item_id: 1, + property_type: actual, + } if actual == property_type + ), + "{property_type}: {err}" + ); + } + } + + #[test] + fn primary_distinct_properties_of_one_transform_type_are_rejected() { + let err = parse_primary_item_transform_properties(&minimal_heic_grid_file( + (1, 1), + (16, 16), + &[2], + &[0x11; 16], + &[ + hvcc_box(), + plain_box(b"imir", &[0]), + identity_clap_box(), + plain_box(b"imir", &[1]), + ], + &[1], + &[(1, &[2, 3, 4])], + )) + .expect_err("second imir must be rejected"); + assert!(matches!( + err, + ParsePrimaryItemTransformPropertiesError::DuplicateTransform { + property_type, + .. + } if property_type.as_bytes() == IMIR_BOX_TYPE + )); + } + + #[test] + fn primary_transforms_keep_one_of_each_type_in_order() { + let transforms = parse_primary_item_transform_properties(&minimal_heic_grid_file( + (1, 1), + (16, 16), + &[2], + &[0x11; 16], + &[ + hvcc_box(), + identity_clap_box(), + plain_box(b"irot", &[0]), + plain_box(b"imir", &[1]), + ], + &[1], + &[(1, &[2, 3, 4])], + )) + .expect("one transform of each type is valid") + .transforms; + + assert_eq!( + transforms + .iter() + .map(|transform| match transform { + PrimaryItemTransformProperty::CleanAperture(_) => "clap", + PrimaryItemTransformProperty::Rotation(_) => "irot", + PrimaryItemTransformProperty::Mirror(_) => "imir", + }) + .collect::>(), + ["clap", "irot", "imir"] + ); + } + #[test] fn grid_tile_codec_configurations_are_shared_across_duplicate_references() { let nal_count = 65_535_u16; From 75b42dd3abd82fd0cbfeeea1e9417f0046e5f3a7 Mon Sep 17 00:00:00 2001 From: laurenspriem Date: Tue, 3 Nov 2026 12:51:26 +0530 Subject: [PATCH 3/3] Apply the one-per-type transform rule in the bounded decoder decode_bounded parses item properties with its own reader, which only capped the total at 16 transforms, so it still accepted repeated clap, irot or imir on a grid primary or tile that decode_bytes_to_rgba now rejects. Reject a second transform of the same type there too. --- src/bounded/grid.rs | 5 ++ src/bounded/tests.rs | 119 +++++++++++++++++++++++++++++++++++++------ 2 files changed, 108 insertions(+), 16 deletions(-) diff --git a/src/bounded/grid.rs b/src/bounded/grid.rs index 43f17d6..799a44e 100644 --- a/src/bounded/grid.rs +++ b/src/bounded/grid.rs @@ -161,6 +161,11 @@ impl<'a> Properties<'a> { _ => {} } if let Some(transform) = transform { + if result.transforms.iter().flatten().any(|stored| { + std::mem::discriminant(stored) == std::mem::discriminant(&transform) + }) { + return Err(Error::Malformed("duplicate transform property")); + } if result.transform_count == result.transforms.len() { return Err(Error::LimitExceeded("transform count")); } diff --git a/src/bounded/tests.rs b/src/bounded/tests.rs index 8f7fc65..bc71c6e 100644 --- a/src/bounded/tests.rs +++ b/src/bounded/tests.rs @@ -57,13 +57,23 @@ fn fixture_with_exif( extra_properties: &[Vec], orientation: Option, ) -> Vec { - fixture_with_exif_info(configs, payload, extra_properties, orientation, b"Exif\0") + fixture_with_exif_info( + configs, + payload, + extra_properties, + &(0..extra_properties.len()).collect::>(), + &[], + orientation, + b"Exif\0", + ) } fn fixture_with_exif_info( configs: &[Vec], payload: &[u8], extra_properties: &[Vec], + primary_extras: &[usize], + tile_extras: &[usize], orientation: Option, exif_info: &[u8], ) -> Vec { @@ -109,13 +119,20 @@ fn fixture_with_exif_info( ); associations.extend_from_slice(&id.to_be_bytes()); if id == primary { - associations.push(1 + extra_properties.len() as u8); + associations.push(1 + primary_extras.len() as u8); associations.push(0x82); - for i in 0..extra_properties.len() { + for i in primary_extras { associations.push(0x80 | (3 + configs.len() + i) as u8); } } else { - associations.extend_from_slice(&[2, 0x81, 0x80 | (id + 2) as u8]); + associations.extend_from_slice(&[ + 2 + tile_extras.len() as u8, + 0x81, + 0x80 | (id + 2) as u8, + ]); + for i in tile_extras { + associations.push(0x80 | (3 + configs.len() + i) as u8); + } } } let mut exif = Vec::new(); @@ -755,18 +772,28 @@ fn incremental_rejects_unimplemented_chroma_transform_orders() { .into_iter() .flat_map(u32::to_be_bytes) .collect::>(); - for extras in [ - vec![box_bytes(b"irot", &[1]), box_bytes(b"clap", &crop)], - vec![box_bytes(b"clap", &crop), box_bytes(b"clap", &crop)], - ] { - let bytes = fixture(std::slice::from_ref(&config), &nals[3], &extras); - assert!(matches!( - incremental::decode(BoundedInput::Bytes(&bytes), Default::default()), - Err(BoundedDecodeError::Unsupported( - "repeated crop or crop after orientation" - )) - )); - } + let bytes = fixture( + std::slice::from_ref(&config), + &nals[3], + &[box_bytes(b"irot", &[1]), box_bytes(b"clap", &crop)], + ); + assert!(matches!( + incremental::decode(BoundedInput::Bytes(&bytes), Default::default()), + Err(BoundedDecodeError::Unsupported( + "repeated crop or crop after orientation" + )) + )); + let bytes = fixture( + std::slice::from_ref(&config), + &nals[3], + &[box_bytes(b"clap", &crop), box_bytes(b"clap", &crop)], + ); + assert!(matches!( + incremental::decode(BoundedInput::Bytes(&bytes), Default::default()), + Err(BoundedDecodeError::Malformed( + "duplicate transform property" + )) + )); let bytes = fixture( &[config.clone(), config], &nals[3], @@ -1006,6 +1033,8 @@ fn public_decode_applies_associated_exif_after_identity_rotation() { &[config.clone(), config.clone()], &asymmetric_payload(), &[box_bytes(b"irot", &[0])], + &[0], + &[], Some(orientation), exif_info, ); @@ -1123,6 +1152,64 @@ fn render_rejects_workspace_and_geometry_changes_after_preflight() { )); } +#[cfg(not(feature = "decoder-tracing"))] +#[test] +fn rejects_repeated_transform_types_like_normal_decode() { + let nals = nal_sets(); + let config = configuration(&nals[1]); + let crop: Vec<_> = [13u32, 1, 11, 1, 0, 1, 0, 1] + .into_iter() + .flat_map(u32::to_be_bytes) + .collect(); + let mirror = box_bytes(b"imir", &[0]); + let rotation = box_bytes(b"irot", &[1]); + let identity = box_bytes(b"irot", &[0]); + let clean_aperture = box_bytes(b"clap", &crop); + for (properties, primary_extras, tile_extras) in [ + (vec![mirror.clone()], vec![0, 0], vec![]), + (vec![mirror.clone(), mirror], vec![0, 1], vec![]), + (vec![rotation.clone()], vec![0, 0], vec![]), + (vec![identity.clone(), rotation], vec![0, 1], vec![]), + (vec![clean_aperture.clone()], vec![0, 0], vec![]), + ( + vec![clean_aperture.clone(), clean_aperture], + vec![0, 1], + vec![], + ), + (vec![identity.clone()], vec![], vec![0, 0]), + (vec![identity.clone(), identity.clone()], vec![], vec![0, 1]), + ] { + let bytes = fixture_with_exif_info( + std::slice::from_ref(&config), + &nals[3], + &properties, + &primary_extras, + &tile_extras, + None, + b"Exif\0", + ); + assert!(matches!( + decode_bounded(BoundedInput::Bytes(&bytes), Default::default()), + Err(BoundedDecodeError::Malformed( + "duplicate transform property" + )) + )); + assert!(crate::decode_bytes_to_rgb8(&bytes).is_err()); + } + let bytes = fixture_with_exif_info( + std::slice::from_ref(&config), + &nals[3], + &[identity], + &[], + &[0], + None, + b"Exif\0", + ); + let normal = crate::decode_bytes_to_rgb8(&bytes).unwrap(); + let bounded = decode_bounded(BoundedInput::Bytes(&bytes), Default::default()).unwrap(); + assert_eq!(bounded.image.pixels, normal.pixels); +} + #[cfg(not(feature = "decoder-tracing"))] #[test] fn rejects_zero_clean_aperture_denominators_without_panicking() {