yeahhbean/cve-2026-45729ThorVG dereferenziazione di puntatore nullo tramite SVG malformato — writeup di fuzzing con AFL++
Gravità: CVSS 4.3 (Media) — CWE-476
Avviso: GHSA-f863-8ghq-7h64
Corretto: ThorVG v1.0.5
Stato: Corretto / Divulgato
Il parser SVG di ThorVG dereferenzia un puntatore mai inizializzato quando incontra un tag di elemento figlio troncato all'interno di un nodo radice <svg>. Il bug è raggiungibile attraverso il normale percorso di rendering (tvg::Picture::load → parse → render) e può essere attivato con un input di 6 byte.
L'impatto peggiore su Linux standard è un crash del processo (DoS) — mmap_min_addr impedisce la mappatura della pagina NULL, quindi il difetto non è direttamente sfruttabile per l'esecuzione di codice in quell'ambiente. Su target privi di MMU dove ThorVG è anche utilizzato (Tizen, firmware basato su LVGL) il quadro di sfruttabilità è diverso e merita un esame più attento.
ThorVG è un motore grafico vettoriale cross-platform scritto in C++17. È il renderer SVG/Lottie predefinito in Samsung Tizen OS, è incluso in LVGL (ampiamente utilizzato nell'UI embedded/IoT) e viene distribuito come libreria standalone su più piattaforme.
La libreria elabora input SVG/JSON non fidati e viene spesso esposta in contesti senza separazione dei privilegi. Il codice del parser nelle librerie grafiche è storicamente stata una fonte affidabile di bug di sicurezza della memoria — ThorVG è in fase di sviluppo attivo e al momento di questa ricerca non aveva copertura di fuzzing registrata nei tracker di bug pubblici.
L'harness racchiude l'API di caricamento in memoria di ThorVG in modo che AFL++ possa guidare il parser direttamente senza I/O su disco.
// fuzz_thorvg.cpp
#include <cstdint>
#include <cstring>
#include <thorvg.h>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
if (size == 0) return 0;
tvg::Initializer::init(tvg::CanvasEngine::Sw, 0);
auto canvas = tvg::SwCanvas::gen();
uint32_t buf[64 * 64] = {};
canvas->target(buf, 64, 64, 64, tvg::SwCanvas::ARGB8888);
auto picture = tvg::Picture::gen();
// Load SVG from raw bytes; mimeType hint "svg" triggers the SVG parser path
if (picture->load(reinterpret_cast<const char*>(data), size, "svg", false)
== tvg::Result::Success) {
canvas->push(tvg::cast(picture));
canvas->draw();
canvas->sync();
}
tvg::Initializer::term(tvg::CanvasEngine::Sw);
return 0;
}
Compila con ASAN + instrumentazione di copertura:
clang++ -std=c++17 -fsanitize=address,undefined -fprofile-instr-generate \
-fcoverage-mapping -O1 -g \
fuzz_thorvg.cpp -o fuzz_thorvg \
$(pkg-config --cflags --libs thorvg)
Partire da zero con byte casuali dà scarsi risultati su parser sensibili al formato. Ho seminato il corpus con un insieme di file SVG minimi strutturalmente validi che coprono:
<svg xmlns="..."/>)<rect>, <circle>, <path>)<g> nidificato<use> xlinkI seed consapevoli della struttura hanno ridotto il tempo per i primi percorsi interessanti da ore a meno di 20 minuti nel mio ambiente.
AFL_AUTORESUME=1 afl-fuzz \
-i corpus/ \
-o findings/ \
-x svg.dict \
-m none \
-- ./fuzz_thorvg @@
-x svg.dict — Dizionario dei token AFL++ con parole chiave SVG per aiutare la mutazione verso nomi di tag validi.
-m none — La memoria shadow di ASAN richiede la disabilitazione del limite di memoria di AFL++.
AFL++ ha prodotto un crash dopo circa 3 ore di fuzzing single-core. L'input iniziale di crash era di ~180 byte. L'output di ASAN:
==pid==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000 (pc 0x... ...)
SEGV on address NULL
#0 in tvg::SvgParser::_parseStyle(...)
#1 in tvg::SvgParser::_createElement(...)
#2 in tvg::SvgParser::parse(...)
#3 in tvg::SvgLoader::read()
...
Il difetto è una lettura tramite un puntatore SvgNode* non inizializzato (NULL) all'interno di _parseStyle. Ci si aspetta che il puntatore venga impostato da _createElement quando elabora un elemento figlio, ma un nome di tag troncato fa sì che l'elemento venga saltato senza che il puntatore venga assegnato, e _parseStyle procede comunque a dereferenziarlo.
Minimizzato con afl-tmin, poi potatura manuale:
afl-tmin -i findings/crashes/id:000000 -o min -- ./fuzz_thorvg @@
Dopo afl-tmin l'input era di 14 byte. L'ispezione manuale del percorso di parsing ha mostrato che solo i primi 6 byte venivano consumati prima del difetto:
<svg><
<svg> apre il nodo radice. < inizia un tag di elemento figlio. Il parser legge il nome del tag, ottiene una stringa vuota (l'input termina subito dopo <), salta la creazione dell'elemento e cade in _parseStyle con il puntatore del nodo ancora NULL.
Conferma che il trigger di 6 byte si riproduce:
printf '<svg><' | ./fuzz_thorvg /dev/stdin
# or
echo -n '<svg><' > poc.svg && ./fuzz_thorvg poc.svg
src/loaders/svg/tvgSvgParser.cpp
Pseudocodice semplificato del flusso vulnerabile:
// _createElement returns nullptr when tag name is empty
SvgNode* node = _createElement(tagName); // tagName == "" → returns nullptr
// No NULL check before passing into style parser
_parseStyle(node, attributes); // ← dereferences node->style at offset 0x18
La correzione in v1.0.5 aggiunge un ritorno anticipato nel ciclo di dispatch degli elementi quando _createElement restituisce nullptr, prima che venga tentata qualsiasi elaborazione di attributi/stili.
/proc/sys/vm/mmap_min_addr è tipicamente impostato a 65536 sulle distribuzioni moderne. La pagina NULL non è mappata, quindi la CPU solleva un SIGSEGV che il kernel converte in un segnale al processo — il risultato è un crash (DoS). Nessuna scrittura controllata, nessun controllo del PC, non direttamente sfruttabile per l'esecuzione di codice.
ThorVG è un cittadino di prima classe in Tizen (sistema operativo IoT/wearable di Samsung) ed è integrato in LVGL, che gira su microcontrollori e sistemi senza MMU.
Su sistemi senza MMU non c'è protezione della memoria e mmap_min_addr non si applica. Se la pagina NULL è mappata (cosa comune negli ambienti embedded bare-metal), una dereferenziazione di puntatore NULL può potenzialmente puntare a memoria controllata dall'attaccante. Se ciò sia raggiungibile in un attacco reale dipende dalla superficie di attacco — ThorVG su un dispositivo Tizen può analizzare SVG da fonti di rete non fidate o contenuti forniti dall'utente.
Questo contesto è ciò che giustifica la divulgazione responsabile anche per un reperto di gravità Media secondo CVSS.
| Data | Evento |
|---|---|
| 2026-xx-xx | Crash scoperto tramite AFL++ |
| 2026-xx-xx | Causa principale confermata con ASAN; POC di 6 byte prodotto |
| 2026-xx-xx | Report privato inviato al manutentore di ThorVG (hermet) tramite GitHub Security Advisory |
| 2026-xx-xx | Manutentore ha riconosciuto e aperto un fork privato |
| 2026-xx-xx | Patch integrata in v1.0.5 |
| 2026-xx-xx | Pubblicato GHSA-f863-8ghq-7h64; assegnato CVE-2026-45729 |
La patch aggiunge una guardia NULL nel ciclo di dispatch degli elementi SVG:
// before (vulnerable)
SvgNode* node = _createElement(tag);
_parseStyle(node, attrs); // unconditional