Sistema de Rastreamento de Infraestrutura Adversária

Construção de Sistema de Rastreamento de Infraestrutura Adversária

Visão Geral

O rastreamento de infraestrutura adversária utiliza registros de DNS passivo, logs de transparência de certificados, dados de registro WHOIS e enriquecimento de IP para descobrir, mapear e monitorar redes de comando e controle (C2) de atores de ameaça. Atacantes frequentemente reutilizam provedores de hospedagem, registradores, certificados SSL e padrões de nomenclatura entre campanhas, permitindo que analistas pivotem a partir de indicadores conhecidos para descobrir novas infraestruturas. Esta habilidade abrange a construção de um sistema automatizado de rastreamento que identifica relações de infraestrutura, detecta domínios recém-registrados que correspondem a padrões adversários e mantém um mapa continuamente atualizado das redes de atores de ameaça.

Quando Usar

• Ao implantar ou configurar capacidades de sistema de rastreamento de infraestrutura adversária em seu ambiente
• Ao estabelecer controles de segurança alinhados a requisitos de conformidade
• Ao construir ou melhorar a arquitetura de segurança para este domínio
• Ao conduzir avaliações de segurança que exigem esta implementação

Pré-requisitos

• Python 3.9+ com as bibliotecas requests, dnspython, python-whois, shodan, networkx
• Chaves de API: SecurityTrails, PassiveTotal/RiskIQ, Shodan, VirusTotal
• Acesso a fontes de dados de DNS passivo
• Compreensão de infraestrutura de DNS, hospedagem e registro de domínios
• Banco de dados de grafo (Neo4j) ou NetworkX para visualização de relacionamentos

Conceitos Chave

DNS Passivo

O DNS passivo captura dados históricos de resolução de DNS, registrando quais domínios resolveram para quais IPs e quando. Diferente de consultas DNS ativas, o DNS passivo preserva relacionamentos históricos mesmo após as alterações nos registros, permitindo que analistas acompanhem mudanças de infraestrutura, identifiquem padrões de hospedagem compartilhada e descubram domínios relacionados que resolveram para os mesmos endereços IP ao longo do tempo.

Pivotagem de Infraestrutura

A pivotagem identifica infraestrutura relacionada seguindo conexões: pivotagem de IP (encontrar todos os domínios em um IP), pivotagem de domínio (encontrar todos os IPs para os quais um domínio resolveu), pivotagem de WHOIS (encontrar domínios com o mesmo registrante), pivotagem de certificado (encontrar hosts que compartilham certificados SSL) e pivotagem de NS/MX (encontrar domínios que usam os mesmos servidores de nomes ou servidores de correio).

Padrões de Infraestrutura Adversária

Atores de ameaça exibem padrões: registradores preferidos (Namecheap, REG.RU, Tucows), hospedagem preferida (provedores de hospedagem à prova de balas, serviços em nuvem), algoritmos de geração de domínios (DGA), padrões de nomenclatura consistentes e reutilização de certificados em campanhas.

Fluxo de Trabalho

Passo 1: Descoberta de Infraestrutura com DNS Passivo

import requests
import json
from collections import defaultdict
from datetime import datetime

class InfrastructureTracker:
    def __init__(self, securitytrails_key=None, vt_key=None, shodan_key=None):
        self.st_key = securitytrails_key
        self.vt_key = vt_key
        self.shodan_key = shodan_key
        self.infrastructure_graph = defaultdict(lambda: {"nodes": set(), "edges": []})

    def passive_dns_lookup(self, domain):
        """Consultar DNS passivo para histórico de resolução de domínio."""
        headers = {"apikey": self.st_key}
        url = f"https://api.securitytrails.com/v1/history/{domain}/dns/a"
        resp = requests.get(url, headers=headers, timeout=30)
        if resp.status_code == 200:
            records = resp.json().get("records", [])
            history = []
            for record in records:
                for value in record.get("values", []):
                    history.append({
                        "domain": domain,
                        "ip": value.get("ip", ""),
                        "first_seen": record.get("first_seen", ""),
                        "last_seen": record.get("last_seen", ""),
                        "type": record.get("type", "a"),
                    })
            print(f"[+] DNS passivo para {domain}: {len(history)} registros")
            return history
        return []

    def reverse_ip_lookup(self, ip_address):
        """Encontrar todos os domínios hospedados em um endereço IP."""
        headers = {"apikey": self.st_key}
        url = f"https://api.securitytrails.com/v1/ips/nearby/{ip_address}"
        resp = requests.get(url, headers=headers, timeout=30)
        if resp.status_code == 200:
            blocks = resp.json().get("blocks", [])
            domains = []
            for block in blocks:
                for site in block.get("sites", []):
                    domains.append(site)
            print(f"[+] IP reverso para {ip_address}: {len(domains)} domínios")
            return domains
        return []

    def whois_lookup(self, domain):
        """Obter dados de registro WHOIS para pivotagem."""
        headers = {"apikey": self.st_key}
        url = f"https://api.securitytrails.com/v1/domain/{domain}/whois"
        resp = requests.get(url, headers=headers, timeout=30)
        if resp.status_code == 200:
            data = resp.json()
            whois_data = {
                "domain": domain,
                "registrar": data.get("registrar", ""),
                "registrant_org": data.get("registrant_org", ""),
                "registrant_email": data.get("registrant_email", ""),
                "name_servers": data.get("nameServers", []),
                "created_date": data.get("createdDate", ""),
                "updated_date": data.get("updatedDate", ""),
                "expires_date": data.get("expiresDate", ""),
            }
            return whois_data
        return {}

    def pivot_from_seed(self, seed_indicator, indicator_type="domain", depth=2):
        """Pivotar recursivamente a partir de um indicador semente para descobrir infraestrutura."""
        discovered = {"domains": set(), "ips": set(), "relationships": []}

        if indicator_type == "domain":
            discovered["domains"].add(seed_indicator)
            # Obter IPs para o domínio
            pdns = self.passive_dns_lookup(seed_indicator)
            for record in pdns:
                ip = record["ip"]
                discovered["ips"].add(ip)
                discovered["relationships"].append({
                    "source": seed_indicator, "target": ip,
                    "type": "resolves_to",
                    "first_seen": record["first_seen"],
                    "last_seen": record["last_seen"],
                })

                if depth > 1:
                    # Consulta reversa nos IPs descobertos
                    reverse_domains = self.reverse_ip_lookup(ip)
                    for rd in reverse_domains[:20]:
                        discovered["domains"].add(rd)
                        discovered["relationships"].append({
                            "source": rd, "target": ip,
                            "type": "hosted_on",
                        })

        elif indicator_type == "ip":
            discovered["ips"].add(seed_indicator)
            domains = self.reverse_ip_lookup(seed_indicator)
            for domain in domains[:20]:
                discovered["domains"].add(domain)
                discovered["relationships"].append({
                    "source": domain, "target": seed_indicator,
                    "type": "hosted_on",
                })

        print(f"[+] Pivotagem de {seed_indicator}: "
              f"{len(discovered['domains'])} domínios, "
              f"{len(discovered['ips'])} IPs, "
              f"{len(discovered['relationships'])} relacionamentos")
        return discovered

tracker = InfrastructureTracker(
    securitytrails_key="SUA_CHAVE_ST",
    vt_key="SUA_CHAVE_VT",
)

Passo 2: Construir Grafo de Infraestrutura

import networkx as nx

class InfrastructureGraph:
    def __init__(self):
        self.graph = nx.Graph()

    def add_discovery(self, discovery_data):
        """Adicionar infraestrutura descoberta ao grafo."""
        for domain in discovery_data["domains"]:
            self.graph.add_node(domain, type="domain")
        for ip in discovery_data["ips"]:
            self.graph.add_node(ip, type="ip")
        for rel in discovery_data["relationships"]:
            self.graph.add_edge(
                rel["source"], rel["target"],
                relationship=rel["type"],
                first_seen=rel.get("first_seen", ""),
                last_seen=rel.get("last_seen", ""),
            )

    def find_clusters(self):
        """Identificar clusters de infraestrutura."""
        components = list(nx.connected_components(self.graph))
        clusters = []
        for component in components:
            domains = [n for n in component if self.graph.nodes[n].get("type") == "domain"]
            ips = [n for n in component if self.graph.nodes[n].get("type") == "ip"]
            clusters.append({
                "size": len(component),
                "domains": sorted(domains),
                "ips": sorted(ips),
                "domain_count": len(domains),
                "ip_count": len(ips),
            })
        clusters.sort(key=lambda x: x["size"], reverse=True)
        print(f"[+] Clusters de infraestrutura: {len(clusters)}")
        return clusters

    def find_hub_nodes(self, top_n=10):
        """Encontrar nós de alta centralidade (infraestrutura compartilhada)."""
        centrality = nx.degree_centrality(self.graph)
        top_nodes = sorted(centrality.items(), key=lambda x: x[1], reverse=True)[:top_n]
        hubs = []
        for node, score in top_nodes:
            hubs.append({
                "node": node,
                "type": self.graph.nodes[node].get("type", "unknown"),
                "centrality": round(score, 4),
                "connections": self.graph.degree(node),
            })
        return hubs

    def export_graph(self, output_file="infrastructure_graph.json"):
        data = nx.node_link_data(self.graph)
        with open(output_file, "w") as f:
            json.dump(data, f, indent=2)
        print(f"[+] Grafo exportado: {self.graph.number_of_nodes()} nós, "
              f"{self.graph.number_of_edges()} arestas")

infra_graph = InfrastructureGraph()
discovery = tracker.pivot_from_seed("evil-domain.com", depth=2)
infra_graph.add_discovery(discovery)
clusters = infra_graph.find_clusters()
hubs = infra_graph.find_hub_nodes()
infra_graph.export_graph()

Passo 3: Monitorar Nova Infraestrutura

import time

class InfrastructureMonitor:
    def __init__(self, tracker, known_indicators):
        self.tracker = tracker
        self.known = set(known_indicators)
        self.alerts = []

    def check_new_registrations(self, patterns):
        """Verificar novos domínios registrados que correspondem a padrões adversários."""
        import re
        new_domains = []
        for pattern in patterns:
            # Consultar SecurityTrails para novos domínios correspondentes ao padrão
            headers = {"apikey": self.tracker.st_key}
            url = "https://api.securitytrails.com/v1/domains/list"
            params = {"include_ips": "true", "page": 1}
            body = {"filter": {"keyword": pattern}}
            resp = requests.post(url, headers=headers, json=body, timeout=30)
            if resp.status_code == 200:
                records = resp.json().get("records", [])
                for record in records:
                    domain = record.get("hostname", "")
                    if domain not in self.known:
                        new_domains.append({
                            "domain": domain,
                            "pattern_matched": pattern,
                            "first_seen": datetime.now().isoformat(),
                        })
                        self.known.add(domain)

        if new_domains:
            print(f"[ALERTA] {len(new_domains)} novos domínios correspondentes a padrões")
            self.alerts.extend(new_domains)
        return new_domains

    def generate_infrastructure_report(self, clusters, hubs):
        report = f"""# Relatório de Rastreamento de Infraestrutura Adversária
Gerado: {datetime.now().isoformat()}

## Resumo
- Clusters de infraestrutura identificados: {len(clusters)}
- Total de domínios rastreados: {sum(c['domain_count'] for c in clusters)}
- Total de IPs rastreados: {sum(c['ip_count'] for c in clusters)}
- Novos domínios detectados: {len(self.alerts)}

## Principais Hubs de Infraestrutura
| Nó | Tipo | Conexões | Centralidade |
|------|------|-------------|------------|
"""
        for hub in hubs[:10]:
            report += (f"| {hub['node']} | {hub['type']} "
                       f"| {hub['connections']} | {hub['centrality']} |\n")

        report += "\n## Clusters de Infraestrutura\n"
        for i, cluster in enumerate(clusters[:5], 1):
            report += f"\n### Cluster {i} ({cluster['size']} nós)\n"
            report += f"- Domínios: {', '.join(cluster['domains'][:5])}\n"
            report += f"- IPs: {', '.join(cluster['ips'][:5])}\n"

        with open("infrastructure_report.md", "w") as f:
            f.write(report)
        print("[+] Relatório de infraestrutura salvo")

monitor = InfrastructureMonitor(tracker, known_indicators=set())

Critérios de Validação

• Consultas de DNS passivo retornam dados históricos de resolução
• Consultas reversas de IP descobrem domínios co-hospedados
• A pivotagem de infraestrutura expande a partir de indicadores semente
• A análise de grafo identifica clusters e nós centrais
• Nova infraestrutura é detectada por meio de monitoramento de padrões
• Relatórios gerados com recomendações acionáveis

Referências

• Juniper: Threat Hunting with Passive DNS
• Censys: Advanced Persistent Infrastructure Tracking
• Embee Research: Malware Infrastructure with DNS Pivoting
• Validin: Passive DNS Threat Hunting
• SecurityTrails API
• Hunt.io: Uncovering Malicious Infrastructure