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

CVE	CVE-2026-52910
Tipo	Use-after-free / leitura fora dos limites (CWE-125), CVSS 3.1 7.8 HIGH AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Introduzido	v4.5 (com suporte a cBPF reuseport)
Corrigido em	5.10.259, 5.15.210, 6.1.176, 6.6.143, 6.12.94, 6.18.36, 7.0.13 (stable); mainline v7.1
Splat upstream	BUG: KASAN: vmalloc-out-of-bounds in reuseport_select_sock (net/core/sock_reuseport.c:596)
Reportado por	Eulgyu Kim

[!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

Arquivo	Propósito
reuseport_race_hammer.c	O reprodutor: martelo multithread que alterna o seletor cBPF sob carga UDP total e depois verifica a integridade da entrega.
run_hammer.sh	Wrapper de execução única: aumenta net.core.optmem_max, executa o martelo, depois verifica o dmesg em busca de splats, /proc/vmallocinfo em busca de alocações bpf_prog vazadas e, opcionalmente, kmemleak.
livepatch_cycle.sh	Aplica/reverte um livepatch que carrega a correção enquanto o martelo é executado — caça riscos do ciclo de vida do livepatch da correção baseada em call_rcu().
Makefile	Compila o martelo.
.github/workflows/ci.yml	CI: build + shellcheck (sem testes de kernel em tempo de execução; veja CI).

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]

Argumento	Padrão	Significado
dur_sec	300 (min 45)	segundos totais de execução
insns	256	instruções de preenchimento no programa cBPF alternado; um programa maior é uma região liberada maior para acertar. Se o attach falhar com ENOMEM, aumente net.core.optmem_max (o wrapper faz isso por você).
nports	4 (max 64)	grupos reuseport (uma porta UDP cada, a partir de 21000)
nsocks	8 (max 512)	sockets por grupo
nsenders	4 (max 32)	threads remetentes UDP por grupo
ip	127.0.0.1	endereço de destino; use um IP de NIC física para espalhar as softirqs de RX entre as CPUs (RSS)
ebpf	0	1 = também alterna attach/detach de SO_ATTACH_REUSEPORT_EBPF (requer CAP_BPF/CAP_NET_ADMIN); esse caminho não é vulnerável, isto é para comparação/cobertura

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