Realizando Inventário e Descoberta de APIs

Quando Usar

• Mapear a superfície completa de ataque de APIs de uma organização antes de uma avaliação de segurança
• Identificar APIs "sombra" (shadow APIs) implantadas por equipes de desenvolvimento sem revisão de segurança
• Descobrir versões de API descontinuadas ou "zumbis" que permanecem acessíveis, mas sem manutenção
• Encontrar endpoints de API não documentados expostos através de aplicativos móveis, SPAs (Single Page Applications) ou microsserviços
• Construir um inventário de APIs para requisitos de conformidade (PCI-DSS, SOC2, GDPR)

Não use sem autorização por escrito. A descoberta de APIs envolve a varredura da infraestrutura de rede e a análise de tráfego.

Pré-requisitos

• Autorização por escrito especificando os domínios e intervalos de rede alvo
• Capacidade de captura de tráfego passivo (tap de rede, proxy ou espelhamento de tráfego na nuvem)
• Ferramentas de varredura ativa: Amass, subfinder, httpx e nuclei
• Ferramentas de análise de JavaScript: LinkFinder, JS-Miner ou parsers personalizados
• Acesso ao console da nuvem (AWS, Azure, GCP) para inventário de API gateways
• Burp Suite Professional para descoberta passiva de endpoints de API

Fluxo de Trabalho

Passo 1: Descoberta Passiva de APIs a partir da Análise de Tráfego

import re
import json
from collections import defaultdict

# Parse HAR file from browser developer tools or proxy
def analyze_har_for_apis(har_file_path):
    """Extract API endpoints from HTTP Archive (HAR) file."""
    with open(har_file_path) as f:
        har = json.load(f)

    api_endpoints = defaultdict(lambda: {
        "methods": set(), "content_types": set(),
        "auth_types": set(), "count": 0
    })

    for entry in har["log"]["entries"]:
        url = entry["request"]["url"]
        method = entry["request"]["method"]

        # Identify API patterns
        api_patterns = [
            r'/api/', r'/v\d+/', r'/graphql', r'/rest/',
            r'/ws/', r'/rpc/', r'/grpc', r'/json',
        ]

        if any(re.search(p, url) for p in api_patterns):
            # Normalize the URL (remove query params and IDs)
            normalized = re.sub(r'\?.*$', '', url)
            normalized = re.sub(r'/\d+(/|$)', '/{id}\\1', normalized)
            normalized = re.sub(
                r'/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}',
                '/{uuid}', normalized)

            ep = api_endpoints[normalized]
            ep["methods"].add(method)
            ep["count"] += 1

            # Detect authentication type
            for header in entry["request"]["headers"]:
                name = header["name"].lower()
                if name == "authorization":
                    if "bearer" in header["value"].lower():
                        ep["auth_types"].add("Bearer/JWT")
                    elif "basic" in header["value"].lower():
                        ep["auth_types"].add("Basic")
                elif name == "x-api-key":
                    ep["auth_types"].add("API Key")

            # Detect content type
            content_type = next(
                (h["value"] for h in entry["request"]["headers"]
                 if h["name"].lower() == "content-type"), None)
            if content_type:
                ep["content_types"].add(content_type.split(";")[0])

    print(f"Discovered {len(api_endpoints)} unique API endpoints:\n")
    for url, info in sorted(api_endpoints.items()):
        methods = ", ".join(sorted(info["methods"]))
        auth = ", ".join(info["auth_types"]) or "None"
        print(f"  [{methods}] {url}")
        print(f"    Auth: {auth} | Requests: {info['count']}")

    return api_endpoints

Passo 2: Descoberta Ativa de Endpoints de API

# DNS enumeration for API subdomains
amass enum -d example.com -o amass_results.txt
subfinder -d example.com -o subfinder_results.txt

# Filter for API-related subdomains
grep -iE '(api|rest|graphql|ws|gateway|backend|internal|staging|dev|v1|v2)' \
    amass_results.txt subfinder_results.txt | sort -u > api_subdomains.txt

# Check which subdomains are alive
cat api_subdomains.txt | httpx -status-code -content-length -title \
    -tech-detect -o live_apis.txt

# Probe common API paths on each live subdomain
cat api_subdomains.txt | while read domain; do
    for path in /api /api/v1 /api/v2 /graphql /swagger.json /openapi.json \
                /api-docs /docs /health /status /metrics /actuator; do
        curl -s -o /dev/null -w "%{http_code} %{url_effective}\n" \
            "https://${domain}${path}" 2>/dev/null | grep -v "^404"
    done
done

import requests
import concurrent.futures


…