⚠️ Aviso Legal

Este repositório destina-se apenas a pesquisa de segurança autorizada, análise de vulnerabilidades do kernel, ambientes de CTF e testes defensivos.

Não execute código de prova de conceito contra sistemas sem autorização explícita.

📌 Visão Geral da Vulnerabilidade

O registro do CVE identifica a vulnerabilidade como um ponteiro de cabeçalho PPPoE obsoleto que pode se tornar inválido quando dev_hard_header() realoca o cabeçalho do skb.

🧬 Descrição da Vulnerabilidade

A vulnerabilidade existe em:

drivers/net/ppp/pppoe.c

dentro de:

pppoe_sendmsg()

A sequência vulnerável é conceitualmente:

pppoe_sendmsg()
      │
      ▼
Salva o ponteiro do cabeçalho PPPoE
      │
      ▼
dev_hard_header()
      │
      ▼
O cabeçalho do skb pode ser realocado
      │
      ▼
O ponteiro antigo torna-se obsoleto
      │
      ▼
PPPoE escreve através do ponteiro obsoleto
      │
      ▼
Use-After-Free
      │
      ▼
Corrupção de memória do kernel

O código de rede do Linux permite que callbacks de cabeçalho de dispositivo realoquem o cabeçalho do sk_buff. Um ponteiro para o cabeçalho antigo, portanto, não pode ser reutilizado com segurança após dev_hard_header() retornar.

🔬 Causa Raiz

O problema central é uma violação de tempo de vida.

pppoe_sendmsg() obtém um ponteiro para o cabeçalho PPPoE antes de invocar:

dev_hard_header()

No entanto, esse callback pode fazer com que o cabeçalho do skb se mova.

Conceitualmente:

Antes do callback:

skb
┌──────────────────────────────┐
│ Ethernet │ PPPoE │ Payload   │
└──────────┴───────┴───────────┘
           ▲
           │
       ponteiro obsoleto


Após a expansão do skb:

cabeçalho antigo do skb ──X──► liberado

novo cabeçalho do skb
┌────────────────────────────────────┐
│ Ethernet │ PPPoE │ Payload         │
└──────────┴───────┴─────────────────┘
           ▲
           │
      localização válida

O ponteiro antigo ainda referencia a alocação liberada.

Quando o PPPoE subsequentemente escreve o cabeçalho através desse ponteiro, o kernel realiza uma escrita use-after-free.

🧠 Condição de Disparo

O gatilho documentado envolve uma condição de corrida em torno de copy_from_user() e mudanças nas operações de cabeçalho de um dispositivo team.

Uma sequência descrita é:

PPPoE sendmsg()
      │
      ▼
copy_from_user() bloqueia
      │
      │
      ├───────────────┐
      │               │
      ▼               ▼
Dispositivo team muda   Primeira porta não-Ethernet
operações de cabeçalho  é adicionada
                      │
                      ▼
               Callback GRE delegado
                      │
                      ▼
               Expansão do cabeçalho do skb
      │               │
      └───────────────┘
              │
              ▼
       ponteiro PPPoE obsoleto
              │
              ▼
       escrita use-after-free

O registro do CVE observa que isso pode ocorrer quando a primeira porta não-Ethernet é adicionada a um dispositivo team vazio e o callback de cabeçalho GRE delegado expande o cabeçalho do skb.

💥 Impacto de Segurança

A vulnerabilidade pode resultar em:

• Use-after-free no heap do kernel
• Corrupção de memória do kernel
• Travamento do kernel / negação de serviço
• Potencial divulgação de memória do kernel
• Potencial modificação arbitrária de memória do kernel
• Potencial execução de código no kernel
• Escalação de privilégios local

O vetor CVSS publicado do CVE é:

CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H

com pontuação base de 7.8 Alta.

🔎 Superfície Técnica de Ataque

Os componentes relevantes são:

Socket PF_PPPOX / PPPoE
          │
          ▼
    pppoe_sendmsg()
          │
          ▼
     sk_buff (skb)
          │
          ▼
  dev_hard_header()
          │
          ▼
 Callback de cabeçalho do dispositivo de rede
          │
          ▼
 Potencial expansão do cabeçalho do skb
          │
          ▼
 Ponteiro de cabeçalho PPPoE obsoleto
          │
          ▼
     escrita UAF

O código vulnerável, portanto, não é simplesmente um analisador genérico de pacotes PPPoE; a condição crítica é a interação entre transmissão de socket PPPoE e realocação dinâmica do cabeçalho do skb.

🩹 Correção Upstream

A correção upstream é intitulada:

pppoe: reload header pointer after dev_hard_header()

A correção recarrega o cabeçalho PPPoE através do offset do cabeçalho de rede do skb após a criação do cabeçalho do dispositivo.

A propriedade importante é:

Antes:

ponteiro do cabeçalho
      │
      ▼
dev_hard_header()
      │
      ▼
skb se move
      │
      ▼
ponteiro = obsoleto ❌


Depois:

dev_hard_header()
      │
      ▼
skb pode se mover
      │
      ▼
recarrega o cabeçalho usando o offset do skb
      │
      ▼
ponteiro = válido ✅

pskb_expand_head() atualiza o offset relevante do skb quando o cabeçalho do skb é relocado, tornando a busca baseada em offset segura após a realocação.

📊 Vulnerável vs Corrigido

🧪 Ambiente de Pesquisa

Um laboratório controlado pode ser estruturado como:

┌───────────────────────────────────────────────┐
│                 Linux VM                     │
│                                               │
│       ┌───────────────┐                       │
│       │ PPPoE Socket  │                       │
│       └───────┬───────┘                       │
│               │                               │
│               ▼                               │
│       ┌───────────────┐                       │
│       │ pppoe_sendmsg │                       │
│       └───────┬───────┘                       │
│               │                               │
│               ▼                               │
│       ┌───────────────┐                       │
│       │     Team      │                       │
│       └───────┬───────┘                       │
│               │                               │
│               ▼                               │
│       ┌───────────────┐                       │
│       │     GRE       │                       │
│       └───────────────┘                       │
│                                               │
└───────────────────────────────────────────────┘

Ferramentas úteis de depuração do kernel:

gdb
pwndbg
gef
crash
objdump
readelf
pahole

Monitore as mensagens do kernel:

sudo dmesg -w

Inspecione o suporte a PPPoE:

lsmod | grep pppoe

Verifique os módulos PPP disponíveis:

find /lib/modules/$(uname -r) -iname '*pppoe*'

🔎 Verificação do Kernel

Verifique o kernel em execução no momento:

uname -r

Verifique a configuração relacionada ao PPPoE:

grep -E 'CONFIG_PPP|CONFIG_PPPOE' \
/boot/config-$(uname -r)

Opções relevantes típicas incluem:

CONFIG_PPP
CONFIG_PPP_ASYNC
CONFIG_PPP_SYNC_TTY
CONFIG_PPPOE

🧪 Fluxo de Reprodução

Para pesquisa controlada do kernel:

01. Compilar kernel vulnerável
          ↓
02. Iniciar VM isolada
          ↓
03. Habilitar suporte a PPPoE
          ↓
04. Criar topologia de rede controlada
          ↓
05. Configurar interação team/GRE
          ↓
06. Exercitar pppoe_sendmsg()
          ↓
07. Monitorar o tempo de vida do skb
          ↓
08. Capturar diagnósticos do kernel
          ↓
09. Aplicar a correção upstream
          ↓
10. Repetir e comparar

O objetivo é reproduzir a violação de tempo de vida de memória com segurança e comparar o comportamento vulnerável e o corrigido.

📂 Estrutura do Repositório

CVE-2026-68121-PPPoEject/
│
├── README.md
│
├── exploit/
│   ├── poc.c
│   └── Makefile
│
├── analysis/
│   ├── root-cause.md
│   ├── pppoe-sendmsg.md
│   ├── skb-lifetime.md
│   └── patch-analysis.md
│
├── kernel/
│   ├── vulnerable/
│   └── patched/
│
├── lab/
│   ├── setup.sh
│   ├── cleanup.sh
│   └── topology.md
│
├── screenshots/
│
├── docs/
│   └── research-notes.md
│
└── LICENSE

🛡️ Mitigação

A mitigação recomendada é atualizar para um kernel Linux que contenha a correção upstream ou um backport apropriado da distribuição.

Para Debian/Kali:

sudo apt update
sudo apt full-upgrade

Em seguida, reinicie:

sudo reboot

Verifique o kernel em execução:

uname -r

Backports de distribuição podem usar números de versão diferentes, portanto, os administradores devem verificar seu pacote instalado em relação ao aviso de segurança da distribuição. O Debian atualmente lista versões corrigidas, incluindo 6.1.187-1 para Bookworm e 6.12.101-1 para Trixie.

📦 Referências da Correção Upstream

As árvores estáveis do Linux contêm a correção em vários branches mantidos. O registro do CVE lista os commits estáveis correspondentes e identifica o arquivo de origem afetado como:

drivers/net/ppp/pppoe.c

O histórico vulnerável começa com a implementação PPPoE do kernel Linux e a série de commits corrigidos termina na correção upstream representada por 7a56e7c9b08e08fd55a1bcada24cf4fe3782b722 nos dados do CVE.

🧩 Lições de Segurança

01 — O tempo de vida do ponteiro importa

Um ponteiro para um skb não pode ser considerado válido após um callback capaz de realocar o cabeçalho do skb.

02 — Callbacks podem invalidar suposições

Callbacks de rede podem alterar o layout subjacente da memória.

03 — Use offsets quando a memória pode se mover

A correção demonstra por que um offset relativo ao skb é mais seguro do que reter um ponteiro bruto através de uma operação potencialmente realocadora.

04 — Condições de corrida amplificam bugs de memória

O estado vulnerável depende de atividade concorrente em torno da transmissão de pacotes e da configuração do dispositivo de rede.

05 — UAFs no kernel têm alto impacto

Um ponteiro obsoleto no código de rede do kernel pode se tornar uma primitiva de corrupção de memória com consequências de confidencialidade, integridade e disponibilidade.

📚 Referências

• CVE: CVE-2026-68121
• Codename: PPPoEject
• Subsistema Linux: PPPoE
• Fonte: drivers/net/ppp/pppoe.c
• Função principal: pppoe_sendmsg()
• Correção: pppoe: reload header pointer after dev_hard_header()
• CVSS: 7.8 Alta
• Debian Security Tracker: CVE-2026-68121
• Referências do Linux Kernel / Stable: listadas no registro do CVE