Construindo um Sistema de Rastreamento de Infraestrutura de Adversários

Visão Geral

O rastreamento de infraestrutura de adversários 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ças. Atacantes frequentemente reutilizam provedores de hospedagem, registradores, certificados SSL e padrões de nomenclatura entre campanhas, permitindo que analistas façam pivô de indicadores conhecidos para descobrir nova infraestrutura. Esta habilidade abrange a construção de um sistema de rastreamento automatizado que identifica relacionamentos de infraestrutura, detecta domínios recém-registrados que correspondem a padrões de adversários e mantém um mapa continuamente atualizado de redes de atores de ameaças.

Quando Usar

• Ao implantar ou configurar capacidades de construção de sistema de rastreamento de infraestrutura de adversários em seu ambiente
• Ao estabelecer controles de segurança alinhados aos 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 requests, dnspython, python-whois, shodan, networkx bibliotecas
• 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ínio
• Banco de dados de grafos (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 foram resolvidos para quais IPs e quando. Ao contrário das consultas de DNS ativas, o DNS passivo preserva relacionamentos históricos mesmo após a alteração dos registros, permitindo que analistas rastreiem mudanças na infraestrutura, identifiquem padrões de hospedagem compartilhada e descubram domínios relacionados que foram resolvidos para os mesmos endereços IP ao longo do tempo.

Pivô de Infraestrutura

O pivô identifica infraestrutura relacionada seguindo conexões: pivô de IP (encontrar todos os domínios em um IP), pivô de domínio (encontrar todos os IPs para os quais um domínio foi resolvido), pivô WHOIS (encontrar domínios com o mesmo registrador), pivô de certificado (encontrar hosts que compartilham certificados SSL) e pivô NS/MX (encontrar domínios usando os mesmos servidores de nome ou servidores de e-mail).

Padrões de Infraestrutura de Adversários

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

Fluxo de Trabalho

Etapa 1: Descoberta de Infraestrutura de 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):
        """Consulta 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):
        """Encontra 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")

…