Análise de Logs de DNS para Exfiltração

Quando Usar

Use esta habilidade quando:

• Equipes de SOC suspeitarem de exfiltração de dados através de tunelamento DNS para contornar controles de firewall/proxy
• Inteligência de ameaças indicar que adversários estão usando canais de C2 baseados em DNS (por exemplo, beacon DNS do Cobalt Strike)
• UEBA detectar volumes anômalos de consultas DNS de hosts específicos
• Análise de malware revelar capacidades de DNS-over-HTTPS (DoH) ou tunelamento DNS

Não use para solução de problemas padrão de DNS ou monitoramento de disponibilidade — esta habilidade foca na detecção de abuso de DNS relevante para segurança.

Pré-requisitos

• Registro de consultas DNS habilitado (Windows DNS Server, Bind, Infoblox ou Cisco Umbrella)
• Logs de DNS ingeridos no SIEM (Splunk com sourcetype Stream:DNS, dns, ou logs DNS do Zeek)
• Dados de DNS Passivo para análise histórica de resolução de domínio
• Linha de base do comportamento normal de DNS (volume de consultas, distribuição de domínios, frequência de registros TXT)
• Python com bibliotecas math e collections para cálculo de entropia

Fluxo de Trabalho

Etapa 1: Detectar Tunelamento DNS por Análise de Comprimento de Subdomínio

O tunelamento DNS codifica dados em rótulos de subdomínio, criando consultas anormalmente longas:

index=dns sourcetype="stream:dns" query_type IN ("A", "AAAA", "TXT", "CNAME", "MX")
| eval domain_parts = split(query, ".")
| eval subdomain = mvindex(domain_parts, 0, mvcount(domain_parts)-3)
| eval subdomain_str = mvjoin(subdomain, ".")
| eval subdomain_len = len(subdomain_str)
| eval tld = mvindex(domain_parts, -1)
| eval registered_domain = mvindex(domain_parts, -2).".".tld
| where subdomain_len > 50
| stats count AS queries, dc(query) AS unique_queries,
        avg(subdomain_len) AS avg_subdomain_len,
        max(subdomain_len) AS max_subdomain_len,
        values(src_ip) AS sources
  by registered_domain
| where queries > 20
| sort - avg_subdomain_len
| table registered_domain, queries, unique_queries, avg_subdomain_len, max_subdomain_len, sources

Etapa 2: Detectar Consultas de Domínio de Alta Entropia (Detecção de DGA)

Algoritmos de Geração de Domínio produzem domínios com aparência aleatória:

index=dns sourcetype="stream:dns"
| eval domain_parts = split(query, ".")
| eval sld = mvindex(domain_parts, -2)
| eval sld_len = len(sld)
| eval char_count = sld_len
| eval vowels = len(replace(sld, "[^aeiou]", ""))
| eval consonants = len(replace(sld, "[^bcdfghjklmnpqrstvwxyz]", ""))
| eval digits = len(replace(sld, "[^0-9]", ""))
| eval vowel_ratio = if(char_count > 0, vowels / char_count, 0)
| eval digit_ratio = if(char_count > 0, digits / char_count, 0)
| where sld_len > 12 AND (vowel_ratio < 0.2 OR digit_ratio > 0.3)
| stats count AS queries, dc(query) AS unique_domains, values(src_ip) AS sources
  by query
| where unique_domains > 10
| sort - queries

Cálculo de Entropia de Shannon baseado em Python para consultas DNS:

import math
from collections import Counter

def shannon_entropy(text):
    """Calculate Shannon entropy of a string"""
    if not text:
        return 0
    counter = Counter(text.lower())
    length = len(text)
    entropy = -sum(
        (count / length) * math.log2(count / length)
        for count in counter.values()
    )
    return round(entropy, 4)

# Test with examples
normal_domain = "google"           # Low entropy
dga_domain = "x8kj2m9p4qw7n"      # High entropy
tunnel_subdomain = "aGVsbG8gd29ybGQ.evil.com"  # Base64 encoded data

print(f"Normal: {shannon_entropy(normal_domain)}")     # ~2.25
print(f"DGA:    {shannon_entropy(dga_domain)}")         # ~3.70
print(f"Tunnel: {shannon_entropy(tunnel_subdomain)}")   # ~3.50

# Threshold: entropy > 3.5 for subdomain = likely tunneling/DGA

Implementação de pontuação de entropia no Splunk:

index=dns sourcetype="stream:dns"
| eval domain_parts = split(query, ".")
| eval check_string = mvindex(domain_parts, 0)
| eval check_len = len(check_string)
| where check_len > 8
| eval chars = split(check_string, "")
| stats count AS total_chars, dc(chars) AS unique_chars by query, src_ip, check_string, check_len
| eval entropy_estimate = log(unique_chars, 2) * (unique_chars / check_len)
| where entropy_estimate > 3.5
| stats count AS high_entropy_queries, dc(query) AS unique_queries by src_ip
| where high_entropy_queries > 50
| sort - high_entropy_queries

Etapa 3: Detectar Volume Anômalo de Consultas DNS

Identificar hosts gerando tráfego DNS anormal:

index=dns sourcetype="stream:dns" earliest=-24h
| bin _time span=1h
| stats count AS queries, dc(query) AS unique_domains by src_ip, _time

…