Skip to content
KitploitKITPLOIT
FerramentasBlog
Log in
Enviar
FerramentasBlog
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
CVE-2026-64507 — PoC e ferramenta de detecção para CVE-2026-64507: demonstra o classic-BPF JIT spray, a reutilização de memória JIT e verifica a mitigação de flush do IBPB por meio de símbolos do kernel e ftrace. | Kitploit
Ferramentas/GitHubGitHub/manalejandro/cve-2026-64507
Ferramentas DefensivasForensia de MemóriaAnálise de VulnerabilidadesExploraçãoExploração de Binários
GitHubmanalejandro/cve-2026-64507

CVE-2026-64507

PoC e ferramenta de detecção para CVE-2026-64507: demonstra o classic-BPF JIT spray, a reutilização de memória JIT e verifica a mitigação de flush do IBPB por meio de símbolos do kernel e ftrace.

Compartilhar
Ver Repositório
há 1 mêsAinda não revisado

CVE-2026-64507 — PoC: IBPB flush on BPF JIT allocation

Ferramentas de demonstração e detecção para o endurecimento do kernel Linux que realiza o flush dos preditores de desvio indireto (IBPB) quando memória JIT de BPF clássico é reutilizada pelo alocador de pacotes de programas BPF ("endurecimento contra cBPF JIT spray").

CVECVE-2026-64507 (GHSA-mfjh-rff8-525v)
ComponenteKernel Linux — kernel/bpf/core.c + arch/x86/kernel/cpu/bugs.c
Introduzidocom o alocador de pacotes de programas BPF (57631054fae6, v5.18)
Corrigido (mainline)a3af84b0fa00ead01fcd0e28b5d773ff25990a0d — mesclado para v7.2-rc2
Corrigido (stable)6.6.145, 6.12.97, 6.18.39, 7.1.4 (+ fila de backport 6.16.y)
CVE relacionadoCVE-2026-64508 — infraestrutura (bpf_arch_pred_flush static call/key, 96cce16e26dd02)
Série"cBPF JIT spray hardening" por Pawan Gupta (Intel), 6 patches
Severidadelacuna de endurecimento para injeção de alvo de desvio (BTI) Spectre-v2/BHI em código BPF com JIT spray

TL;DR

$ make
$ ./poc info          # is this kernel patched? is the flush active?
$ sudo ./poc all      # full demonstration (spray + reuse + ftrace ground truth)

Verificado neste repositório num kernel corrigido (7.2.6, flush ativo, IBPB confirmado por reutilização) e num kernel genuinamente vulnerável (Debian 6.12.96 iniciado em QEMU/KVM, sem flush algum). Transcrições reais estão em Resultados verificados.


1. Contexto

1.1 O alocador de pacotes de programas do BPF JIT

Desde a v5.18 o BPF JIT aloca programas pequenos a partir de pacotes executáveis de 2 MiB (bpf_prog_pack_alloc(), BPF_PROG_PACK_SIZE, blocos de 64 bytes). Quando um programa é liberado, os seus blocos retornam ao bitmap do pacote e são distribuídos novamente a programas posteriores.

1.2 JIT spraying

Os imediatos do BPF são copiados literalmente para o código de máquina gerado. Um filtro clássico (SO_ATTACH_FILTER) como:

BPF_STMT(BPF_LD  | BPF_IMM, 0xdeadbeef)   /* ->  b8 ef be ad de   mov eax, 0xdeadbeef */
BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xcafebabe) /* -> 05 be ba fe ca  add eax, 0xcafebabe */

compila para memória de kernel executável que contém os bytes escolhidos pelo atacante ef be ad de … be ba fe ca literalmente (este PoC os despeja, ver §6). Um atacante que controla muitos programas pode, portanto, colocar grandes quantidades de bytes de instrução escolhidos ("JIT spray") em endereços alinhados a 64 bytes dentro da região execmem. Filtros de socket clássicos são a superfície de ataque não privilegiada visada pela série.

1.3 Por que a reutilização de memória importa — Spectre-v2 / BTI

Em CPUs vulneráveis a Spectre-v2 / injeção de alvo de desvio (e a BHI), as previsões de desvio não são marcadas por privilégio. Um desvio indireto pode ser direcionado erroneamente especulativamente para memória executável cujo endereço o atacante preparou.

O alocador de packs reutiliza chunks liberados, então um novo programa pode ser colocado no exato mesmo endereço que um programa mais antigo, controlado pelo atacante, ocupava. Qualquer estado de preditor (entradas BTB/BHB) deixado pelo antigo ocupante — ou treinado pelo atacante contra ele — ainda se refere a esse endereço, mas o código ali agora é diferente. A correção upstream descreve isso como:

"Quando código novo é escrito no espaço que um programa anterior ocupava, um desvio indireto para o novo programa pode reutilizar uma previsão de desvio deixada pelo antigo."

Limpar os preditores de desvio indireto (IBPB) antes que a memória reutilizada seja entregue remove esse estado de preditor obsoleto.


2. A correção

A série de 6 patches (hashes do mainline):

#CommitAssunto
196cce16e26dd02a8678f1e87f88a4b5cdb63b995bpf: Support for hardening against JIT spraying (CVE-2026-64508)
2a3af84b0fa00ead01fcd0e28b5d773ff25990a0dx86/bugs: Enable IBPB flush on BPF JIT allocation (esta CVE)
30bb99f2cfaae6822d734d69722de30af823efdf3bpf: Restrict JIT predictor flush to cBPF
4a23c1c5396a91680703360d1ee28a44657c503c4bpf: Skip redundant IBPB in pack allocator
5a9b1f19a6a673ba06820898d0f1ad02883ea1639bpf: Prefer packs that won't trigger an IBPB flush on allocation
6b72e29e0f7ee329d89f86db8700c8ea99b4a370abpf: Prefer dirty packs for eBPF allocations

Mecânica (conforme mesclado, v7.2-rc2):

  • kernel/bpf/core.c ganha uma chave estática bpf_pred_flush_enabled e uma chamada estática bpf_arch_pred_flush (padrão NULL → nenhum CALL emitido). bpf_prog_pack_alloc() a invoca quando entrega um chunk de um pack que "precisa de um flush" (pack novo, ou um pack cuja memória liberada se tornou reutilizável) e apenas para programas BPF clássicos (pr_warn_once para o caso extremo de cBPF maior que o pack). Alocações eBPF são direcionadas para packs já limpos e nunca fazem flush.

  • arch/x86/kernel/cpu/bugs.c conecta a chamada estática a bpf_arch_ibpb(), que emite on_each_cpu(write_ibpb/entry_ibpb) — um IBPB em cada CPU — e imprime no boot:

    Spectre V2 : Enabling IBPB for BPF
    

    A liberação só é ativada quando uma sequência retpoline genuína não está ativa (retpoline_seq_enabled()) e a CPU possui IBPB. Com retpoline, as previsões indiretas em ring-0 já estão neutralizadas, portanto a liberação é intencionalmente ignorada.

2.1 Por que isso se torna observável

  • A liberação é um broadcast IPI: neste sistema de teste com 12 threads, um anexo clássico liberado custa ~50–80 µs contra ~6 µs sem ela.
  • bpf_arch_ibpb é um símbolo real; sua presença/ausência em /proc/kallsyms é um indicador barato de patch.
  • Com CONFIG_RCU_LAZY=y (padrão do Debian), as liberações do JIT são adiadas por dezenas de milissegundos, então ciclos de alocação que reutilizam memória se comportam de forma observavelmente diferente de loops apertados cujas liberações ainda estão pendentes.

3. O que este PoC demonstra — e o que não demonstra

Demonstrado:

  1. Triagem do host — matriz de versões, símbolos do kernel, status de CPU/Spectre, sysctls e o marcador de runtime Enabling IBPB for BPF (info).
  2. Primitiva de JIT spray — filtros clássicos cujos imediatos são encontrados literalmente na memória executável do kernel, com o endereço de kernel dos bytes pulverizados (spray, três caminhos de evidência independentes: gêmeo eBPF BPF_OBJ_GET_INFO_BY_FD, varredura de pacotes em /proc/kcore, dump de log com bpf_jit_enable=2).
  3. Reutilização de memória — blocos JIT liberados são comprovadamente entregues a programas posteriores novamente (reuse; sondagem ciente de RCU, jited_ksyms do eBPF).
  4. Observação da liberação — um kprobe ftrace em bpf_arch_ibpb conta os broadcasts IBPB reais por ciclo de reutilização: por exemplo, 30/30 ou 19/20 no kernel de teste com patch (uma falha simplesmente significa que uma liberação adiada ainda não foi concluída), e estruturalmente impossível em um kernel vulnerável (reuse, root).

Não demonstrado (fora do escopo, honestamente):

  • Um exploit Spectre-v2 de ponta a ponta. Isso exigiria adicionalmente uma primitiva de treinamento de BTI microarquiteturalmente utilizável e um gadget de vazamento para a CPU específica. Este PoC prova as precondições e o comportamento da mitigação, não a exfiltração de dados.
  • Qualquer escape arquitetural: os bytes pulverizados são dados até que um redirecionamento especulativo os alcance.
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Sem dados de popularidade ainda.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →