Explorando a Exposição Excessiva de Dados em APIs

Quando Usar

• Testando APIs onde o frontend exibe um subconjunto de dados, mas a resposta da API inclui campos adicionais
• Avaliando APIs de aplicativos móveis onde as respostas são projetadas para vários tipos de clientes e podem conter dados em excesso
• Identificando vazamentos de PII (Informações de Identificação Pessoal) em respostas de API que incluem endereços de e-mail, números de telefone, SSNs (Números de Seguro Social) ou dados de pagamento não mostrados na interface do usuário
• Testando APIs GraphQL onde os clientes podem solicitar campos arbitrários, incluindo atributos sensíveis
• Avaliando APIs após refatoração de microsserviços onde dados internos de serviço para serviço vazam para endpoints públicos

Não use sem autorização por escrito. O teste de exposição de dados envolve a captura e análise de dados pessoais potencialmente sensíveis.

Pré-requisitos

• Autorização por escrito especificando os endpoints da API alvo e o escopo
• Burp Suite Professional ou mitmproxy configurado como proxy de interceptação
• Duas contas de teste em níveis de privilégio diferentes (usuário regular e administrador)
• Ferramentas de desenvolvedor do navegador ou configuração de proxy móvel para captura de tráfego
• Python 3.10+ com bibliotecas requests e json
• Documentação da API (especificação OpenAPI) para comparação com as respostas reais

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 por escrito para testar é ilegal e pode violar leis de fraude computacional.

Fluxo de Trabalho

Etapa 1: Descoberta do Esquema de Resposta

Compare as respostas documentadas da API com as respostas reais:

import requests
import json

BASE_URL = "https://target-api.example.com/api/v1"
headers = {"Authorization": "Bearer <user_token>", "Content-Type": "application/json"}

# Fetch a resource and analyze all returned fields
endpoints_to_test = [
    ("GET", "/users/me", None),
    ("GET", "/users/me/orders", None),
    ("GET", "/products", None),
    ("GET", "/users/me/settings", None),
    ("GET", "/transactions", None),
]

for method, path, body in endpoints_to_test:
    resp = requests.request(method, f"{BASE_URL}{path}", headers=headers, json=body)
    if resp.status_code == 200:
        data = resp.json()
        # Recursively extract all field names
        def extract_fields(obj, prefix=""):
            fields = []
            if isinstance(obj, dict):
                for k, v in obj.items():
                    full_key = f"{prefix}.{k}" if prefix else k
                    fields.append(full_key)
                    fields.extend(extract_fields(v, full_key))
            elif isinstance(obj, list) and obj:
                fields.extend(extract_fields(obj[0], f"{prefix}[]"))
            return fields

        all_fields = extract_fields(data)
        print(f"\n{method} {path} - {len(all_fields)} fields returned:")
        for f in sorted(all_fields):
            print(f"  {f}")

Etapa 2: Detecção de Padrões de Dados Sensíveis

Analise as respostas da API em busca de padrões de dados sensíveis:

import re

SENSITIVE_PATTERNS = {
    "email": r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
    "phone": r'(\+?1?\s?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4})',
    "ssn": r'\b\d{3}-\d{2}-\d{4}\b',
    "credit_card": r'\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13})\b',
    "password_hash": r'\$2[aby]?\$\d{2}\$[./A-Za-z0-9]{53}',
    "api_key": r'(?:api[_-]?key|apikey)["\s:=]+["\']?([a-zA-Z0-9_\-]{20,})',
    "internal_ip": r'\b(?:10\.\d{1,3}|172\.(?:1[6-9]|2\d|3[01])|192\.168)\.\d{1,3}\.\d{1,3}\b',
    "aws_key": r'AKIA[0-9A-Z]{16}',
    "jwt_token": r'eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+',
    "uuid": r'[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}',
}

SENSITIVE_FIELD_NAMES = [
    "password", "password_hash", "secret", "token", "ssn", "social_security",
    "credit_card", "card_number", "cvv", "pin", "private_key", "api_key",
    "internal_id", "debug", "trace", "stack_trace", "created_by_ip",
    "last_login_ip", "salt", "session_id", "refresh_token", "mfa_secret",
    "date_of_birth", "bank_account", "routing_number", "tax_id"
]

def scan_response(endpoint, response_text):
    findings = []
    # Check for sensitive data patterns in values
    for pattern_name, pattern in SENSITIVE_PATTERNS.items():
        matches = re.findall(pattern, response_text)
        if matches:
            findings.append({
                "endpoint": endpoint,
                "type": "sensitive_value",
                "pattern": pattern_name,
                "count": len(matches),

…