feat(images): decode bounded ICO resources

Admit ICO in the shared image capability table and decode real PNG and BMP directory frames. Keep PNG frames on the existing bounded color-managed codec, with an explicit orientation policy so embedded Exif does not rotate ICO frames. BMP frames retain palette and AND-mask decoding.

Cover real pixels, directory selection, precision, malformed entries and metadata-only probing. Retain unsupported-format rejection using TIFF now that ICO is supported.
This commit is contained in:
ldm0
2026-11-22 02:02:03 +08:00
parent efe44e00e7
commit 1cfccd72cf
7 changed files with 369 additions and 15 deletions
Generated
+1
View File
@@ -2169,6 +2169,7 @@ dependencies = [
"image-webp",
"moxcms",
"num-traits",
"png",
]
[[package]]
+1 -1
View File
@@ -6,7 +6,7 @@ license = "MIT OR Apache-2.0"
[dependencies]
color = "0.3.3"
image = { version = "0.25.10", default-features = false, features = ["bmp", "gif", "webp"] }
image = { version = "0.25.10", default-features = false, features = ["bmp", "gif", "ico", "webp"] }
jpeg-decoder = "0.3"
jpeg-encoder = "0.6"
moxcms = { version = "0.8.1", features = ["extended_range"] }
+116
View File
@@ -0,0 +1,116 @@
//! ICO directory inspection for the bounded, color-managed PNG codec path.
//! BMP icons use the image decoder's palette and AND-mask handling.
use crate::{PngDecodeError, RasterColorPrecision, png::PngOrientation};
#[derive(Debug, thiserror::Error)]
pub enum IcoDecodeError {
#[error("invalid ICO directory")]
InvalidDirectory,
#[error("ICO image entry is outside the encoded buffer")]
InvalidEntry,
#[error("ICO directory dimensions do not match its PNG image")]
DimensionMismatch,
#[error(transparent)]
Png(#[from] PngDecodeError),
}
pub(super) struct PngIcon<'a> {
bytes: &'a [u8],
width: u32,
height: u32,
}
impl PngIcon<'_> {
pub(super) fn metadata(&self) -> Result<(u32, u32, RasterColorPrecision), IcoDecodeError> {
// Exif belongs to a standalone PNG. ICO directory frames retain their
// encoded orientation, including when the selected frame is a PNG.
let metadata =
crate::png::png_metadata_with_orientation(self.bytes, PngOrientation::Ignore)?;
// A zero directory byte denotes 256, including larger embedded PNGs.
if metadata.0.min(256) != self.width || metadata.1.min(256) != self.height {
return Err(IcoDecodeError::DimensionMismatch);
}
Ok(metadata)
}
pub(super) fn decode(
&self,
convert_profile: bool,
) -> Result<crate::color::DecodedColorPixels, IcoDecodeError> {
self.metadata()?;
Ok(crate::png::decode_png_colors_with_orientation(
self.bytes,
convert_profile,
PngOrientation::Ignore,
)?)
}
}
fn u16_le(bytes: &[u8]) -> u16 {
u16::from_le_bytes(bytes[..2].try_into().expect("ICO directory field"))
}
fn u32_le(bytes: &[u8]) -> u32 {
u32::from_le_bytes(bytes[..4].try_into().expect("ICO directory field"))
}
fn dimension(value: u8) -> u32 {
if value == 0 { 256 } else { u32::from(value) }
}
fn entry_score(entry: &[u8]) -> (u16, u32) {
// Match the underlying ICO decoder's frame choice, including its last-entry
// tie break, so metadata and pixel decoding always refer to the same frame.
(
u16_le(&entry[6..]),
dimension(entry[0]) * dimension(entry[1]),
)
}
pub(super) fn png_icon(bytes: &[u8]) -> Result<Option<PngIcon<'_>>, IcoDecodeError> {
let header = bytes.get(..6).ok_or(IcoDecodeError::InvalidDirectory)?;
if header[..4] != [0, 0, 1, 0] {
return Err(IcoDecodeError::InvalidDirectory);
}
let count = usize::from(u16_le(&header[4..]));
if count == 0 {
return Err(IcoDecodeError::InvalidDirectory);
}
let directory_end = 6 + count * 16;
let directory = bytes
.get(6..directory_end)
.ok_or(IcoDecodeError::InvalidDirectory)?;
let mut selected: Option<&[u8]> = None;
for entry in directory.as_chunks::<16>().0 {
if u16_le(&entry[4..]) > 256 || u16_le(&entry[6..]) > 256 {
return Err(IcoDecodeError::InvalidDirectory);
}
if selected.is_none_or(|previous| entry_score(entry) >= entry_score(previous)) {
selected = Some(entry);
}
}
let selected = selected.expect("non-empty ICO directory");
let offset =
usize::try_from(u32_le(&selected[12..])).map_err(|_| IcoDecodeError::InvalidEntry)?;
let length =
usize::try_from(u32_le(&selected[8..])).map_err(|_| IcoDecodeError::InvalidEntry)?;
let end = offset
.checked_add(length)
.ok_or(IcoDecodeError::InvalidEntry)?;
if offset < directory_end {
return Err(IcoDecodeError::InvalidEntry);
}
let payload = bytes.get(offset..end).ok_or(IcoDecodeError::InvalidEntry)?;
if !payload.starts_with(b"\x89PNG\r\n\x1a\n") {
return Ok(None);
}
Ok(Some(PngIcon {
bytes: payload,
width: dimension(selected[0]),
height: dimension(selected[1]),
}))
}
#[cfg(test)]
mod tests;
+177
View File
@@ -0,0 +1,177 @@
use super::*;
use crate::{
RasterDecodeError, RasterImageFormat, decode_raster_image, probe_raster_image,
raster_image_dimensions, supports_image_mime_essence,
};
fn icon(entries: &[(u8, u8, u16, &[u8])]) -> Vec<u8> {
let mut bytes = vec![0, 0, 1, 0];
bytes.extend_from_slice(&u16::try_from(entries.len()).unwrap().to_le_bytes());
let mut offset = 6 + entries.len() * 16;
for &(width, height, depth, payload) in entries {
bytes.extend_from_slice(&[width, height, 0, 0]);
bytes.extend_from_slice(&1_u16.to_le_bytes());
bytes.extend_from_slice(&depth.to_le_bytes());
bytes.extend_from_slice(&u32::try_from(payload.len()).unwrap().to_le_bytes());
bytes.extend_from_slice(&u32::try_from(offset).unwrap().to_le_bytes());
offset += payload.len();
}
for &(_, _, _, payload) in entries {
bytes.extend_from_slice(payload);
}
bytes
}
fn png() -> Vec<u8> {
crate::encode_png_rgba8(2, 1, &[255, 0, 0, 255, 0, 0, 255, 128])
.unwrap()
.bytes
}
#[test]
fn png_icons_share_bounded_metadata_and_transparent_pixels() {
let png = png();
let bytes = icon(&[(2, 1, 32, &png)]);
let metadata = probe_raster_image(&bytes).unwrap();
assert_eq!(metadata.format, RasterImageFormat::Ico);
assert_eq!(metadata.decoded_byte_len(), 8);
assert_eq!(raster_image_dimensions(&bytes).unwrap(), (2, 1));
assert_eq!(
decode_raster_image(&bytes).unwrap().image,
crate::decode_png(&png).unwrap()
);
for essence in ["image/x-icon", "image/vnd.microsoft.icon"] {
assert!(supports_image_mime_essence(essence), "{essence}");
}
}
#[test]
fn png_icons_retain_full_precision_samples() {
let mut png = Vec::new();
{
let mut encoder = png::Encoder::new(&mut png, 1, 1);
encoder.set_color(png::ColorType::Rgba);
encoder.set_depth(png::BitDepth::Sixteen);
let mut writer = encoder.write_header().unwrap();
writer
.write_image_data(&[0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xff, 0xff])
.unwrap();
writer.finish().unwrap();
}
let plain = decode_raster_image(&png).unwrap();
let wrapped = decode_raster_image(&icon(&[(1, 1, 32, &png)])).unwrap();
assert_eq!(
wrapped.metadata.color_precision,
RasterColorPrecision::Float32
);
assert_eq!(wrapped.image, plain.image);
assert!(wrapped.color_managed.is_some());
assert_eq!(wrapped.color_managed, plain.color_managed);
}
#[test]
fn png_icon_frames_ignore_embedded_exif_orientation() {
let exif = b"II*\0\x08\0\0\0\x01\0\x12\x01\x03\0\x01\0\0\0\x06\0\0\0\0\0\0\0";
let mut info = png::Info::with_size(2, 1);
info.color_type = png::ColorType::Rgba;
info.exif_metadata = Some(std::borrow::Cow::Borrowed(exif));
let mut png = Vec::new();
{
let mut writer = png::Encoder::with_info(&mut png, info)
.unwrap()
.write_header()
.unwrap();
writer
.write_image_data(&[255, 0, 0, 255, 0, 0, 255, 255])
.unwrap();
writer.finish().unwrap();
}
let bytes = icon(&[(2, 1, 32, &png)]);
assert_eq!(raster_image_dimensions(&bytes).unwrap(), (2, 1));
let decoded = decode_raster_image(&bytes).unwrap();
assert_eq!((decoded.image.width, decoded.image.height), (2, 1));
assert_eq!(decoded.image.rgba, [255, 0, 0, 255, 0, 0, 255, 255]);
}
#[test]
fn bmp_icons_apply_bottom_up_rows_and_the_and_mask() {
let mut dib = Vec::new();
dib.extend_from_slice(&40_u32.to_le_bytes());
dib.extend_from_slice(&2_i32.to_le_bytes());
dib.extend_from_slice(&4_i32.to_le_bytes()); // XOR pixels and AND mask share the height.
dib.extend_from_slice(&1_u16.to_le_bytes());
dib.extend_from_slice(&24_u16.to_le_bytes());
dib.extend_from_slice(&0_u32.to_le_bytes());
dib.extend_from_slice(&24_u32.to_le_bytes());
dib.extend_from_slice(&[0; 16]);
dib.extend_from_slice(&[
255, 0, 0, 255, 255, 255, 0, 0, // blue, white, padding (bottom row)
0, 0, 255, 0, 255, 0, 0, 0, // red, green, padding (top row)
0x80, 0, 0, 0, // bottom-left pixel is transparent
0, 0, 0, 0,
]);
let bytes = icon(&[(2, 2, 24, &dib)]);
assert_eq!(raster_image_dimensions(&bytes).unwrap(), (2, 2));
assert_eq!(
decode_raster_image(&bytes).unwrap().image.rgba,
[
255, 0, 0, 255, 0, 255, 0, 255, 0, 0, 255, 0, 255, 255, 255, 255,
]
);
}
#[test]
fn icon_metadata_and_decode_select_the_same_directory_entry() {
let large = png();
let small = crate::encode_png_rgba8(1, 1, &[0, 255, 0, 255])
.unwrap()
.bytes;
for bytes in [
icon(&[(1, 1, 32, &small), (2, 1, 32, &large)]),
icon(&[(2, 1, 32, &large), (1, 1, 32, &small)]),
] {
assert_eq!(raster_image_dimensions(&bytes).unwrap(), (2, 1));
assert_eq!(
decode_raster_image(&bytes).unwrap().image,
crate::decode_png(&large).unwrap()
);
}
}
#[test]
fn png_icon_metadata_does_not_inflate_the_pixel_payload() {
let mut png = png();
let idat = png.windows(4).position(|chunk| chunk == b"IDAT").unwrap();
png[idat + 4] ^= 0xff;
let bytes = icon(&[(2, 1, 32, &png)]);
assert_eq!(raster_image_dimensions(&bytes).unwrap(), (2, 1));
assert!(decode_raster_image(&bytes).is_err());
}
#[test]
fn icon_probe_rejects_invalid_directories_offsets_and_dimensions() {
assert!(matches!(
probe_raster_image(b"\0\0\x01\0\0\0"),
Err(RasterDecodeError::Ico(IcoDecodeError::InvalidDirectory))
));
let png = png();
let bytes = icon(&[(2, 1, 32, &png)]);
for end in [5, 6, 21, bytes.len() - 1] {
assert!(
probe_raster_image(&bytes[..end]).is_err(),
"truncated at {end}"
);
}
for offset in [0_u32, u32::MAX] {
let mut invalid = bytes.clone();
invalid[18..22].copy_from_slice(&offset.to_le_bytes());
assert!(matches!(
probe_raster_image(&invalid),
Err(RasterDecodeError::Ico(IcoDecodeError::InvalidEntry))
));
}
assert!(matches!(
probe_raster_image(&icon(&[(1, 1, 32, &png)])),
Err(RasterDecodeError::Ico(IcoDecodeError::DimensionMismatch))
));
}
+2
View File
@@ -9,6 +9,7 @@ mod budget;
mod color;
#[cfg(test)]
mod color_tests;
mod ico;
mod jpeg;
mod orientation;
#[cfg(test)]
@@ -22,6 +23,7 @@ pub use budget::{MAX_DECODED_RGBA_BYTES, MAX_ENCODED_IMAGE_BYTES};
pub use color::{
ColorDecodeError, ColorManagedRasterImage, RasterColorPrecision, UnconvertedRasterPixels,
};
pub use ico::IcoDecodeError;
pub use jpeg::{EncodedJpeg, JpegDecodeError, JpegEncodeError, decode_jpeg, encode_jpeg};
pub use png::{
EncodedPng, PngDecodeError, PngEncodeError, PngEncodeOptions, decode_png, encode_png,
+32 -2
View File
@@ -114,9 +114,32 @@ pub fn decode_png(bytes: &[u8]) -> Result<RgbaImage, PngDecodeError> {
decode_png_colors(bytes, true).map(|(image, _)| image)
}
#[derive(Clone, Copy)]
pub(crate) enum PngOrientation {
FromExif,
Ignore,
}
impl PngOrientation {
fn resolve(self, exif: Option<&[u8]>) -> image::metadata::Orientation {
match self {
Self::FromExif => crate::orientation::from_exif(exif),
Self::Ignore => image::metadata::Orientation::NoTransforms,
}
}
}
pub(crate) fn decode_png_colors(
bytes: &[u8],
convert_profile: bool,
) -> Result<crate::color::DecodedColorPixels, PngDecodeError> {
decode_png_colors_with_orientation(bytes, convert_profile, PngOrientation::FromExif)
}
pub(crate) fn decode_png_colors_with_orientation(
bytes: &[u8],
convert_profile: bool,
orientation: PngOrientation,
) -> Result<crate::color::DecodedColorPixels, PngDecodeError> {
use crate::color::{ColorSamples, RawColorImage};
let mut decoder = png::Decoder::new_with_limits(
@@ -128,7 +151,7 @@ pub(crate) fn decode_png_colors(
decoder.set_transformations(png::Transformations::EXPAND);
let mut reader = decoder.read_info()?;
let (width, height) = (reader.info().width, reader.info().height);
let orientation = crate::orientation::from_exif(reader.info().exif_metadata.as_deref());
let orientation = orientation.resolve(reader.info().exif_metadata.as_deref());
checked_rgba_len(width, height)?;
let cicp = cicp_profile(reader.info());
let expand_gray = cicp.is_some();
@@ -196,6 +219,13 @@ pub(crate) fn decode_png_colors(
pub(crate) fn png_metadata(
bytes: &[u8],
) -> Result<(u32, u32, crate::RasterColorPrecision), PngDecodeError> {
png_metadata_with_orientation(bytes, PngOrientation::FromExif)
}
pub(crate) fn png_metadata_with_orientation(
bytes: &[u8],
orientation: PngOrientation,
) -> Result<(u32, u32, crate::RasterColorPrecision), PngDecodeError> {
let decoder = png::Decoder::new_with_limits(
Cursor::new(bytes),
@@ -208,7 +238,7 @@ pub(crate) fn png_metadata(
let (width, height) = crate::orientation::dimensions(
info.width,
info.height,
crate::orientation::from_exif(info.exif_metadata.as_deref()),
orientation.resolve(info.exif_metadata.as_deref()),
);
checked_rgba_len(info.width, info.height)?;
let high_precision = info.bit_depth == png::BitDepth::Sixteen
+40 -12
View File
@@ -21,6 +21,7 @@ pub enum RasterImageFormat {
Gif,
WebP,
Bmp,
Ico,
}
impl RasterImageFormat {
@@ -31,6 +32,7 @@ impl RasterImageFormat {
ImageFormat::Gif => Some(Self::Gif),
ImageFormat::WebP => Some(Self::WebP),
ImageFormat::Bmp => Some(Self::Bmp),
ImageFormat::Ico => Some(Self::Ico),
_ => None,
}
}
@@ -97,6 +99,8 @@ pub enum RasterDecodeError {
Png(#[from] PngDecodeError),
#[error("JPEG image could not be decoded: {0}")]
Jpeg(#[from] JpegDecodeError),
#[error("ICO image could not be decoded: {0}")]
Ico(#[from] crate::IcoDecodeError),
#[error("{format:?} image could not be decoded: {source}")]
Image {
format: RasterImageFormat,
@@ -123,10 +127,22 @@ pub fn probe_raster_image(bytes: &[u8]) -> Result<RasterImageMetadata, RasterDec
let format = image::guess_format(bytes).map_err(|_| RasterDecodeError::UnknownFormat)?;
let admitted = RasterImageFormat::from_image_format(format)
.ok_or(RasterDecodeError::UnsupportedFormat(format))?;
let (width, height, color_precision) = match admitted {
RasterImageFormat::Png => png_metadata(bytes)?,
RasterImageFormat::Jpeg => jpeg_metadata(bytes)?,
RasterImageFormat::Gif | RasterImageFormat::WebP | RasterImageFormat::Bmp => {
let png_icon = if admitted == RasterImageFormat::Ico {
crate::ico::png_icon(bytes)?
} else {
None
};
let (width, height, color_precision) = match (admitted, png_icon) {
(RasterImageFormat::Png, _) => png_metadata(bytes)?,
(RasterImageFormat::Jpeg, _) => jpeg_metadata(bytes)?,
(RasterImageFormat::Ico, Some(icon)) => icon.metadata()?,
(
RasterImageFormat::Gif
| RasterImageFormat::WebP
| RasterImageFormat::Bmp
| RasterImageFormat::Ico,
_,
) => {
let mut reader = ImageReader::with_format(BufReader::new(Cursor::new(bytes)), format);
reader.limits(decode_limits());
let mut decoder = reader.into_decoder().map_err(RasterDecodeError::Metadata)?;
@@ -206,14 +222,27 @@ fn decode_raster(
) -> Result<DecodedRasterImage, RasterDecodeError> {
check_encoded_budget(bytes)?;
let convert_profile = matches!(conversion, ColorProfileConversion::Apply);
let (image, color_managed) = match metadata.format {
RasterImageFormat::Png => decode_png_colors(bytes, convert_profile)?,
RasterImageFormat::Jpeg => decode_jpeg_colors(bytes, convert_profile)?,
format @ (RasterImageFormat::Gif | RasterImageFormat::WebP | RasterImageFormat::Bmp) => {
let png_icon = if metadata.format == RasterImageFormat::Ico {
crate::ico::png_icon(bytes)?
} else {
None
};
let (image, color_managed) = match (metadata.format, png_icon) {
(RasterImageFormat::Png, _) => decode_png_colors(bytes, convert_profile)?,
(RasterImageFormat::Jpeg, _) => decode_jpeg_colors(bytes, convert_profile)?,
(RasterImageFormat::Ico, Some(icon)) => icon.decode(convert_profile)?,
(
format @ (RasterImageFormat::Gif
| RasterImageFormat::WebP
| RasterImageFormat::Bmp
| RasterImageFormat::Ico),
_,
) => {
let image_format = match format {
RasterImageFormat::Gif => ImageFormat::Gif,
RasterImageFormat::WebP => ImageFormat::WebP,
RasterImageFormat::Bmp => ImageFormat::Bmp,
RasterImageFormat::Ico => ImageFormat::Ico,
RasterImageFormat::Png | RasterImageFormat::Jpeg => unreachable!(),
};
let mut reader =
@@ -328,11 +357,10 @@ mod tests {
probe_raster_image(b"not an image"),
Err(RasterDecodeError::UnknownFormat)
));
// Minimal ICO signature is enough for format identification; the
// browser resource contract intentionally admits only its named set.
// Recognizing a format does not enable codecs outside the admitted set.
assert!(matches!(
probe_raster_image(b"\0\0\x01\0\0\0\0\0\0\0\0\0\0\0\0\0"),
Err(RasterDecodeError::UnsupportedFormat(ImageFormat::Ico))
probe_raster_image(b"II\x2a\0\0\0\0\0"),
Err(RasterDecodeError::UnsupportedFormat(ImageFormat::Tiff))
));
}