Falhas de Autenticação e Controle de Acesso

Aula 4 de 6

A07:2021 — Identification and Authentication Failures

Credential Stuffing

Uso de credenciais vazadas em outros serviços contra o alvo.

Mitigação:
  - MFA obrigatório
  - Rate limiting (ex: 5 tentativas/min)
  - CAPTCHA após falhas
  - Verificação de credenciais vazadas (HaveIBeenPwned API)
  - Device fingerprinting

Senhas Fracas

# Verificar senha contra lista de comuns
import requests

def check_breached_password(password):
    """Verificar se senha já foi vazada (API HaveIBeenPwned - k-anonymity)"""
    import hashlib
    sha1 = hashlib.sha1(password.encode()).hexdigest().upper()
    prefix = sha1[:5]
    suffix = sha1[5:]
    resp = requests.get(f"https://api.pwnedpasswords.com/range/{prefix}")
    return suffix in resp.text

Session Fixation

Atacante força vítima a usar um ID de sessão conhecido.

Ataque:
  1. Atacante obtém session ID e engana vítima
  2. Vítima faz login com session ID fixado
  3. Atacante usa mesmo session ID — acesso à conta da vítima

Prevenção:
  - Gerar novo session ID após login
  - HttpOnly + Secure flags
  - Regenerar token de sessão no login

JWT Attacks

Estrutura JWT

Header.Payload.Signature

Header:    {"alg":"HS256","typ":"JWT"}
Payload:   {"sub":"admin","iat":1700000000}
Signature: HMAC-SHA256(base64(header) + "." + base64(payload), secret)

Ataque alg:none

Header modificado: {"alg":"none","typ":"JWT"}
Assinatura: (vazia)

Se o servidor aceitar "none", qualquer token é válido.

# Testar ataque alg:none
# Token original: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0In0.x
# Token modificado: eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJzdWIiOiJhZG1pbiJ9.
#                    |--- alg:none ---|    |--- sub:admin ---|

Ataques de Força Bruta (HS256)

# Força bruta de secret JWT com hashcat
hashcat -m 16500 jwt.txt /usr/share/wordlists/rockyou.txt

# Verificar JWT com jwt_tool
python3 jwt_tool.py eyJhbGciOiJIUzI1NiJ9...
python3 jwt_tool.py -T token.json token.jwt   # Testar tampering

Ataque de Chave Pública (RS256 → HS256)

Se o servidor usa RS256 (pública/privada) mas permite HS256:
  - Obter a chave pública do servidor
  - Assinar token com HS256 usando a chave pública como segredo
  - Servidor verifica com mesma chave pública

A01:2021 — Broken Access Control

IDOR (Insecure Direct Object References)

GET /api/users/me    → 401 (sem permissão)
GET /api/users/1     → 200 (dados de outro usuário)
GET /api/orders/1001 → 200
GET /api/orders/1002 → 200 (pedido de outro cliente)

# Testar IDOR
curl -H "Authorization: Bearer TOKEN" https://api.alvo.com/users/1
curl -H "Authorization: Bearer TOKEN" https://api.alvo.com/users/2
curl -H "Authorization: Bearer TOKEN" https://api.alvo.com/users/3

Privilege Escalation

Vertical: usuário comum → admin
  - Modificar parâmetro: role=admin, isAdmin=true
  - Acessar /admin sem permissão

Horizontal: usuário A → usuário B
  - Alterar ID na URL: /user/123 → /user/456

Path Traversal

# Directory traversal
../../etc/passwd
..%252f..%252f..%252fetc/passwd       # Double URL encoding
....//....//....//etc/passwd           # Bypass filter
..;/..;/..;/etc/passwd                 # Bypass filter (Java)
file:///etc/passwd                     # Protocolo file

CORS Misconfiguration

# Configuração insegura — qualquer origem pode ler resposta
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true

# Ataque: site malicioso lê dados da API alvo via JavaScript
# fetch('https://api.alvo.com/dados', { credentials: 'include' })

OAuth2/OIDC Security

Ataques Comuns

- CSRF no flow OAuth (state parameter ausente)
- Code injection (interceptar authorization code)
- Token interception (redirect_uri mal configurado)
- Consent phishing (escopo excessivo)
- Mix-up attacks (confundir authorization server com resource server)

Mitigações

- state parameter obrigatório (anti-CSRF)
- PKCE (Proof Key for Code Exchange) — S256
- redirect_uri configurado estritamente
- Validar nonce no ID Token
- Escopos mínimos necessários

MFA Implementation

# Exemplo de implementação TOTP
import pyotp

# Gerar secret
secret = pyotp.random_base32()
qr_url = pyotp.totp.TOTP(secret).provisioning_uri("[email protected]", issuer="App")

# Verificar código
totp = pyotp.TOTP(secret)
valid = totp.verify(user_input)  # Código de 6 dígitos

Lab: Testando Autenticação

# 1. Testar IDOR em API REST
curl -H "Authorization: Bearer TOKEN" https://api.alvo.com/users/1
curl -H "Authorization: Bearer TOKEN" https://api.alvo.com/users/2

# 2. Testar JWT alg:none
# Decodificar token
# https://jwt.io

# 3. Verificar headers de segurança
curl -I https://alvo.com | findstr "Strict-Transport-Security"
curl -I https://alvo.com | findstr "Set-Cookie"

# 4. Testar path traversal
curl https://alvo.com/../../etc/passwd

# 5. Verificar CORS
curl -H "Origin: https://atacante.com" -I https://api.alvo.com | findstr "Access-Control"

Falhas de autenticação são as mais exploradas. JWT com alg:none é inaceitável em produção. MFA e rate limiting resolvem 80% dos problemas. Sempre valide permissões no servidor, nunca confie no frontend.