Detecção de Comando e Controle Via DNS

Quando Usar

• Investigando suspeitas de túneis DNS usados para comunicação C2 ou exfiltração de dados
• Analisando logs de consultas DNS em busca de sinais de payloads codificados em strings de subdomínios
• Classificando domínios como gerados por DGA vs. legítimos usando métodos estatísticos ou de ML
• Detectando padrões de beaconing DNS (intervalos regulares, tamanhos de consulta consistentes)
• Caçando por tráfego Iodine, dnscat2, dns2tcp, Cobalt Strike DNS ou Sliver DNS
• Monitorando o abuso de registros TXT para entrega de comandos ou download de payloads em estágios
• Construindo regras de detecção de anomalias DNS para implantação em SOC/SIEM

Não use para monitoramento geral de desempenho DNS ou auditoria de configuração DNS; use ferramentas de monitoramento de saúde DNS para isso. Para detecção de C2 baseada em HTTP/HTTPS, use habilidades de análise de tráfego de rede focadas em protocolos web.

AVISO LEGAL: As ferramentas de túnel DNS referenciadas nesta habilidade (Iodine, dnscat2, dns2tcp) são de uso duplo. Elas têm usos legítimos (contornar portais cativos, pesquisa de segurança) e usos maliciosos (canais C2, exfiltração). Implante a detecção apenas em redes que você está autorizado a monitorar. Testar ferramentas de túnel requer autorização explícita.

Pré-requisitos

• Logs de consultas DNS do resolvedor recursivo, Zeek/Bro, Suricata ou tap de DNS passivo
• Python 3.9+ com numpy, scikit-learn, pandas, tldextract e dnspython
• Zeek (anteriormente Bro) com saída dns.log ou Suricata com log JSON EVE de DNS
• Acesso a SIEM (Splunk, Elastic, Microsoft Sentinel) para correlação de logs
• Acesso a banco de dados de DNS passivo (CIRCL pDNS, Farsight DNSDB ou interno) para enriquecimento
• Wireshark/tshark para inspeção de DNS em nível de pacote
• Lista branca de domínios conhecidos como bons (Alexa/Tranco top 1M ou Majestic Million)

Fluxo de Trabalho

Etapa 1: Coletar e Analisar Logs de Consultas DNS

Ingerir tráfego DNS de sensores de rede e analisar em formato legível:

# Zeek - extract dns.log fields
# Default Zeek dns.log columns:
# ts uid id.orig_h id.orig_p id.resp_h id.resp_p proto trans_id rtt query
# qclass qclass_name qtype qtype_name rcode rcode_name AA TC RD RA Z
# answers TTLs rejected

# Filter for potentially suspicious record types
cat dns.log | zeek-cut ts id.orig_h query qtype_name answers rcode_name | \
    grep -E "TXT|NULL|CNAME|MX" > suspicious_qtypes.log

# Extract unique queried domains
cat dns.log | zeek-cut query | sort -u > unique_domains.txt

# Suricata EVE JSON - extract DNS events
cat eve.json | jq -r 'select(.event_type=="dns") |
    [.timestamp, .src_ip, .dns.rrname, .dns.rrtype, .dns.rcode] |
    @tsv' > dns_events.tsv

# tshark - extract DNS queries from pcap
tshark -r capture.pcap -T fields \
    -e frame.time -e ip.src -e ip.dst \
    -e dns.qry.name -e dns.qry.type \
    -e dns.resp.type -e dns.txt \
    -Y "dns" > dns_queries.tsv

# Count queries per domain (find high-volume destinations)
cat dns.log | zeek-cut query | \
    awk -F. '{print $(NF-1)"."$NF}' | \
    sort | uniq -c | sort -rn | head -50

Etapa 2: Análise de Entropia de Shannon de Consultas DNS

Calcular a entropia de strings de subdomínios para identificar dados codificados/criptografados:

#!/usr/bin/env python3
"""Análise de entropia de Shannon para subdomínios de consultas DNS."""

import math
import csv
import sys
from collections import Counter

try:
    import tldextract
    HAS_TLDEXTRACT = True
except ImportError:
    HAS_TLDEXTRACT = False


def shannon_entropy(data):
    """Calcular a entropia de Shannon de uma string (bits por caractere)."""
    if not data:
        return 0.0
    counter = Counter(data)
    length = len(data)
    entropy = -sum(
        (count / length) * math.log2(count / length)
        for count in counter.values()
    )
    return entropy


def extract_subdomain(fqdn):
    """Extrair a porção do subdomínio de um nome de domínio totalmente qualificado."""
    if HAS_TLDEXTRACT:
        ext = tldextract.extract(fqdn)
        if ext.subdomain:
            return ext.subdomain, f"{ext.domain}.{ext.suffix}"
        return "", f"{ext.domain}.{ext.suffix}"
    else:
        # Fallback: assumir que os dois últimos rótulos são domínio + TLD
        parts = fqdn.rstrip(".").split(".")
        if len(parts) > 2:
            return ".".join(parts[:-2]), ".".join(parts[-2:])
        return "", fqdn


def analyze_dns_entropy(queries, entropy_threshold=3.5, length_threshold=30):
    """
    Analisar consultas DNS para indicadores de túnel usando entropia.

    Limiares (ajustáveis por ambiente):
      - entropy_threshold: Entropia de Shannon acima deste valor sinaliza como suspeito (3.5-4.0 típico)

…