Skip to content
Fencer Intel
critical 9.8

HSEC-2026-0017 json

Out-of-bounds writes in BMP RLE and TIFF strip decoding

published 2d ago modified 2d ago

cvss
9.8
version 3.1, OSV
cisa kev
Not listed
not in CISA's catalog
epss
—
no score, EPSS covers CVEs only
public exploits
0
none known

Summary

# Out-of-bounds writes in BMP RLE and TIFF strip decoding

JuicyPixels contains independent out-of-bounds writes reachable from ordinary image decoding (`Codec.Picture.decodeImage` and the format-specific decoders):

1. **BMP `BI_RLE8`/`BI_RLE4`** (`Codec.Picture.Bitmap.decodeImageY8RLE`): the pixel buffer size is computed with 32-bit `Int32` arithmetic and wraps to a zero-length allocation for large headers; end-of-line and vertical-delta control codes move the destination cursor without a bound, and the horizontal delta jump is unclamped. Every run writes attacker-chosen bytes through `M.unsafeWrite` at the cursor position — negative offsets before the raster, arbitrary offsets against a wrapped allocation, and up to 255 bytes past it. 2. **TIFF uncompressed/PackBits contiguous strips** (`Codec.Picture.Tiff.gatherStrips`, `copyByteString`, `unpackPackBit`): strip copies have no destination bound and the per-strip size computation wraps negative for strips starting past the raster, so excess strips copy attacker-chosen bytes past the end of the allocated raster.

Impact: heap memory adjacent to the decoded image is corrupted with attacker-selected values and offsets through maliciously crafted BMP or TIFF files. Beyond corruption, exploitation primitives were demonstrated end-to-end on GHC 9.6 / linux-amd64: a crafted BMP deterministically crashed the process via the wrapped allocation; against a warp-based service a single uploaded BMP overwrote another request's in-memory session blob, observed in the victim's own HTTP response (12 of 12 cycles); and with heap grooming the write primitive was used to redirect a lazily-evaluated top-level `String` passed to `callCommand`, executing attacker-supplied commands (3 of 3 runs). These are relative-offset primitives: the demonstrated RCE depends on heap layout and linkage and is not a guaranteed arbitrary-address write.

The fix, released in 3.3.10, validates the declared pixel count centrally in `decodeBitmapWithPaletteAndMetadata` (cap 2^29 pixels, i.e. 2 GiB of RGBA8), computes all decoder buffer sizes in exact 64-bit `Int` arithmetic, clips out-of-bounds BMP RLE writes to the raster (zero-filling skipped pixels, matching the clipping behaviour of the non-RLE decoders and the Windows WIC decoder), bounds TIFF strip copies at the destination buffer, and clamps strip counts at the raster boundary. Malformed-but-decodable files keep decoding instead of failing.

Residual risk in 3.3.10: the shared GIF/TIFF LZW decoder (`Codec.Picture.Gif.Internal.LZW`) retains an unguarded single-byte KwKwK write reachable from the same TIFF/GIF decode paths; it is documented as a follow-up and is not addressed by this release.

Credit: external vulnerability report by Akash Sebastian (@akashseb) and Tomer Fichman (irregular).

Patch / fix

  • hackage JuicyPixels 3.3.10

Is HSEC-2026-0017 in your dependencies? Fencer shows which of your repositories are affected as soon as an advisory lands, and opens the fix as a pull request.

Check with Fencer

CVSS scores

assigned by version score vector
OSV 3.1 9.8 CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H

Affected packages

ecosystem package affected fixed in
hackage JuicyPixels
>=3.1.3, <3.3.10
3.3.10

References

Sources

Fencer Intel keeps one entry per vulnerability: the CVE id wins, then GHSA, and records that alias each other are merged, except that two CVEs always keep separate entries. The same data is available as JSON.