CVE-2026-52910 — reprodutor de use-after-free do cBPF reuseport

Um reprodutor de corrida e kit de estresse para CVE-2026-52910, um use-after-free (UAF) no tratamento do kernel Linux de programas seletores classic BPF (cBPF) de reuseport, corrigido upstream pelo commit "bpf: Free reuseport cBPF prog after RCU grace period".

[!WARNING] Esta é uma ferramenta de estresse do kernel. Em um kernel vulnerável ela deliberadamente amplia uma janela de corrida de use-after-free; um acerto pode travar ou corromper a máquina. Execute-a apenas em máquinas que você possui ou está explicitamente autorizado a testar (VMs de teste, máquinas de CI descartáveis), nunca em sistemas de produção.

O bug em um minuto

SO_REUSEPORT permite que muitos sockets se vinculem à mesma porta UDP; para cada pacote recebido o kernel escolhe um socket do grupo em reuseport_select_sock() (net/core/sock_reuseport.c). Um grupo pode instalar um programa seletor — um programa classic BPF anexado com setsockopt(SO_ATTACH_REUSEPORT_CBPF) — que decide por pacote qual socket do grupo o recebe. O programa executa na softirq de RX (processamento de recepção de rede) dentro de uma seção crítica de leitura RCU.

O bug: quando o programa é substituído ou desanexado via setsockopt() (reuseport_attach_prog() / reuseport_detach_prog()), o programa cBPF antigo é liberado imediatamente por sk_reuseport_prog_free(), sem esperar pelos leitores RCU em andamento. Uma CPU ainda percorrendo as instruções do programa liberado lê memória vmalloc liberada:

sequenceDiagram
    autonumber
    participant C as CPU0 — churner thread
    participant K as setsockopt() path
    participant R as CPU1 — RX softirq

    R->>R: rcu_read_lock()
    R->>R: prog = rcu_dereference(reuse->prog)
    C->>K: setsockopt(SO_ATTACH_REUSEPORT_CBPF, progB)
    K->>K: swap progA → progB
    K->>K: sk_reuseport_prog_free(progA)
    Note right of K: unfixed kernels: bpf_prog_free()<br/>runs NOW — no RCU grace period
    R->>R: execute progA->insns (run_bpf_filter)
    Note right of R: progA was already freed<br/>KASAN: vmalloc-out-of-bounds
    Note over K: fix: call_rcu(sk_reuseport_prog_free_rcu) —<br/>free deferred by one RCU grace period

O caminho do seletor eBPF (SO_ATTACH_REUSEPORT_EBPF) não é afetado: ele já libera programas através de estágios diferidos de bpf_prog_put(). A correção dá ao caminho cBPF o mesmo tratamento — um período de graça RCU antes que o programa antigo seja liberado.

O relatório KASAN upstream (em um kernel de depuração 7.0):

BUG: KASAN: vmalloc-out-of-bounds in reuseport_select_sock+0xedc/0x1220
Read of size 4 at addr ffffc9000051e004 by task slowme/10208
 net/core/sock_reuseport.c:596

O que há neste repositório

Início rápido

Em uma máquina de teste Linux:

$ make
$ sudo ./run_hammer.sh 600        # 10-minute run
...
== result: RC=0 (0 clean / 1 setup / 2 splat / 3 leak / 4 integrity) ==

Requisitos:

• Uma máquina de teste Linux que você possa travar (VM ou bare metal). Um kernel com KASAN habilitado é fortemente recomendado — sem KASAN, um acerto de corrida pode passar completamente despercebido.
• gcc e bash.
• Root para as verificações do wrapper (dmesg, /proc/vmallocinfo, sysctl); o martelo em si roda sem privilégios (o reprodutor upstream rodou como UID 1000).
• Uma máquina ociosa: tráfego em segundo plano e outros usuários de BPF adicionam ruído à verificação de vazamento.
• O martelo vincula portas UDP a partir de 21000 (uma porta por grupo reuseport) — certifique-se de que estejam livres.

Resultados esperados:

• Kernel vulnerável — splat KASAN no dmesg → RC=2; ocasionalmente a verificação de integridade do martelo dispara primeiro → RC=4.
• Kernel corrigido — execução limpa, RC=0, contagem de vmalloc de bpf_prog estável.

A janela de corrida é minúscula (liberação vs. execução de RX em andamento), então trate uma única execução limpa como inconclusiva. Para testes reais, execute por horas, por exemplo:

$ sudo ./run_hammer.sh 86400 512 8 16 4 127.0.0.1 0

O martelo: reuseport_race_hammer

$ ./reuseport_race_hammer [dur_sec] [insns] [nports] [nsocks] [nsenders] [ip] [ebpf]

Cada grupo executa uma thread churner que troca e desanexa o seletor cBPF via setsockopt() em um loop apertado, e threads sender inundando o grupo com datagramas UDP de 64 bytes enquanto os receptores contam a entrega por socket.

Fases de execução (T = dur_sec):

time ──────────────────────────────────────────────────────────────►
 [0 ──────────── T-15s)   [T-15s ── T-10s)   [T-10s ─────────── T]
       CHURN + FLOOD             SETTLE               MEASURE
 churner swaps/detaches    churn frozen,       deterministic program
 the selector prog at      final program       (selects the LAST
 max rate under full       attached             socket): EVERY packet
 UDP flood — THE           (selects LAST        must land on the LAST
 race window open          socket)              socket; snapshot A →
                                               run → snapshot B

Verificação de integridade: durante a fase de medição o programa final seleciona deterministicamente o último socket do grupo. Se os pacotes recebidos pelo grupo durante essa janela não chegaram todos a esse socket, a seleção deu errado (um possível efeito de UAF mesmo sem KASAN) → código de saída 2.

Códigos de saída do martelo: 0 PASS · 1 erro de setup/execução · 2 WARN de integridade.

run_hammer.sh — wrapper de execução única

Executa o martelo e adiciona as verificações que tornam uma única execução significativa:

1. tira um snapshot da contagem de alocações bpf_prog em /proc/vmallocinfo;
2. aumenta net.core.optmem_max para que programas cBPF de vários KB sejam anexados sem problemas;
3. executa o martelo;
4. aguarda DRAIN (padrão 30s) para que as liberações diferidas de RCU/workqueue terminem;
5. varre o dmesg em busca de novos splats (BUG:, Oops:, WARNING:, RIP:, leaked, stuck);
6. compara a contagem de vmalloc de bpf_prog antes/depois (verificação de vazamento) e, opcionalmente, varre o kmemleak se /sys/kernel/debug/kmemleak existir.

Códigos de saída: 0 limpo · 1 erro de setup (incluindo falha de setup do martelo) · 2 splat do kernel visto · 3 possível vazamento de bpf_prog · 4 WARN de integridade do martelo.

livepatch_cycle.sh — teste do ciclo de vida do livepatch

A correção libera o programa cBPF antigo a partir de um callback call_rcu(). Se você distribuir a correção como um livepatch (kernel live patching — código aplicado em um kernel em execução), a própria função de callback vive no módulo do patch: um revert/unload enquanto callbacks ainda estão pendentes libera o texto do módulo sob os pés do callback. Este script exercita ciclos de apply/revert enquanto o martelo mantém a janela de corrida quente, e observa /sys/kernel/livepatch/*/transition e o dmesg.

$ MODE=rcu ./livepatch_cycle.sh 20 120    # 20 cycles × 120s hammer each

Códigos de saída: 0 limpo · 1 falha de comando · 2 splat ou transição travada · 4 WARN de integridade do martelo.

CI

A CI compila o martelo com dois conjuntos de flags e executa shellcheck nos scripts. Testes de kernel em tempo de execução não são executados intencionalmente em runners de CI compartilhados: o reprodutor precisa de controle sobre a versão do kernel do runner (e em um kernel vulnerável poderia causar oops no runner). Execute esses em máquinas de teste reais.

Referências

• Registro NVD: https://nvd.nist.gov/vuln/detail/CVE-2026-52910
• Correção: bpf: Free reuseport cBPF prog after RCU grace period — backports stable: 08264d5bba0b, 18fc650ccd7d, 298db6167f81, 87dfb977bdb6, 90e47dc5c572, c3e3fddda6b5, f8b8f1d4bb76, fec41484e7c2
• Rastreamento Red Hat: https://bugzilla.redhat.com/show_bug.cgi?id=2490779

Licença

GPL-2.0-only — veja LICENSE.