CVE-2025-64720 : Débordement de tampon dans libpng lors de la prémultiplication de palette

Statut : Corrigé
Gravité : Élevée
CVE ID : CVE-2025-64720
Date de découverte : 2025-11-XX
Divulgation publique : 2025-11-21

Présentation

Résumé

Une vulnérabilité de lecture hors limites existe dans la fonction png_image_read_composite de libpng lors du traitement d'images palette avec PNG_FLAG_OPTIMIZE_ALPHA activé. Le code de composition de palette dans png_init_read_transformations applique incorrectement la composition d'arrière-plan pendant la prémultiplication, violant l'invariant component ≤ alpha × 257 requis par l'API PNG simplifiée, entraînant une corruption mémoire.

---

Détails de la vulnérabilité

Cause racine

Dans png_init_read_transformations à la ligne ~1336, le code d'expansion de palette effectue :

component += (255-alpha)*png_sRGB_table[outrow[c]];

Ce calcul produit des valeurs de component allant jusqu'à 16 776 960 (0x1000800), où (component >> 15) == 512. La macro PNG_sRGB_FROM_LINEAR suivante dans png_image_read_composite effectue un accès hors limites au tableau :

png_sRGB_base[component>>15]    // Accède à png_sRGB_base[512]
png_sRGB_delta[component>>15]   // Accède à png_sRGB_delta[512]
// Les deux tableaux ont seulement des indices 0-511 (taille 512)

Le problème se produit lorsque :

1. Le PNG utilise le mode palette (type de couleur 3) avec transparence (morceau tRNS)
2. L'application utilise l'API simplifiée avec un format compatible alpha
3. PNG_FLAG_OPTIMIZE_ALPHA est activé en interne
4. L'expansion de palette effectue la prémultiplication avec composition d'arrière-plan

Composant vulnérable

• Fichier : pngread.c, pngtrans.c
• Fonctions : png_image_read_composite, png_init_read_transformations
• Chemin de code : API simplifiée → Expansion de palette avec optimisation alpha

Violation d'invariant

Attendu : component ≤ alpha × 257
         Assure (component >> 15) ≤ 511 (dans les limites du tableau)

Réel :   component = previous_value + (255-alpha) × png_sRGB_table[RGB_value]
         Avec alpha=0, RGB=255 : component peut dépasser les limites attendues
         
Résultat :   (component >> 15) peut être égal à 512 (accès hors limites)

---

Versions affectées

Versions vulnérables

• Logiciel : libpng
• Versions : Toutes les versions < 1.6.51
• Plateformes : Linux, Windows, macOS, BSD, etc.
• Architectures : x86, x64, ARM, ARM64, etc.

Versions corrigées

• Première version corrigée : 1.6.51
• Date de publication : 2025-11-21
• Commit du correctif : 08da33b

Détection de version

# Method 1: pkg-config
pkg-config --modversion libpng

# Method 2: Direct library query
libpng-config --version

# Method 3: Check binary
strings /usr/lib/libpng*.so* | grep -i "libpng version"

# Method 4: From source
grep PNG_LIBPNG_VER_STRING png.h

---

Analyse technique

Vecteur d'attaque

Un attaquant peut exploiter cette vulnérabilité en créant un fichier PNG malveillant avec des caractéristiques spécifiques :

1. Prérequis de l'attaque :

   • L'application cible utilise libpng < 1.6.51
   • L'application utilise l'API PNG simplifiée (fonctions png_image_*)
   • L'application demande un format de sortie compatible alpha (par ex. RGBA, ARGB)

2. Étapes de l'attaque :

   • Créer un PNG palette (type de couleur 3) avec un morceau tRNS
   • Définir les entrées de palette sur les valeurs RGB maximales (255, 255, 255)
   • Définir les valeurs alpha à zéro pour plusieurs entrées de palette
   • L'application victime traite le PNG avec le format alpha
   • PNG_FLAG_OPTIMIZE_ALPHA est activé en interne
   • L'expansion de palette viole l'invariant de composant
   • Un accès hors limites au tableau se produit

3. Résultat de l'attaque :

   • Lecture hors limites de png_sRGB_base ou png_sRGB_delta
   • Corruption mémoire entraînant une utilisation après libération
   • Plantage de l'application (déni de service)
   • Divulgation potentielle d'informations via lecture hors limites

Disposition mémoire

┌─────────────────┐
│ png_sRGB_base   │  Array indices: 0-511 (512 entries)
│ [512 entries]   │  Valid access: (component >> 15) ≤ 511
├─────────────────┤
│ [OOB Access]    │  Index 512 ← Vulnerable access when component ≥ 0x1000000
├─────────────────┤
│ png_sRGB_delta  │  Array indices: 0-511 (512 entries)
│ [512 entries]   │  Also vulnerable to same OOB access
├─────────────────┤
│ Adjacent Memory │  Potential information disclosure
└─────────────────┘

Calculation that causes overflow:
component = alpha × component + (255-alpha) × png_sRGB_table[palette_RGB]

When alpha=0 and palette_RGB=255:
component = 0 + 255 × 65535 = 16,711,425
(component >> 15) = 512 (OUT OF BOUNDS!)

Conditions de déclenchement

Conditions requises :

• Type de couleur PNG 3 (indexé/palette)
• Morceau tRNS présent (transparence)
• Valeurs alpha de 0 dans le morceau tRNS
• Valeurs RGB élevées dans la palette (surtout 255, 255, 255)
• Utilisation de l'API simplifiée (png_image_finish_read)
• Format compatible alpha (PNG_FORMAT_ARGB, PNG_FORMAT_RGBA avec drapeaux)

Facteurs optionnels :

• Le format avec PNG_FORMAT_FLAG_AFIRST augmente la probabilité de plantage
• Des images plus grandes offrent plus d'opportunités de déclencher le bogue
• Plusieurs entrées de palette avec alpha nul augmentent la fiabilité

Conditions non déclenchantes :

• libpng >= 1.6.51 (corrigé)
• PNG_FORMAT_RGBA sans drapeaux supplémentaires (parfois sûr)
• Types de couleurs non palette (RGB, niveaux de gris, etc.)
• Palette sans transparence
• Toutes les valeurs alpha = 255 (entièrement opaque)

---

Preuve de concept

Démarrage rapide

# Clone repository
git clone https://github.com/truediogo/CVE-2025-64720
cd CVE-2025-64720

# Generate images
python3 generate-images.py

# Build test
chmod +x build.sh
./build.sh

# Run exploit (requires vulnerable libpng < 1.6.51)
./test_asan exploit_v1.png exploit_v2.png exploit_v3.png exploit_v4.png

Composants de la PoC

1. Générateur d'exploit (generate-images.py)

Génère des fichiers PNG malveillants qui déclenchent la vulnérabilité.

Utilisation :

python3 generate_poc.py

Sortie :

• exploit_v1.png - Image 8x8, palette blanche uniforme, alpha nul
• exploit_v2.png - Image 8x8, variation de palette stratégique
• exploit_v3.png - Image 64x64, grande avec motifs répétés
• exploit_v4.png - Image 4x4, cas minimal avec alpha nul partout

Options :

# Generate specific variant
generate_malicious_png('custom.png', variant=2)

# Variants:
# 1: Maximum RGB values with zero alpha (reliable)
# 2: Strategic palette designed for maximum overflow
# 3: Larger image with repeated triggering patterns
# 4: Minimal case targeting global-buffer-overflow

2. Test (test.c)

Traite les fichiers PNG en utilisant l'API simplifiée et démontre la vulnérabilité.

Compilation :

# With AddressSanitizer (recommended - best detection)
gcc -o test_asan test.c -lpng -fsanitize=address -g -O0 -fno-omit-frame-pointer

# With UndefinedBehaviorSanitizer
gcc -o test_ubsan test.c -lpng -fsanitize=undefined -g -O0

# With debugging symbols
gcc -o test_debug test.c -lpng -g -O0

# For Valgrind
gcc -o test_valgrind test.c -lpng -g -O0 -fno-inline

Fonctionnalités :

• Teste plusieurs formats compatibles alpha (RGBA, ARGB, LINEAR_RGB_ALPHA)
• Affiche la version de libpng et le statut de la vulnérabilité
• Montre les valeurs du premier pixel pour vérification
• Gestion complète des erreurs

Sortie attendue

Sur version vulnérable (libpng 1.6.36) :

libpng version: 1.6.36
PNG_LIBPNG_VER: 10636