CVE-2025-64720: Overflow del buffer in libpng nella premoltiplicazione della palette

Stato: Corretto
Gravità: Alta
ID CVE: CVE-2025-64720
Data di scoperta: 2025-11-XX
Divulgazione pubblica: 2025-11-21

Panoramica

Riepilogo

Esiste una vulnerabilità di lettura fuori dai limiti nella funzione png_image_read_composite di libpng durante l'elaborazione di immagini con palette con PNG_FLAG_OPTIMIZE_ALPHA abilitato. Il codice di composizione della palette in png_init_read_transformations applica erroneamente la composizione dello sfondo durante la premoltiplicazione, violando l'invariante component ≤ alpha × 257 richiesto dall'API PNG semplificata, causando corruzione della memoria.

---

Dettagli della vulnerabilità

Causa principale

In png_init_read_transformations alla riga ~1336, il codice di espansione della palette esegue:

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

Questo calcolo produce valori di component fino a 16.776.960 (0x1000800), dove (component >> 15) == 512. La successiva macro PNG_sRGB_FROM_LINEAR in png_image_read_composite esegue un accesso all'array fuori dai limiti:

png_sRGB_base[component>>15]    // Accede a png_sRGB_base[512]
png_sRGB_delta[component>>15]   // Accede a png_sRGB_delta[512]
// Entrambi gli array hanno indici solo da 0 a 511 (dimensione 512)

Il problema si verifica quando:

1. Il PNG utilizza la modalità palette (tipo colore 3) con trasparenza (chunk tRNS)
2. L'applicazione utilizza l'API semplificata con formato alpha-capable
3. PNG_FLAG_OPTIMIZE_ALPHA è abilitato internamente
4. L'espansione della palette esegue la premoltiplicazione con composizione dello sfondo

Componente vulnerabile

• File: pngread.c, pngtrans.c
• Funzioni: png_image_read_composite, png_init_read_transformations
• Percorso del codice: API semplificata → Espansione della palette con ottimizzazione alpha

Violazione dell'invariante

Previsto: component ≤ alpha × 257
         Garantisce che (component >> 15) ≤ 511 (entro i limiti dell'array)

Reale:   component = previous_value + (255-alpha) × png_sRGB_table[RGB_value]
         Con alpha=0, RGB=255: component può superare i limiti previsti
         
Risultato:   (component >> 15) può essere uguale a 512 (accesso fuori dai limiti)

---

Versioni interessate

Versioni vulnerabili

• Software: libpng
• Versioni: Tutte le versioni < 1.6.51
• Piattaforme: Linux, Windows, macOS, BSD, ecc.
• Architetture: x86, x64, ARM, ARM64, ecc.

Versioni corrette

• Prima versione corretta: 1.6.51
• Data di rilascio: 2025-11-21
• Commit della patch: 08da33b

Rilevamento della versione

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

# Metodo 2: Query diretta alla libreria
libpng-config --version

# Metodo 3: Controllo del binario
strings /usr/lib/libpng*.so* | grep -i "libpng version"

# Metodo 4: Dal sorgente
grep PNG_LIBPNG_VER_STRING png.h

---

Analisi tecnica

Vettore d'attacco

Un attaccante può sfruttare questa vulnerabilità creando un file PNG dannoso con caratteristiche specifiche:

1. Prerequisiti dell'attacco:

   • L'applicazione target utilizza libpng < 1.6.51
   • L'applicazione utilizza l'API PNG semplificata (funzioni png_image_*)
   • L'applicazione richiede un formato di output alpha-capable (es. RGBA, ARGB)

2. Fasi dell'attacco:

   • Creare un PNG con palette (tipo colore 3) con chunk tRNS
   • Impostare le voci della palette ai valori RGB massimi (255, 255, 255)
   • Impostare i valori alpha a zero per più voci della palette
   • L'applicazione vittima elabora il PNG con formato alpha
   • PNG_FLAG_OPTIMIZE_ALPHA viene abilitato internamente
   • L'espansione della palette viola l'invariante del componente
   • Si verifica un accesso all'array fuori dai limiti

3. Risultato dell'attacco:

   • Lettura fuori dai limiti da png_sRGB_base o png_sRGB_delta
   • La corruzione della memoria porta a heap-use-after-free
   • Arresto anomalo dell'applicazione (denial of service)
   • Potenziale divulgazione di informazioni tramite lettura OOB

Disposizione della memoria

┌─────────────────┐
│ png_sRGB_base   │  Indici dell'array: 0-511 (512 voci)
│ [512 voci]      │  Accesso valido: (component >> 15) ≤ 511
├─────────────────┤
│ [Accesso OOB]   │  Indice 512 ← Accesso vulnerabile quando component ≥ 0x1000000
├─────────────────┤
│ png_sRGB_delta  │  Indici dell'array: 0-511 (512 voci)
│ [512 voci]      │  Anch'esso vulnerabile allo stesso accesso OOB
├─────────────────┤
│ Memoria adiacente│  Potenziale divulgazione di informazioni
└─────────────────┘

Calcolo che causa overflow:
component = alpha × component + (255-alpha) × png_sRGB_table[palette_RGB]

Quando alpha=0 e palette_RGB=255:
component = 0 + 255 × 65535 = 16.711.425
(component >> 15) = 512 (FUORI DAI LIMITI!)

Condizioni di attivazione

Condizioni richieste:

• Tipo colore PNG 3 (indicizzato/palette)
• Chunk tRNS presente (trasparenza)
• Valori alpha pari a 0 nel chunk tRNS
• Valori RGB elevati nella palette (specialmente 255, 255, 255)
• Utilizzo dell'API semplificata (png_image_finish_read)
• Formato alpha-capable (PNG_FORMAT_ARGB, PNG_FORMAT_RGBA con flag)

Fattori opzionali:

• Il formato con PNG_FORMAT_FLAG_AFIRST aumenta la probabilità di crash
• Immagini più grandi forniscono maggiori opportunità per innescare il bug
• Più voci della palette con alpha zero aumentano l'affidabilità

Condizioni non attivanti:

• libpng >= 1.6.51 (corretto)
• PNG_FORMAT_RGBA senza flag aggiuntivi (a volte sicuro)
• Tipi colore non palette (RGB, scala di grigi, ecc.)
• Palette senza trasparenza
• Tutti i valori alpha = 255 (completamente opachi)

---

Proof of Concept

Avvio rapido

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

# Genera le immagini
python3 generate-images.py

# Compila il test
chmod +x build.sh
./build.sh

# Esegui l'exploit (richiede libpng vulnerabile < 1.6.51)
./test_asan exploit_v1.png exploit_v2.png exploit_v3.png exploit_v4.png

Componenti del PoC

1. Generatore di exploit (generate-images.py)

Genera file PNG dannosi che innescano la vulnerabilità.

Utilizzo:

python3 generate_poc.py

Output:

• exploit_v1.png - Immagine 8x8, palette bianca uniforme, alpha zero
• exploit_v2.png - Immagine 8x8, variazione strategica della palette
• exploit_v3.png - Immagine 64x64, grande con schemi ripetuti
• exploit_v4.png - Immagine 4x4, caso minimo con alpha tutto zero

Opzioni:

# Genera una variante specifica
generate_malicious_png('custom.png', variant=2)

# Varianti:
# 1: Valori RGB massimi con alpha zero (affidabile)
# 2: Palette strategica progettata per overflow massimo
# 3: Immagine più grande con schemi di attivazione ripetuti
# 4: Caso minimo mirato a global-buffer-overflow

2. Test (test.c)

Elabora file PNG utilizzando l'API semplificata e dimostra la vulnerabilità.

Compilazione:

# Con AddressSanitizer (consigliato - miglior rilevamento)
gcc -o test_asan test.c -lpng -fsanitize=address -g -O0 -fno-omit-frame-pointer

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

# Con simboli di debug
gcc -o test_debug test.c -lpng -g -O0

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

Caratteristiche:

• Testa più formati alpha-capable (RGBA, ARGB, LINEAR_RGB_ALPHA)
• Mostra la versione di libpng e lo stato della vulnerabilità
• Mostra i valori del primo pixel per verifica
• Gestione completa degli errori

Output previsto

Su versione vulnerabile (libpng 1.6.36):

libpng version: 1.6.36
PNG_LIBPNG_VER: 10636