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
CVE-2026-53157 — Análise técnica, evidências do KASAN e reprodutor em C para a CVE-2026-53157, um use-after-free no caminho phonet_device_destroy() do Phonet do Linux, com harness de teste em QEMU. | Kitploit
Ferramentas/GitHubGitHub/santoshkalluri/cve-2026-53157
Análise de VulnerabilidadesExploraçãoFuzzingPapers e PesquisaAprendizado e Educação
GitHubsantoshkalluri/cve-2026-53157

CVE-2026-53157

Análise técnica, evidências do KASAN e reprodutor em C para a CVE-2026-53157, um use-after-free no caminho phonet_device_destroy() do Phonet do Linux, com harness de teste em QEMU.

Ver Repositório
1há 16 diasAinda não revisado
Compartilhar

CVE-2026-53157: use-after-free no Phonet do Linux

Um use-after-free no código Phonet do kernel Linux (net/phonet). Quando um dispositivo de rede era removido, o kernel podia liberar um registro Phonet enquanto outra tarefa ainda o estava lendo.

O bug remonta à v2.6.33 (2009). Foi corrigido no Linux 7.1 e retroportado para os kernels estáveis. Este repositório contém uma análise escrita, um reprodutor e os logs de teste.

CVECVE-2026-53157
Ondenet/phonet/pn_dev.c, função phonet_device_destroy()
Tipo de bugUse-after-free (memória liberada sem esperar que os leitores RCU terminem)
Introduzido emv2.6.33, commit eeb74a9d45f7 ("Phonet: convert devices list to RCU", 2009)
Corrigido emv7.1, commit 71de0177b28d
Quem pode acioná-loRoot (requer CAP_NET_ADMIN e CAP_SYS_ADMIN no namespace de usuário inicial)
CVSS 3.1O NVD lista 7.8 (Alto), assumindo um atacante com baixos privilégios. Adicionar um endereço Phonet requer root, então com PR:H a pontuação é 6.7 (Médio): CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H
Encontrado e corrigido porSantosh Kalluri

Em resumo

  • Quando um dispositivo de rede é removido, o kernel exclui seu registro Phonet e libera a memória imediatamente.
  • No mesmo momento, outra tarefa pode estar listando endereços Phonet e ainda estar mantendo esse registro.
  • Essa tarefa então lê memória que já foi liberada. O KASAN detecta isso, e o kernel pode travar.
  • A correção é uma linha: liberar a memória somente depois que todos os leitores terminarem.

O que deu errado

O kernel mantém um struct phonet_device para cada dispositivo de rede que possui endereços Phonet. Esses registros ficam em uma lista. Os leitores percorrem a lista sob RCU, um mecanismo do kernel que permite aos leitores trabalhar sem adquirir um lock. A regra com RCU é simples: depois de remover um item da lista, você deve esperar até que todos os leitores atuais terminem antes de liberá-lo.

phonet_device_destroy() quebrou essa regra. Ele removia o item da lista e o liberava imediatamente:

	spin_lock(&pndevs->lock);

	pnd = __phonet_get(dev);
	if (pnd)
		list_del_rcu(&pnd->list);

	spin_unlock(&pndevs->lock);

	if (pnd) {
		...
		kfree(pnd);              /* freed right away, readers may still use it */
	}

list_del_rcu() apenas remove o item da lista. Um leitor que já estava percorrendo a lista ainda pode ter um ponteiro para ele. A outra função que libera o mesmo tipo de objeto, phonet_address_del(), já fazia isso da forma correta com kfree_rcu().

Um desses leitores é getaddr_dumpit(), que responde a solicitações de "listar todos os endereços Phonet" (RTM_GETADDR):

	rcu_read_lock();
	list_for_each_entry_rcu(pnd, &pndevs->list, list) {
		...
		memcpy(addrs, pnd->addrs, sizeof(pnd->addrs));       /* reads freed memory */
		for_each_set_bit(addr, addrs, 64) {
			...
			err = fill_addr(skb, READ_ONCE(pnd->netdev->ifindex), ...);  /* follows a pointer from freed memory */

A correção

--- a/net/phonet/pn_dev.c
+++ b/net/phonet/pn_dev.c
@@ static void phonet_device_destroy(struct net_device *dev)
 		for_each_set_bit(addr, pnd->addrs, 64)
 			phonet_address_notify(net, RTM_DELADDR, ifindex, addr);
 
-		kfree(pnd);
+		kfree_rcu(pnd, rcu);
 	}
 }

kfree_rcu() aguarda até que todos os leitores RCU atuais terminem e então libera a memória. A struct já tinha o campo rcu de que precisa, então nada mais precisou mudar.

Como o reprodutor dispara o bug

Duas coisas precisam acontecer ao mesmo tempo:

  1. Lado da liberação. Crie um dispositivo de rede, dê a ele um endereço Phonet (RTM_NEWADDR) e então exclua o dispositivo (RTM_DELLINK). Excluir o dispositivo termina em phonet_device_destroy(), que libera o registro.
  2. Lado da leitura. Continue pedindo ao kernel para listar endereços Phonet (RTM_GETADDR).

poc/pn_uaf_repro.c executa 8 threads fazendo a primeira parte e 8 threads fazendo a segunda. Ele roda dentro de seu próprio namespace de rede. Ele apenas dispara o bug. Não tenta explorá-lo.

O que o bug pode e não pode fazer

O que eu vi (logs em evidence/):

  • KASAN use-after-free. getaddr_dumpit() lê 8 bytes de um objeto de 64 bytes liberado (cache kmalloc-64).
  • Kernel crash. Uma vez que a memória liberada é reutilizada, getaddr_dumpit() segue um ponteiro pnd->netdev obsoleto e o kernel atinge uma falha de proteção geral. Toda execução vulnerável terminou em pânico. Os relatórios KASAN extras mais tarde na mesma execução são efeitos colaterais da caminhada na lista passando por memória liberada. Eles não são bugs separados.

Limitações:

  • Requer root. Adicionar um endereço Phonet verifica CAP_NET_ADMIN e CAP_SYS_ADMIN contra o namespace de usuário inicial. Um usuário normal dentro de seu próprio namespace de usuário recebe EPERM. Eu testei isso (teste 1 abaixo). Listar endereços não requer direitos especiais, mas por si só não libera nada.
  • Phonet deve estar habilitado (CONFIG_PHONET). Ubuntu, por exemplo, o compila como um módulo (CONFIG_PHONET=m).

Versões afetadas

O bug existe desde a v2.6.33 até as versões corrigidas abaixo. Elas correspondem ao registro oficial do CVE.

RamoPrimeira versão corrigida
mainline7.1
7.0.y7.0.13
6.18.y6.18.36
6.12.y6.12.95
6.6.y6.6.144
6.1.y6.1.177
5.15.y5.15.211
5.10.y5.10.260

Maneira rápida de verificar uma árvore de código-fonte do kernel: olhe o último kfree em phonet_device_destroy(). kfree_rcu(pnd, rcu) significa corrigido. kfree(pnd) significa vulnerável.

Reproduzindo o bug

Use uma VM descartável. O reprodutor precisa de root e, em um kernel vulnerável, ele irá travar o kernel.

  1. Compile o Linux v7.1 com KASAN e Phonet. Comece a partir de x86_64_defconfig mais kvm_guest.config, então adicione as opções em test/kasan-phonet.config. Este é o kernel corrigido.
  2. Aplique test/revert-fix.diff e compile novamente. Ele altera apenas a única linha mostrada acima. Este é o kernel vulnerável.
  3. Compile o initramfs de teste. Você precisa de um busybox estático:
    test/build_initramfs.sh /usr/bin/busybox initramfs.cpio.gz
    
  4. Inicialize cada kernel:
    test/run_qemu.sh path/to/bzImage initramfs.cpio.gz 60
    

O initramfs executa dois testes:

  • Teste 1: o reprodutor como uid 1000 dentro de um novo namespace de usuário e de rede. Esperado: EPERM.
  • Teste 2: o reprodutor como root por 60 segundos.

Resultados

Linux v7.1, KASAN, QEMU/KVM, 4 vCPUs.

DataKernelExecuçõesKASAN use-after-freeTravamento do kernelTeste 1 (usuário normal)
2026-10-08v7.1 (corrigido)3 × 60 s0 de 30 de 3EPERM
2026-10-08v7.1 com a correção revertida33 de 3, primeiro relatório 5–20 s após o boot3 de 3EPERM
2026-11-01v7.1 (corrigido), build nova2 × 60 s0 de 20 de 2EPERM
2026-11-01v7.1 com a correção revertida, build nova33 de 3, primeiro relatório 4,7–6,4 s após o boot3 de 3EPERM

Um relatório KASAN de uma execução vulnerável (evidence/kasan_vulnerable.txt):

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 →