Detectar Anomalias com Suricata: Guia Prático de Cibersegurança

Introdução

Neste laboratório, você aprenderá a detectar anomalias de rede usando o Suricata, um poderoso motor de detecção de ameaças de código aberto (open-source). Você explorará recursos chave, incluindo configuração de regras, monitoramento de tráfego e análise de alertas para identificar potenciais ameaças à segurança.

Os exercícios práticos o guiarão através da configuração do Suricata, criação de regras básicas e inspeção de tráfego em tempo real. Você obterá experiência prática na detecção de atividades suspeitas, como solicitações de ping ICMP, e na personalização de regras para cenários de ameaças específicos.

Instalar o Suricata

Nesta etapa, você instalará o Suricata, um motor de detecção de ameaças de rede de código aberto (open-source). O Suricata age como uma câmera de segurança para sua rede, analisando constantemente o tráfego para identificar potenciais ameaças. Ele pode desempenhar três funções principais: detecção de intrusão em tempo real (IDS) para monitorar ataques, prevenção de intrusão em linha (IPS) para bloquear tráfego malicioso e monitoramento de segurança de rede para registrar toda a atividade.

Vamos começar o processo de instalação passo a passo:

Primeiro, precisamos atualizar a lista de pacotes. Isso garante que seu sistema saiba sobre as versões de software mais recentes disponíveis antes de instalarmos qualquer coisa:
```
sudo apt update
```
O comando sudo concede a você privilégios de administrador, enquanto apt update atualiza a lista de pacotes disponíveis do seu sistema.
Agora, instalaremos o Suricata junto com todos os seus componentes necessários (dependências). A flag -y confirma automaticamente a instalação:
```
sudo apt install -y suricata
```
Este comando baixa e instala o pacote de software Suricata dos repositórios oficiais do Ubuntu.
Após a instalação, vamos verificar se tudo funcionou corretamente, verificando a versão instalada:
```
suricata -V
```
Você deve ver uma saída semelhante a:
```
This is Suricata version 6.0.3 RELEASE
```
A flag -V diz ao Suricata para exibir suas informações de versão. Ver esta saída confirma que a instalação foi bem-sucedida.
O comportamento do Suricata é controlado por um arquivo de configuração. Vamos verificar se este arquivo importante existe em seu local padrão:
```
ls /etc/suricata/suricata.yaml
```
O diretório /etc/suricata/ é onde o Linux normalmente armazena arquivos de configuração para aplicativos em todo o sistema.
Finalmente, o Suricata precisa de regras para saber o que procurar no tráfego de rede. Essas regras são como um conjunto de instruções que dizem ao Suricata o que constitui atividade suspeita. As regras padrão são armazenadas em:
```
ls /var/lib/suricata/rules
```
O diretório /var/lib/suricata/rules contém os arquivos de regras que vêm com a instalação do Suricata. Trabalharemos com essas regras mais tarde no laboratório.

Configurar Regras Básicas

Nesta etapa, você configurará regras básicas de detecção para o Suricata. As regras são o componente central que diz ao Suricata o que procurar no tráfego de rede. Pense nelas como um conjunto de instruções que definem padrões suspeitos ou ameaças conhecidas.

Primeiro, navegue até o diretório de regras do Suricata, onde todos os arquivos de regras são armazenados:
```
cd /var/lib/suricata/rules
```
É aqui que o Suricata mantém seus arquivos de regras padrão e personalizados. A localização do diretório é especificada na configuração do Suricata.
Liste os arquivos de regras existentes para ver o que já está disponível:
```
ls
```
Você deve ver vários arquivos .rules, como suricata.rules. Esses arquivos contêm diferentes categorias de regras que o Suricata usa para detecção.
Vamos examinar uma estrutura de regra básica. Abra o arquivo de regras principal usando o editor nano:
```
sudo nano suricata.rules
```
O editor nano é um editor de texto simples que usaremos para modificar as regras. Você verá muitas regras existentes com estruturas semelhantes.
Adicione uma regra simples para detectar solicitações de ping ICMP (adicione isso no final do arquivo):
```
alert icmp any any -> any any (msg:"ICMP Ping Detected"; itype:8; sid:1000001; rev:1;)
```
Vamos detalhar o que essa regra faz:
- alert: Diz ao Suricata para gerar um alerta quando houver correspondência
- icmp: Aplica-se ao tráfego do protocolo ICMP
- any any -> any any: Corresponde a qualquer IP/porta de origem para qualquer IP/porta de destino
- msg: A mensagem de alerta que aparecerá nos logs
- itype:8: Corresponde especificamente ao tipo 8 do ICMP (solicitações de ping)
- sid: Identificador de regra exclusivo (1000001+ para regras personalizadas)
- rev: Número da revisão da regra
Salve o arquivo (Ctrl+O, Enter, Ctrl+X no nano). Isso armazena sua nova regra permanentemente.
Verifique se a sintaxe da regra está correta antes de aplicá-la:
```
sudo suricata -T -c /etc/suricata/suricata.yaml -v
```
A flag -T testa a configuração. Você deve ver uma saída terminando com:
```
Configuration provided was successfully loaded. Exiting.
```
Isso confirma que sua regra está formatada corretamente.
Reinicie o Suricata para carregar as novas regras e começar a monitorar:
```
sudo pkill suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0
```
O primeiro comando interrompe qualquer instância do Suricata em execução, enquanto o segundo a inicia novamente com suas novas regras, monitorando a interface eth0.

Monitorar Tráfego em Tempo Real

Nesta etapa, observaremos como o Suricata monitora o tráfego de rede em tempo real e gera alertas com base nas regras que configuramos anteriormente. Esta é a funcionalidade principal de qualquer IDS (Sistema de Detecção de Intrusão) - observar os pacotes de rede e sinalizar atividades suspeitas.

Primeiro, precisamos iniciar o Suricata no modo de captura ao vivo. Os seguintes comandos primeiro interromperão qualquer instância do Suricata em execução (se existir) e, em seguida, iniciarão uma nova, monitorando a interface eth0:
```
sudo pkill suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0
```
A flag -c especifica nosso arquivo de configuração, enquanto -i informa ao Suricata qual interface de rede monitorar.
Agora, vamos gerar algum tráfego de teste que deve acionar nossa regra ICMP da etapa anterior. Abra um novo terminal e execute:
```
ping -c 3 8.8.8.8
```
Isso envia 3 pacotes de ping ICMP para o servidor DNS do Google (8.8.8.8). Como criamos uma regra para detectar tráfego ICMP, o Suricata deve registrar essa atividade.
O Suricata grava alertas em /var/log/suricata/fast.log. Para observar esses alertas em tempo real, use:
```
sudo tail -f /var/log/suricata/fast.log
```
O comando tail -f exibe continuamente novas linhas adicionadas ao arquivo. Você deve ver uma saída semelhante a:
```
01/01/2023-12:34:56.123456  [**] [1:1000001:1] ICMP Ping Detected [**] [Classification: (null)] [Priority: 3] {ICMP} 192.168.1.1 -> 8.8.8.8
```
Isso mostra o carimbo de data/hora, o ID da regra (1:1000001:1), a mensagem de alerta e os endereços IP de origem/destino.
Para um registro mais detalhado em formato JSON, podemos examinar o arquivo eve.json. O seguinte comando filtra e imprime de forma formatada apenas eventos de alerta:
```
sudo tail -f /var/log/suricata/eve.json | jq '. | select(.event_type == "alert")'
```
A ferramenta jq ajuda a analisar e formatar a saída JSON, tornando-a mais fácil de ler.
Para visualizar estatísticas sobre o tráfego que o Suricata está processando, incluindo quantos alertas foram gerados:
```
sudo suricatasc -c stats
```
Procure contadores como detect.alert na saída - isso mostra quantas vezes nossas regras acionaram alertas.
Quando terminar de observar o tráfego, pressione Ctrl+C em qualquer janela do terminal onde estiver monitorando os logs para interromper a saída contínua.

Revisar Alertas Gerados

Nesta etapa, você analisará os alertas gerados pelo Suricata a partir da sessão de monitoramento anterior. Isso ajuda a entender quais padrões de tráfego acionaram suas regras. Ao trabalhar com sistemas de detecção de intrusão, a revisão de alertas é crucial para identificar potenciais ameaças à segurança e ajustar suas regras de detecção.

Primeiro, verifique o log de alertas básico:
```
sudo cat /var/log/suricata/fast.log
```
Este comando exibe alertas com carimbo de data/hora em um formato simples e legível por humanos. O fast.log é o arquivo de saída de alerta padrão do Suricata. Procure por entradas contendo "ICMP Ping Detected" - estas indicam solicitações de ping que corresponderam à sua regra de detecção.
Para uma análise mais detalhada, examine o log JSON estruturado:
```
sudo cat /var/log/suricata/eve.json | jq '. | select(.event_type == "alert")'
```
O arquivo eve.json contém logs abrangentes e legíveis por máquina em formato JSON. Usamos jq para filtrar apenas eventos de alerta. Isso fornece informações detalhadas, incluindo:
- Endereços IP de origem e destino
- Carimbos de data/hora precisos
- Detalhes completos da regra
- Informações da carga útil do pacote (quando configurado)
Para contar quantas vezes cada alerta foi acionado:
```
sudo grep -o "ICMP Ping Detected" /var/log/suricata/fast.log | wc -l
```
Este pipeline primeiro extrai todas as ocorrências de "ICMP Ping Detected" usando grep -o e, em seguida, as conta com wc -l. Isso ajuda a quantificar com que frequência esse evento ocorre.
Para um resumo dos tipos de alerta:
```
sudo jq -r '.alert.signature' /var/log/suricata/eve.json | sort | uniq -c
```
Este comando extrai todas as assinaturas de alerta (nomes de regras), as classifica alfabeticamente e, em seguida, conta as ocorrências exclusivas. Ele fornece uma visão geral de quais regras estão sendo acionadas com mais frequência.
Para visualizar alertas com informações de IP de origem:
```
sudo jq -r 'select(.event_type == "alert") | [.timestamp, .src_ip, .alert.signature] | @tsv' /var/log/suricata/eve.json
```
Esta consulta jq avançada cria uma saída separada por tabulações mostrando o carimbo de data/hora, o IP de origem e a assinatura do alerta para cada evento. O formato @tsv facilita a importação para planilhas.
Para verificar os 5 alertas mais recentes:
```
sudo tail -n 5 /var/log/suricata/fast.log
```
O comando tail mostra as últimas linhas de um arquivo. Isso é útil para verificações rápidas de atividades recentes sem rolar por todo o log.

Adicionar uma Regra Personalizada

Nesta etapa, você aprenderá como criar e testar sua própria regra Suricata para detectar padrões específicos no tráfego de rede. Vamos nos concentrar na detecção de solicitações HTTP para um domínio de teste (example.com) como um exemplo prático. Regras personalizadas permitem que você estenda os recursos de detecção do Suricata além de seu conjunto de regras padrão.

Primeiro, navegue até o diretório de regras onde o Suricata armazena suas regras de detecção:
```
cd /var/lib/suricata/rules
```
É aqui que todos os arquivos de regras do Suricata são normalmente armazenados. Adicionaremos nossas regras personalizadas aqui para mantê-las organizadas com as regras existentes.
Crie um novo arquivo de regra especificamente para suas regras personalizadas:
```
sudo nano custom.rules
```
Usar sudo é necessário porque o diretório de regras requer privilégios administrativos para modificar. Estamos nomeando o arquivo custom.rules para distingui-lo claramente dos arquivos de regras padrão do Suricata.
Adicione a seguinte regra para detectar solicitações HTTP para example.com:
```
alert http any any -> any any (msg:"HTTP Request to example.com"; flow:to_server; http.host; content:"example.com"; nocase; sid:1000002; rev:1;)
```
Vamos detalhar o que essa regra faz:
- alert http: Aciona um alerta para tráfego HTTP
- any any -> any any: Aplica-se ao tráfego de qualquer porta de origem para qualquer porta de destino
- msg: Fornece uma mensagem de alerta legível por humanos
- flow:to_server: Corresponde apenas ao tráfego que vai para servidores
- http.host: Examina o cabeçalho HTTP Host
- content:"example.com": Procura por este domínio específico
- nocase: Torna a correspondência insensível a maiúsculas e minúsculas
- sid:1000002: Dá à regra um ID exclusivo (acima de 1.000.000 para regras personalizadas)
- rev:1: Indica que esta é a primeira versão da regra
Salve o arquivo no editor nano pressionando Ctrl+O (escrever), depois Enter para confirmar e Ctrl+X para sair.
Agora precisamos dizer ao Suricata para carregar nosso novo arquivo de regras. Edite a configuração principal:
```
sudo nano /etc/suricata/suricata.yaml
```
Encontre a seção rule-files: (geralmente por volta da linha 50-60) e adicione:
```
- custom.rules
```
Esta adição garante que o Suricata carregará nossas regras personalizadas quando iniciar.
Antes de aplicar as alterações, verifique se a sintaxe da regra está correta:
```
sudo suricata -T -c /etc/suricata/suricata.yaml -v
```
A flag -T informa ao Suricata para testar a configuração sem realmente executá-la. Isso ajuda a detectar quaisquer erros de sintaxe em suas regras antes que elas sejam usadas.
Reinicie o Suricata para carregar a nova regra:
```
sudo pkill suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0
```
O primeiro comando interrompe qualquer instância do Suricata em execução, enquanto o segundo a inicia novamente com nossa configuração atualizada.
Para testar se nossa regra funciona, gere algum tráfego HTTP para example.com:
```
curl http://example.com
```
Este comando faz uma solicitação HTTP simples que deve acionar nossa nova regra.
Finalmente, verifique se o Suricata detectou o tráfego visualizando os alertas mais recentes:
```
sudo tail -n 5 /var/log/suricata/fast.log
```
Você deve ver um alerta correspondente à mensagem de nossa regra personalizada sobre solicitações HTTP para example.com. Caso contrário, verifique novamente cada etapa e verifique a sintaxe da regra.

Resumo

Neste laboratório, você aprendeu como instalar e configurar o Suricata, um mecanismo de detecção de ameaças de rede de código aberto. O processo incluiu a atualização de pacotes, a instalação de dependências e a verificação da instalação, verificando o arquivo de configuração e o diretório de regras.

Você também explorou a criação de regras de detecção personalizadas, adicionando uma regra de solicitação de ping ICMP, compreendendo sua estrutura e componentes. Por fim, você verificou a sintaxe da regra para garantir que o Suricata possa monitorar efetivamente o tráfego de rede e gerar alertas para anomalias.

Detectar Anomalias no Suricata