diff --git a/crates/doc/src/decode.rs b/crates/doc/src/decode.rs
index 24dea325f7..11d1b2d72b 100644
--- a/crates/doc/src/decode.rs
+++ b/crates/doc/src/decode.rs
@@ -23,8 +23,9 @@ pub fn decode_image(format: craft_image_codecs::Format, bytes: &[u8], allowance:
/// `bytes` decoded within `max` bytes, counted as the file's samples and as RGBA (#1717), the
/// pixels as stored and as the image crate gave them, with the ICC profile the file embeds.
/// Image blobs read their pixels with it. `Ok(None)` when they would take more than `max` as
-/// samples or as RGBA, or when the decode needs more than `max`. `Err` when the bytes aren't an
-/// image the decoder reads.
+/// samples or as RGBA (the header alone decides; the pixels are not read). `Err` when the bytes
+/// aren't an image the decoder reads, including a file whose header fits the allowance but whose
+/// pixels can't be decoded (a cut-short file, or one the decoder refuses as a decompression bomb).
pub fn decode_within(bytes: &[u8], max: u64) -> Result, craft_image_codecs::CodecError> {
let format = craft_image_codecs::detect(bytes).ok_or(craft_image_codecs::CodecError::UnknownFormat)?;
let (w, h, per_pixel) =
@@ -33,11 +34,7 @@ pub fn decode_within(bytes: &[u8], max: u64) -> Result , cra
if pixels.saturating_mul(per_pixel) > max || pixels.saturating_mul(4) > max {
return Ok(None);
}
- match decode_image(format, bytes, max) {
- Ok(img) => Ok(Some(img)),
- Err(craft_image_codecs::CodecError::LimitExceeded(_)) => Ok(None),
- Err(e) => Err(e),
- }
+ decode_image(format, bytes, max).map(Some)
}
/// A decoded image as the image crate's: 8- and 16-bit gray, gray and alpha, RGB and RGBA as they
diff --git a/crates/doc/src/links.rs b/crates/doc/src/links.rs
index 4a2c36c09a..b8a9998fda 100644
--- a/crates/doc/src/links.rs
+++ b/crates/doc/src/links.rs
@@ -145,9 +145,9 @@ impl ImageBlob {
/// This blob after its pixels are decoded once, within [`crate::MAX_RASTER_ALLOC`], to check
/// that they can be read; with `proxy`, it also gets the preview [`Self::with_proxy`] makes,
/// made from that decode. `None` when the pixels can't be read, as with a file cut short that
- /// has a header but not all its pixels. An image whose pixels would take more than the
- /// allowance as RGBA is not decoded, and one whose decode needs more than the allowance stops
- /// decoding; either is returned as it is.
+ /// has a header but not all its pixels, or one the decoder refuses as a decompression bomb.
+ /// An image whose pixels would take more than the allowance as RGBA is not decoded and is
+ /// returned as it is.
pub fn checked_with_proxy(self, proxy: bool) -> Option {
self.checked_with_pixels(proxy).map(|(blob, _)| blob)
}
@@ -733,4 +733,37 @@ mod tests {
assert!(p.pixels().all(|q| q.0 == [200, 30, 30, 128]), "{:?}", p.get_pixel(0, 0));
}
}
+
+ /// A PNG that says it is `w` × `h` 1-bit grey pixels (header and a stub IDAT, no rows).
+ fn png_header_1bit(w: u32, h: u32) -> Vec {
+ let mut out = vec![0x89, b'P', b'N', b'G', 0x0D, 0x0A, 0x1A, 0x0A];
+ let push = |out: &mut Vec, chunk: &[u8]| {
+ out.extend((chunk.len() as u32 - 4).to_be_bytes());
+ out.extend(chunk);
+ out.extend(crc32(chunk).to_be_bytes());
+ };
+ let mut ihdr = b"IHDR".to_vec();
+ ihdr.extend(w.to_be_bytes());
+ ihdr.extend(h.to_be_bytes());
+ ihdr.extend([1, 0, 0, 0, 0]);
+ push(&mut out, &ihdr);
+ push(&mut out, b"IDAT\x78\x9c");
+ push(&mut out, b"IEND");
+ out
+ }
+
+ /// A header-only 23,170 × 23,170 1-bit gray PNG is within the 2 GiB RGBA allowance, so Place
+ /// decodes it and must refuse it (no pixel rows). 23,171 × 23,170 is past the allowance and is
+ /// kept unread, not refused. craft-image-codecs reports the cut-short file as LimitExceeded
+ /// (its decompression-bomb guard); that is still "pixels can't be read", not "past the allowance".
+ #[test]
+ fn a_gray_header_within_the_allowance_is_unreadable() {
+ let within = png_header_1bit(23_170, 23_170);
+ let over = png_header_1bit(23_171, 23_170);
+ assert!(crate::decode::decode_within(&within, crate::MAX_RASTER_ALLOC).is_err(), "header-only within the allowance");
+ assert!(matches!(crate::decode::decode_within(&over, crate::MAX_RASTER_ALLOC), Ok(None)), "past the allowance is not decoded");
+ assert!(ImageBlob::new("image/png", within).checked_with_pixels(false).is_none(), "Place refuses the file");
+ let (_, pixels) = ImageBlob::new("image/png", over).checked_with_pixels(false).expect("past the allowance is kept unread");
+ assert!(pixels.is_none());
+ }
}