FastNetMon: Mitigação Automatizada de Ataques DDoS

O Desafio da Mitigação de Ataques DDoS em Ambientes Modernos

A segurança de rede moderna enfrenta um desafio constante: a escalabilidade e a sofisticação dos ataques de Negação de Serviço Distribuída (DDoS). Enquanto firewalls tradicionais e sistemas de detecção de intrusão (IDS/IPS) são eficazes contra vetores específicos, eles frequentemente operam em modo síncrono ou com latência significativa para identificar e bloquear tráfego malicioso em tempo real, especialmente quando o volume de dados excede a capacidade de processamento do hardware local. É aqui que ferramentas como o FastNetMon se tornam cruciais.

O FastNetMon é uma solução open-source altamente performática para detecção e mitigação automática de ataques DDoS. Ele funciona analisando fluxos de rede (NetFlow, sFlow, IPFIX) em tempo real, identificando padrões anômalos que indicam um ataque e integrando-se a gateways BGP ou firewalls para bloquear o tráfego malicioso instantaneamente. Neste tutorial técnico, vamos configurar uma stack completa de monitoramento e segurança, utilizando FastNetMon como núcleo da mitigação, Prometheus para coleta de métricas, Grafana para visualização, Wazuh para gestão de logs e segurança do host, Akvorado para coleta avançada de fluxos e Uptime Kuma para verificação de disponibilidade.

Arquitetura da Solução Proposta

Antes de iniciar a instalação, é fundamental entender como os componentes se comunicam. A arquitetura proposta segue uma linha de processamento de dados de rede:

1. Akvorado (Collector): Atua como o coletor de fluxos NetFlow/IPFIX. Ele recebe os pacotes do roteador ou switch, parseia os cabeçalhos e exporta os dados para um banco de dados otimizado.
2. Prometheus: Consome as métricas expostas pelo Akvorado e pelo próprio FastNetMon. É o sistema de armazenamento de séries temporais (TSDB).
3. Grafana: Conecta-se ao Prometheus para criar dashboards visuais que permitem aos administradores visualizar picos de tráfego e ataques em andamento.
4. FastNetMon: Consulta o banco de dados ou recebe alertas das métricas. Quando detecta um pico acima do threshold configurado, ele executa scripts de mitigação (ex: enviar comandos BGP Flowspec ou atualizar regras no firewall).
5. Wazuh: Monitora a integridade dos arquivos de configuração e logs do sistema para garantir que o servidor de segurança não foi comprometido.
6. Uptime Kuma: Monitora a saúde dos serviços HTTP/API expostos por essas ferramentas, garantindo que o painel de controle esteja acessível.

Etapa 1: Instalação e Configuração do Coletor de Fluxos (Akvorado)

O Akvorado é um coletor de fluxos escrito em Go, projetado para ser leve e eficiente. Ele será responsável por transformar o tráfego bruto da rede em dados estruturados que o FastNetMon pode analisar.

Inicie a instalação do Akvorado em seu servidor Linux (exemplo baseado em Debian/Ubuntu).

# Atualize o sistema
apt update && apt upgrade -y

# Instale dependências básicas
apt install -y curl wget gnupg2 software-properties-common

# Adicione o repositório oficial do Akvorado e instale
curl -fsSL https://packagecloud.io/install/repositories/akvorado/stable/script.deb.sh | bash
apt install akvorado

Após a instalação, edite o arquivo de configuração principal /etc/akvorado/akvorado.yaml. Você deve definir os endereços de escuta para os protocolos NetFlow (UDP 2055), sFlow (UDP 6343) e IPFIX (TCP/UDP 4739). Além disso, configure o destino dos dados. Para este tutorial, configuraremos o Akvorado para exportar métricas compatíveis com Prometheus.

# Exemplo de configuração básica no arquivo yaml
collector:
  netflow:
    listen: "0.0.0.0:2055"
  sflow:
    listen: "0.0.0.0:6343"
  ipfix:
    listen: "0.0.0.0:4739"

database:
  type: postgres # Ou InfluxDB, dependendo da sua preferência de escala
  connection: "postgres://user:pass@localhost/akvorado"

metrics:
  prometheus:
    enabled: true
    listen: ":8081"

Inicie o serviço e verifique se as métricas estão sendo expostas:

systemctl enable akvorado --now
curl http://localhost:8081/metrics

Etapa 2: Implantação do FastNetMon

O FastNetMon precisa de acesso aos dados de fluxo para tomar decisões. Ele pode se conectar diretamente ao banco de dados configurado no Akvorado ou usar um backend próprio. Para este cenário, vamos utilizar o backend PostgreSQL compartilhado ou configurar o FastNetMon para ler as métricas do Prometheus que foram alimentadas pelo Akvorado.

Instale o FastNetMon:

# Baixar a versão mais recente do repositório oficial
wget https://github.com/FastnetMon/fastnetmon/releases/download/v2023.11/fnm_linux_amd64.tar.gz
tar -xzf fnm_linux_amd64.tar.gz
cp fastnetmon /usr/local/bin/
chmod +x /usr/local/bin/fastnetmon

Crie o arquivo de configuração /etc/fastnetmon.conf. A parte crítica aqui é a seção [mitigation], onde definimos como o bloqueio será feito. Vamos usar um exemplo com script shell que adiciona regras no iptables, mas em produção, recomenda-se BGP Flowspec ou integração com provedores de limpeza de tráfego.

[general]
# Endereço IP da interface monitorada
interface_to_monitor=eth0
# Tipo de daemon
daemonize=true

[database]
# Conexão com o banco de dados onde o Akvorado escreve os fluxos
backend=postgresql
host=localhost
port=5432
user=fnm_user
password=strong_password
dbname=akvorado

[mitigation]
# Habilitar mitigação automática
mitigation_enabled=true
# Script executado quando um ataque é detectado
mitigation_script=/usr/local/bin/block_ip.sh
# Tempo em segundos para monitorar o tráfego antes de decidir (window)
monitoring_window=60

Crie o script de mitigação /usr/local/bin/block_ip.sh. Este script receberá o IP atacante como argumento:

#!/bin/bash
IP_TO_BLOCK=$1
echo "$(date): Bloqueando IP $IP_TO_BLOCK" >> /var/log/fnm_mitigation.log
iptables -A INPUT -s $IP_TO_BLOCK -j DROP
iptables -A FORWARD -s $IP_TO_BLOCK -j DROP

Torne o script executável e inicie o FastNetMon:

chmod +x /usr/local/bin/block_ip.sh
fastnetmon --config /etc/fastnetmon.conf

Etapa 3: Integração com Prometheus e Grafana

Para visualizar a eficácia da mitigação e ter uma visão macro da segurança de rede, configuraremos o Prometheus para coletar métricas do FastNetMon e do Akvorado.

No arquivo de configuração do Prometheus /etc/prometheus/prometheus.yml, adicione os alvos (targets):

scrape_configs:
  - job_name: 'akvorado'
    static_configs:
      - targets: ['localhost:8081']

  - job_name: 'fastnetmon'
    # FastNetMon expõe métricas em seu endpoint HTTP interno
    static_configs:
      - targets: ['localhost:9095']

Reinicie o Prometheus:

systemctl restart prometheus

Acesse o Grafana (instalado via pacote padrão) e adicione o Prometheus como fonte de dados. Crie um dashboard personalizado com consultas SQL ou PromQL para mostrar:

• Total de pacotes por segundo (PPS) na interface monitorada.
• Volumes de tráfego por IP de origem.
• Número de IPs bloqueados pelo script do FastNetMon nas últimas 24 horas.

Etapa 4: Segurança do Host com Wazuh

A ferramenta de mitigação é crítica; se o servidor onde o FastNetMon roda for comprometido, a defesa cai. Utilize o Wazuh para monitorar a integridade dos arquivos de configuração do FastNetMon e Akvorado.

No agente Wazuh instalado no mesmo servidor (ou em um servidor dedicado se usar agentes remotos), configure o monitoramento de integridade de arquivos no /var/ossec/etc/ossec.conf:

<syscheck>
  <!-- Monitorar configurações de segurança -->
  <directories check_all="yes">/etc/fastnetmon</directories>
  <directories check_all="yes">/etc/akvorado</directories>
  
  <!-- Monitorar logs do sistema -->
  <localfile>
    <log_format>syslog</log_format>
    <location>/var/log/syslog</location>
  </localfile>
</syscheck>

O Wazuh alertará imediatamente se houver alterações não autorizadas nos scripts de mitigação ou nas configurações de coleta de fluxos, garantindo que um atacante não desative a proteção silenciosamente.

Etapa 5: Verificação de Uptime com Uptime Kuma

Por fim, garanta que toda a stack está operacional. Instale o Uptime Kuma (recomendado via Docker para isolamento):

docker run -d --restart=always --name uptime-kuma -v uptime-kuma:/app/data -p 3001:3001 lscr.io/linuxserver/uptime-kuma

No painel do Uptime Kuma, adicione monitoramentos para:

• HTTP: Endpoint de status do Prometheus (geralmente porta 9090).
• HTTP: Interface Web do Grafana.
• TCP: Porta do serviço FastNetMon (9095) para garantir que o daemon está respondendo.

Configure alertas via Slack, Email ou Telegram. Se o Uptime Kuma detectar que o endpoint do FastNetMon caiu, você será notificado instantaneamente, permitindo ação rápida antes que um ataque DDoS prologue sem detecção.

Melhores Práticas e Considerações Finais

A implementação de mitigacao ddos automatizada requer ajustes finos. O maior risco do FastNetMon é o "falso positivo". Se você configurar a janela de monitoramento muito curta ou o threshold muito baixo, tráfego legítimo (como um lançamento de produto viral) pode ser bloqueado.

Dicas críticas para produção:

1. Whitelist de IPs: Sempre mantenha uma lista branca de IPs internos, CDNs e parceiros que não devem ser bloqueados, mesmo em picos anômalos.
2. BGP Flowspec: Para grandes infraestruturas, substitua o script iptables por integração BGP Flowspec. Isso permite que a mitigação seja feita no roteador de borda ou pelo provedor de internet, aliviando a carga do servidor de segurança.
3. Logs Auditados: Centralize os logs do FastNetMon e Akvorado no Wazuh ou em um sistema SIEM como o Elasticsearch. A forense pós-ataque depende da qualidade dos dados coletados.
4. Testes de Penetração: Realize testes controlados de DDoS (simulação) para validar se os thresholds estão corretos e se os scripts de mitigação estão executando conforme o esperado.

A combinação de Akvorado para coleta leve, FastNetMon para lógica de decisão rápida, Prometheus/Grafana para visibilidade e Wazuh/Uptime Kuma para governança cria uma malha de segurança robusta. Esta abordagem não apenas mitiga ataques, mas também fornece os dados necessários para otimizar a infraestrutura de rede continuamente.

Lembre-se: a segurança é um processo contínuo. Revise as regras do FastNetMon mensalmente e atualize as versões dos componentes da stack para garantir proteção contra vulnerabilidades emergentes. A seguranca de rede depende tanto da tecnologia quanto da vigilância constante dos administradores.