Análise de Canais Ocultos de Rede em Malware

Visão Geral

Malware usa canais ocultos para disfarçar a comunicação C2 (Comando e Controle) e a exfiltração de dados dentro de tráfego de rede com aparência legítima. O túnel DNS codifica dados em consultas e respostas DNS (usado por ferramentas como iodine, dnscat2 e famílias de malware como FrameworkPOS). O túnel ICMP esconde dados em payloads de requisição/resposta de eco (icmpsh, ptunnel). Canais ocultos HTTP incorporam dados C2 em cabeçalhos, cookies ou imagens esteganográficas. O abuso de protocolos explora protocolos permitidos para contornar firewalls. A detecção de túnel DNS atinge mais de 99% de recall com abordagens modernas baseadas em ML, embora a exfiltração de baixo throughput permaneça desafiadora. A Unit42 da Palo Alto rastreou três grandes campanhas de túnel DNS (TrkCdn, SecShow, Savvy Seahorse) ao longo de 2024, demonstrando a prevalência contínua da técnica.

Quando Usar

• Ao investigar incidentes de segurança que exigem a análise de canais ocultos de rede em malware
• Ao construir regras de detecção ou consultas de caça a ameaças para este domínio
• Quando analistas de SOC precisam de procedimentos estruturados para este tipo de análise
• Ao validar a cobertura de monitoramento de segurança para técnicas de ataque relacionadas

Pré-requisitos

• Python 3.9+ com scapy, dpkt, dnslib
• Wireshark/tshark para análise de PCAP
• Zeek (anteriormente Bro) para monitoramento de rede
• Infraestrutura de log de consultas DNS
• Compreensão dos protocolos DNS, ICMP, HTTP em nível de pacote

Fluxo de Trabalho

Etapa 1: Detecção de Túnel DNS

#!/usr/bin/env python3
"""Detecta túnel DNS e canais ocultos em tráfego de rede."""
import sys
import json
import math
from collections import Counter, defaultdict

try:
    from scapy.all import rdpcap, DNS, DNSQR, DNSRR, IP, ICMP
except ImportError:
    print("pip install scapy")
    sys.exit(1)


def entropy(data):
    if not data:
        return 0
    freq = Counter(data)
    length = len(data)
    return -sum((c/length) * math.log2(c/length) for c in freq.values())


def analyze_dns_tunneling(pcap_path):
    """Detecta indicadores de túnel DNS em PCAP."""
    packets = rdpcap(pcap_path)
    domain_stats = defaultdict(lambda: {
        "queries": 0, "total_qname_len": 0, "subdomain_lengths": [],
        "query_types": Counter(), "unique_subdomains": set(),
    })

    for pkt in packets:
        if pkt.haslayer(DNS) and pkt.haslayer(DNSQR):
            qname = pkt[DNSQR].qname.decode('utf-8', errors='replace').rstrip('.')
            qtype = pkt[DNSQR].qtype

            parts = qname.split('.')
            if len(parts) >= 3:
                base_domain = '.'.join(parts[-2:])
                subdomain = '.'.join(parts[:-2])

                stats = domain_stats[base_domain]
                stats["queries"] += 1
                stats["total_qname_len"] += len(qname)
                stats["subdomain_lengths"].append(len(subdomain))
                stats["query_types"][qtype] += 1
                stats["unique_subdomains"].add(subdomain)

    # Pontua domínios para indicadores de túnel
    suspicious = []
    for domain, stats in domain_stats.items():
        if stats["queries"] < 5:
            continue

        avg_subdomain_len = (sum(stats["subdomain_lengths"]) /
                             len(stats["subdomain_lengths"]))
        unique_ratio = len(stats["unique_subdomains"]) / stats["queries"]

        # Calcula a entropia do subdomínio
        all_subdomains = ''.join(stats["unique_subdomains"])
        sub_entropy = entropy(all_subdomains)

        score = 0
        reasons = []

        if avg_subdomain_len > 30:
            score += 30
            reasons.append(f"Subdomínios longos (média {avg_subdomain_len:.0f} caracteres)")
        if unique_ratio > 0.9:
            score += 25
            reasons.append(f"Alta exclusividade ({unique_ratio:.2%})")
        if sub_entropy > 4.0:
            score += 25
            reasons.append(f"Alta entropia ({sub_entropy:.2f})")
        if stats["query_types"].get(16, 0) > 10:  # Registros TXT
            score += 20
            reasons.append(f"Muitas consultas TXT ({stats['query_types'][16]})")

        if score >= 50:
            suspicious.append({
                "domain": domain,
                "score": score,
                "queries": stats["queries"],
                "avg_subdomain_length": round(avg_subdomain_len, 1),
                "unique_subdomains": len(stats["unique_subdomains"]),
                "subdomain_entropy": round(sub_entropy, 2),
                "reasons": reasons,
            })


…