Adjust tests for ImageReader limits usage

Author: 197g

fuzz/fuzzers/fuzzer_script_exr.rs

@@ -17,7 +17,7 @@ fn roundtrip(bytes: &[u8]) -> ImageResult<()> {
     // TODO this method should probably already exist in the main image crate
     fn read_as_rgba_byte_image(read: impl BufRead + Seek) -> ImageResult<(u32, u32, Vec<u8>)> {
         let mut decoder = OpenExrDecoder::with_alpha_preference(read, Some(true))?;
-        match usize::try_from(decoder.total_bytes()) {
+        match usize::try_from(decoder.peek_layout()?.total_bytes()) {
             Ok(decoded_size) if decoded_size <= 256 * 1024 * 1024 => {
                 decoder.set_limits(Limits::default())?;
                 let (width, height) = decoder.dimensions();

fuzz/fuzzers/fuzzer_script_tga.rs

@@ -8,11 +8,11 @@ fuzz_target!(|data: &[u8]| {
 
 fn decode(data: &[u8]) -> Result<(), image::ImageError> {
     use image::ImageDecoder;
-    let decoder = image::codecs::tga::TgaDecoder::new(std::io::Cursor::new(data))?;
-    if decoder.total_bytes() > 4_000_000 {
+    let mut decoder = image::codecs::tga::TgaDecoder::new(std::io::Cursor::new(data))?;
+    if decoder.peek_layout()?.total_bytes() > 4_000_000 {
         return Ok(());
     }
-    let mut buffer = vec![0; decoder.total_bytes() as usize];
+    let mut buffer = vec![0; decoder.peek_layout()?.total_bytes() as usize];
     decoder.read_image(&mut buffer)?;
     Ok(())
 }

tests/limits.rs

@@ -51,7 +51,10 @@ fn permissive_limits() -> Limits {
     let mut limits = Limits::no_limits();
     limits.max_image_width = Some(WIDTH);
     limits.max_image_height = Some(HEIGHT);
-    limits.max_alloc = Some((WIDTH * HEIGHT * 5).into()); // `* 3`` would be an exact fit for RGB; `* 5`` allows some slack space
+    // `* 3`` would be an exact fit for RGB;
+    // `* 6` allows a duplicate buffer (ImageReader and internal)
+    // `* 8` gives some slack for reserving half in ImageReader
+    limits.max_alloc = Some((WIDTH * HEIGHT * 8).into());
     limits
 }
 
@@ -153,7 +156,8 @@ fn tiff() {
     // so there is a copy from the buffer allocated by `tiff` to a buffer allocated by `image`.
     // This results in memory usage overhead the size of the output buffer.
     let mut tiff_permissive_limits = permissive_limits();
-    tiff_permissive_limits.max_alloc = Some((WIDTH * HEIGHT * 10).into()); // `* 9` would be exactly three output buffers, `* 10`` has some slack space
+    // `* 6` would be exactly two output buffers, `* 12`` accounts for ImageReader taking half.
+    tiff_permissive_limits.max_alloc = Some((WIDTH * HEIGHT * 12).into());
     load_through_reader(&image, ImageFormat::Tiff, tiff_permissive_limits).unwrap();
 
     // image::ImageReader