O Suricata se consolidou como uma das ferramentas mais poderosas para detecção e prevenção de intrusões em ambientes Linux modernos. Ao contrário de soluções tradicionais de thread única, o Suricata foi projetado do zero para tirar proveito de arquiteturas multi-core e multi-thread, entregando desempenho excepcional mesmo em links de rede de alta velocidade — 10 Gbps, 40 Gbps e além. Nesta aula 26 do curso Segurança Linux — Do Zero ao Avançado, você mergulhará fundo na instalação, configuração e operação do Suricata como IDS (Sistema de Detecção de Intrusões) e IPS (Sistema de Prevenção de Intrusões) em modo inline.
Profissionais de segurança da informação e administradores de infraestrutura precisam dominar ferramentas de nível empresarial que vão além do básico. O Suricata não apenas inspeciona pacotes contra milhares de regras em tempo real, como também oferece recursos avançados: análise de protocolos de aplicação (HTTP, DNS, TLS, SMB), extração de arquivos, logging JSON altamente estruturado e integração nativa com stacks de monitoramento como Elasticsearch e Grafana. Em nossos projetos na JRT Technology Solutions, nossos especialistas utilizam diariamente o Suricata para proteger redes corporativas, e o conhecimento que você adquirirá aqui reflete exatamente o que é exigido em campo.
Nesta aula, você aprenderá a implantar o Suricata em distribuições Ubuntu/Debian e Rocky Linux 9 (RHEL 9), construindo uma instância funcional desde o zero — adicionando repositórios oficiais da OISF (Open Information Security Foundation), ajustando o arquivo de configuração principal /etc/suricata/suricata.yaml, compreendendo o modelo de threads, selecionando o modo de captura ideal (AF_PACKET, PF_RING ou Netmap) e configurando regras de detecção. Mostraremos cada comando, cada saída esperada e cada armadilha a ser evitada. Ao final, você terá uma implementação de IDS/IPS pronta para produção, capaz de inspecionar tráfego com confiabilidade e baixa latência.
Este é um conteúdo de nível avançado. Assumimos que você já concluiu as aulas anteriores do curso, possui domínio de linha de comando, entende conceitos de rede como pilha TCP/IP, VLANs, roteamento e firewall (iptables/nftables), e tem familiaridade com análise de logs no Linux. Se algum desses tópicos ainda não estiver claro, recomendamos revisitar as aulas 1 a 25 antes de prosseguir.
Ao concluir esta aula, você será capaz de: instalar o Suricata a partir dos repositórios oficiais; validar a configuração; executar o motor de detecção em modo IDS e IPS; interpretar os arquivos de log (eve.json e fast.log); criar e gerenciar regras personalizadas; e aplicar ajustes de performance para diferentes cargas de trabalho. Preparado? Vamos elevar seu domínio em Segurança Linux ao próximo patamar.
O que você vai aprender nesta aula
- Contextualização arquitetural: como o Suricata difere de soluções como Snort e por que o modelo multi-thread é crucial para redes de alta velocidade.
- Instalação passo a passo em Ubuntu 22.04/24.04 e Rocky Linux 9, com repositórios oficiais da OISF.
- Configuração detalhada do suricata.yaml: af-packet, threading, detect-engine, outputs e tuning de performance.
- Modos de operação: Sniffer, IDS (NIDS) e IPS inline via NFQUEUE.
- Gerenciamento de regras: utilização do suricata-update, categorias Emerging Threats e criação de assinaturas customizadas.
- Verificação e troubleshooting: testes de configuração, validação de regras, análise de logs e solução dos erros mais comuns.
- Boas práticas de produção: afinidade de CPU, balanceamento de workers, integração com ELK e alertas em tempo real.
Pré-requisitos e Ambiente
Para acompanhar cada etapa sem frustrações, você precisará de um servidor (físico ou virtual) com:
- Ubuntu 22.04 LTS / 24.04 LTS (ou Debian 12) ou Rocky Linux 9 (ou RHEL 9 / AlmaLinux 9).
- Mínimo de 2 vCPUs e 4 GB de RAM; recomendamos 4 vCPUs e 8 GB para testes com regras completas.
- Pelo menos 20 GB de espaço em disco (logs do Suricata podem crescer rapidamente).
- Acesso root ou sudo.
- Conectividade com a internet para download de regras e atualizações.
- Familiaridade com editores de texto como vim ou nano.
Verifique seu sistema antes de começar:
# Verificar distribuição e versão do kernel
cat /etc/os-release
uname -r
# Verificar memória e CPUs disponíveis
free -h
lscpu | grep -E "^CPU\(s\)|Model name"
Suricata: Arquitetura Multi-Thread e Por Que Isso Importa
A diferença fundamental entre o Suricata e os IDS/IPS baseados em thread única (como o Snort 2.x) está na capacidade de distribuir a carga de processamento de pacotes entre múltiplas threads de execução, cada uma podendo ser atrelada a um core de CPU específico. O motor do Suricata utiliza um pipeline de processamento que começa na captura de pacotes, passa pela decodificação, análise de fluxo, detecção de assinaturas e termina nos outputs (logs, alertas, syslog, etc.). Em vez de um único processo linear, o Suricata cria múltiplos threads de “worker” que executam todas essas etapas de forma independente para diferentes pacotes, paralelizando o trabalho.
Esse design é controlado pela seção threading do arquivo /etc/suricata/suricata.yaml. Você define quantos threads de gerenciamento e quantos workers deseja, além do modo de detecção (autofp, workers ou single). O modo workers é o mais eficiente: cada worker recebe pacotes diretamente do mecanismo de captura (AF_PACKET, PF_RING) e processa o pipeline completo, eliminando overhead de sincronização entre threads. Em nossos projetos na JRT Technology Solutions, configuramos o Suricata com um worker por núcleo físico, deixando um ou dois cores para o sistema operacional e IRQs de rede, obtendo ganhos de throughput superiores a 300% em relação a configurações padrão.
Compreender essa arquitetura é essencial para o tuning de performance. Se você simplesmente instalar o Suricata e iniciar com as configurações padrão, provavelmente verá perda de pacotes (packet drops) em links acima de 1 Gbps. Ajustar o número de workers, a afinidade de CPU (cpu-affinity) e o modo de operação é a diferença entre um IDS que engasga e um que processa milhões de pacotes por segundo sem degradação.
Além disso, o Suricata suporta aceleração por hardware (como Intel Hyperscan para correspondência de padrões) e descarregamento de processamento para FPGA ou SmartNICs em cenários extremos. Embora esses tópicos estejam além desta aula, é importante saber que a plataforma foi projetada para escalar vertical e horizontalmente.
Instalação do Suricata Passo a Passo — Ubuntu/Debian
Nesta seção, realizaremos a instalação completa do Suricata no Ubuntu 22.04/24.04 utilizando o repositório oficial da OISF. Essa abordagem garante que você obtenha a versão mais recente estável (atualmente a 7.x), com todas as otimizações e correções de segurança. Evitaremos os pacotes do repositório padrão do Ubuntu, que frequentemente estão desatualizados.
- Atualize o sistema e instale dependências básicas:
# Atualizar cache de pacotes e sistema
sudo apt update && sudo apt upgrade -y
# Instalar dependências necessárias para adicionar repositórios e compilar regras
sudo apt install -y curl gnupg2 software-properties-common lsb-release apt-transport-https
- Adicione o repositório oficial da OISF para Suricata:
# Adicionar chave GPG do repositório OISF
sudo curl -fsSL https://packages.suricata.io/suricata-oisf.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/suricata-archive-keyring.gpg
# Adicionar o repositório à lista de sources
echo "deb [signed-by=/usr/share/keyrings/suricata-archive-keyring.gpg] https://packages.suricata.io/debian $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/suricata.list
# Atualizar cache de pacotes para incluir o novo repositório
sudo apt update
Saída esperada ao executar sudo apt update (você verá a linha do repositório suricata sendo consultada):
Hit:1 http://archive.ubuntu.com/ubuntu jammy InRelease
Get:2 https://packages.suricata.io/debian jammy InRelease [12.3 kB]
Get:3 https://packages.suricata.io/debian jammy/main amd64 Packages [5.4 kB]
Fetched 17.7 kB in 1s (17.7 kB/s)
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
All packages are up to date.
- Instale o Suricata:
# Instalar o pacote principal do Suricata
sudo apt install -y suricata
O instalador criará automaticamente o usuário e grupo suricata, diretórios de log em /var/log/suricata/ e o arquivo de configuração principal em /etc/suricata/suricata.yaml.
- Verifique a versão instalada e informações de compilação:
# Exibir versão do Suricata
suricata --build-info
This is Suricata version 7.0.6 RELEASE
Features: PCAP_SET_BUFF AF_PACKET HAVE_PACKET_FANOUT LIBCAP_NG LIBNET1.1 HAVE_HTP_URI_NORMALIZE_HOOK PCRE_JIT HAVE_NSS HAVE_LIBJANSSON TLS TLS_C11 MAGIC RUST
SIMD support: SSE_4_2 SSE_4_1 SSE_3
Atomic ints: 1 2 4 8 byte(s)
64-bits, Little-endian architecture
GCC version 13.2.0, C version 201
compiled with libnss: yes
compiled with libnspr: yes
compiled with libcap-ng: yes
...
Suricata Configuration:
AF_PACKET support: yes
PF_RING support: no
NFQueue support: yes
...
Observe que o suporte a NFQUEUE (necessário para modo IPS inline) está habilitado, assim como AF_PACKET. O suporte a RUST indica que módulos escritos em Rust para análise de protocolos (como SMB, NFS) estão compilados. Caso precise de suporte a PF_RING (para captura de alta performance com balanceamento de carga em hardware), você precisará compilar o Suricata você mesmo ou utilizar pacotes específicos — tópico que abordaremos em aulas avançadas de otimização.
Instalação do Suricata Passo a Passo — Rocky Linux 9 / RHEL 9
Em sistemas da família Red Hat, o procedimento é semelhante, mas utilizamos o gerenciador dnf e o repositório EPEL mais o repositório oficial da OISF. A OISF fornece pacotes RPM oficiais para RHEL 9 e derivados.
- Habilite o repositório EPEL e instale dependências:
# Instalar EPEL (Extra Packages for Enterprise Linux)
sudo dnf install -y epel-release
# Instalar dependências para adicionar repositórios
sudo dnf install -y dnf-plugins-core curl
- Adicione o repositório oficial da OISF:
# Baixar e instalar o pacote de configuração do repositório OISF para RHEL 9
curl -fsSL https://packages.suricata.io/oisf.repo | sudo tee /etc/yum.repos.d/suricata.repo
# Atualizar cache do DNF
sudo dnf makecache
- Instale o Suricata:
# Instalar o Suricata
sudo dnf install -y suricata
- Verifique a instalação e habilite o serviço para iniciar no boot:
# Verificar versão
suricata -V
# Habilitar o serviço systemd (ainda não iniciaremos)
sudo systemctl enable suricata
Saída esperada do comando suricata -V:
Suricata version 7.0.6 RELEASE
Agora que o Suricata está instalado em ambas as plataformas, prosseguiremos para a etapa mais crítica: a configuração fina do mecanismo de detecção.
Configuração Detalhada do suricata.yaml
O arquivo /etc/suricata/suricata.yaml é o centro de controle do Suricata. Com centenas de diretivas, ele define como o motor captura pacotes, quais redes monitorar, como processar threads, quais regras carregar e como gerar logs. Mostraremos aqui as seções essenciais que você precisa dominar para uma implementação de produção, com comentários linha a linha. Recomendamos abrir o arquivo completo em um editor enquanto lê esta seção, pois faremos referência a trechos específicos.
Estrutura do arquivo (trechos principais com explicações):
# ==================== Configuração do Suricata ====================
# Este é um subconjunto das diretivas mais importantes.
# O arquivo completo encontra-se em /etc/suricata/suricata.yaml
# 1. Variáveis de ambiente: definem faixas de rede usadas em regras
vars:
# Endereços protegidos (sua rede interna)
address-groups:
HOME_NET: "[192.168.0.0/16,10.0.0.0/8,172.16.0.0/12]"
EXTERNAL_NET: "!$HOME_NET" # Tudo que não for HOME_NET
HTTP_SERVERS: "$HOME_NET"
SMTP_SERVERS: "$HOME_NET"
SQL_SERVERS: "$HOME_NET"
DNS_SERVERS: "$HOME_NET"
TELNET_SERVERS: "$HOME_NET"
AIM_SERVERS: "$EXTERNAL_NET"
# Portas de rede para serviços
port-groups:
HTTP_PORTS: "80"
SHELLCODE_PORTS: "!80"
ORACLE_PORTS: 1521
SSH_PORTS: 22
# 2. Configuração de threads e detecção
threading:
set-cpu-affinity: yes # Vincula threads a CPUs específicas
cpu-affinity:
- management-cpu-set:
cpu: [ 0 ] # CPU para threads de gerenciamento
worker-cpu-set:
cpu: [ 1,2,3 ] # CPUs para workers (modo workers)
mode: "exclusive" # Threads não compartilham CPU
detect-thread-ratio: 1.0 # Proporção de threads de detecção
# 3. Modo de captura de pacotes (AF_PACKET para alta performance)
af-packet:
- interface: eth0
# Número de workers de captura (threads que recebem pacotes)
threads: 3
# Modo cluster para balancear pacotes entre workers
cluster-id: 99
cluster-type: cluster_flow # Balanceia por fluxo (5-tupla)
defrag: yes
use-mmap: yes # Mapeamento em memória para zerocopy
tpacket-v3: yes # Usar TPACKET_V3 (mais eficiente)
ring-size: 300000 # Tamanho do buffer de anel (pacotes)
# 4. Motor de detecção
detect:
profile: high # Perfil de detecção (low, medium, high)
fast-pattern: yes
sgh-mpm-context: full # Otimização de busca de padrões
# 5. Saídas e logging
outputs:
# Saída JSON (EVE) - altamente recomendado
- eve-log:
enabled: yes
filetype: regular
filename: eve.json
types:
- alert # Alertas de detecção
- http # Transações HTTP
- dns # Consultas DNS
- tls # Handshakes TLS (certificados, JA3)
- ssh # Conexões SSH
- flow # Metadados de fluxos
- fileinfo # Arquivos extraídos do tráfego
# Log de alertas simplificado (fast log)
- fast:
enabled: yes
filename: fast.log
append: yes
# Estatísticas de performance
- stats:
enabled: yes
interval: 60 # A cada 60 segundos
totals: yes # Acumula totais desde início
A seção af-packet merece atenção especial. O cluster-id e cluster-type: cluster_flow instruem o kernel a distribuir pacotes entre os threads de captura baseando-se no hash do fluxo (IP de origem/destino, portas, protocolo), garantindo que todos os pacotes de uma mesma conexão sejam processados pelo mesmo worker — essencial para análise de estado de protocolo. O uso de tpacket-v3 e use-mmap reduz drasticamente a cópia de memória entre kernel space e user space, minimizando a perda de pacotes. Em laboratórios da JRT Technology Solutions, alcançamos velocidades de captura de 10 Gbps com menos de 0.01% de perda usando essas configurações em hardware adequado.
Nota sobre IPS inline: Se deseja operar em modo IPS (dropando pacotes maliciosos), você precisará configurar o Suricata para trabalhar em conjunto com o firewall via NFQUEUE. Nesse caso, a seção de captura mudaria para algo como:
nfqueue:
mode: accept
repeat: 1
route-queue: 1
batchcount: 20
fail-open: yes # Libera tráfego se Suricata falhar
Abordaremos o modo IPS com detalhes práticos na seção de Boas Práticas e Dicas Avançadas.
Verificando a Instalação e Testando a Configuração
Antes de colocar o Suricata em produção, é obrigatório validar que a configuração está sintaticamente correta e que o motor consegue inicializar sem erros. O Suricata oferece um modo de teste seco que carrega todas as regras, configura os mecanismos de captura e sai, reportando qualquer problema.
Comando de teste de configuração:
# Testar configuração sem iniciar a captura
sudo suricata -T -c /etc/suricata/suricata.yaml -v
Parâmetros:
- -T: Testa a configuração e as regras, depois sai.
- -c /etc/suricata/suricata.yaml: Especifica o caminho do arquivo de configuração.
- -v: Modo verboso, para ver detalhes do carregamento.
Saída esperada de sucesso:
Info: conf: Running in test mode, not starting engine.
Info: suricata: This is Suricata version 7.0.6 RELEASE running in SYSTEM mode
Info: cpu: Setting affinity management to CPU 0
Info: cpu: Setting affinity worker to CPU 1,2,3
Info: suricata: Running suricata under test mode
Info: suricata: Setting engine mode to IDS mode by default
Warn: detect: No rules loaded from /var/lib/suricata/rules/suricata.rules
Info: pcap: No physical capture interface specified, using default 'eth0'
Info: RunMode: AF_PACKET picked as capture method
Info: AF_PACKET: using cluster_flow on iface eth0 with cluster-id 99
Info: All 3 packet processing threads, 3 management threads initialized, engine started.
Info: Signal Received: SIGUSR2
Info: cleaning up signature grouping structure... complete
Info: suricata: Test mode exit cleanly.
A ausência de erros fatais (Error) indica que a configuração é válida. O aviso sobre regras não carregadas é esperado, pois ainda não baixamos o conjunto de regras padrão.
Verificar se o serviço systemd está corretamente configurado:
# Verificar status do serviço (deve estar parado)
sudo systemctl status suricata
# Verificar se as variáveis de ambiente do serviço apontam para as interfaces corretas
sudo systemctl cat suricata
Gerenciamento de Regras com suricata-update
O Suricata sem regras é como um carro sem combustível. O conjunto padrão de regras é fornecido pela comunidade Emerging Threats (ET Open) e pela própria OISF. Utilizamos a ferramenta suricata-update, incluída na instalação, para baixar, atualizar e gerenciar regras facilmente.
- Atualizar o cache de regras e baixar o conjunto padrão:
# Executar suricata-update (primeira execução)
sudo suricata-update
Downloading Emerging Threats Open ruleset...
Processing downloaded rules...
Merging with local rules...
Successfully merged 35678 rules.
Writing rules to /var/lib/suricata/rules/suricata.rules
- Verificar o arquivo de regras gerado:
# Listar primeiras linhas das regras baixadas
head -20 /var/lib/suricata/rules/suricata.rules
- Configurar atualização automática (cron job ou timer systemd):
# O pacote instalou um timer systemd para atualização diária (opcional)
sudo systemctl enable suricata-update.timer
sudo systemctl start suricata-update.timer
- Habilitar regras específicas desativando categorias indesejadas:
# Exemplo: desabilitar regras de protocolo "chat", "games"
sudo suricata-update disable-conf /etc/suricata/disable.conf
sudo suricata-update
Você pode criar arquivos /etc/suricata/enable.conf e disable.conf para controlar quais SIDs (identificadores de regras) são ativados. Isso é útil para reduzir falsos positivos em ambientes específicos.
Executando o Suricata em Modo IDS e Interpretando os Logs
Com a configuração validada e as regras carregadas, podemos iniciar o Suricata em modo IDS ao vivo. Escolhemos uma interface de rede para monitoramento — de preferência uma interface que receba tráfego espelhado (port mirror/SPAN) ou uma bridge transparente. Neste exemplo, usaremos eth1 como interface de monitoramento.
- Parar o serviço padrão (se estiver rodando) e iniciar manualmente com configuração personalizada:
# Certifique-se de que o serviço systemd está parado
sudo systemctl stop suricata
# Iniciar Suricata em modo IDS na interface eth1
sudo suricata -c /etc/suricata/suricata.yaml -i eth1 -D -v
- -i eth1: Interface de captura.
- -D: Executa como daemon em segundo plano.
- -v: Verboso (pode omitir em produção).
Para verificar se o Suricata está realmente capturando e gerando alertas, podemos gerar tráfego malicioso de teste ou simplesmente ver o log fast.log.
- Acompanhar os logs em tempo real:
# Visualizar alertas em tempo real
sudo tail -f /var/log/suricata/fast.log
# Em outro terminal, gerar um alerta de teste (ex: regra ICMP)
ping -c 3 8.8.8.8
Saída esperada no fast.log se houver regras para ICMP Echo Request:
08/03/2026-15:32:01.123456 [**] [1:1000001:0] ICMP Echo Request Detected [**] [Classification: Misc activity] [Priority: 3] {ICMP} 192.168.1.100:8 -> 8.8.8.8:0
O log eve.json conterá a mesma informação em formato JSON com riqueza de detalhes, incluindo metadados de fluxo, informações de protocolo e muito mais. Utilize jq para filtrar e processar esses dados:
sudo tail -f /var/log/suricata/eve.json | jq 'select(.event_type=="alert")'
Erros Comuns e Como Resolver
Durante a implantação do Suricata, alguns erros são recorrentes. Abaixo listamos os mais frequentes em nossa experiência na JRT Technology Solutions, com diagnóstico e solução.
-
Erro: “AF_PACKET: Failed to setup AF_PACKET capture: ioctl: No such device”
Causa: A interface especificada não existe ou o nome está incorreto.
Sintoma: O Suricata falha ao iniciar com mensagem de dispositivo não encontrado.
Solução: Liste as interfaces disponíveis com ip link show e verifique o nome exato. Ajuste a diretiva interface: no suricata.yaml. -
Erro: “Permission denied opening /var/log/suricata/eve.json”
Causa: O usuário que tenta executar o Suricata não tem permissão de escrita no diretório de logs (geralmente ao rodar sem sudo ou com usuário sem grupo suricata).
Sintoma: Suricata inicia mas não gera arquivos de log; mensagens de erro nos logs do sistema.
Solução: Execute o Suricata com sudo ou adicione seu usuário ao grupo suricata (sudo usermod -a -G suricata $USER) e ajuste as permissões do diretório com sudo chown -R suricata:suricata /var/log/suricata. -
Erro: “Warn: detect: No rules loaded from /var/lib/suricata/rules/suricata.rules”
Causa: Arquivo de regras não existe ou está vazio.
Sintoma: Suricata inicia, mas nenhum alerta é gerado, e o log mostra ausência de regras.
Solução: Execute sudo suricata-update para baixar as regras e verifique se o caminho em default-rule-path: no suricata.yaml corresponde ao arquivo gerado. -
Erro: “Performance: high packet loss (50%+) detectada no stats.log”
Causa: Workers de captura insuficientes, buffer de anel pequeno ou CPU sobrecarregada.
Sintoma: O arquivo stats.log mostra valores altos de capture.kernel_drops.
Solução: Aumente o número de threads em af-packet, ajuste ring-size para 300000 ou mais, garanta que o cluster-type esteja como cluster_flow e considere usar workers em vez de autofp. Monitore com suricata –dump-stats. -
Erro: “NFQUEUE: Failed to bind to queue 0”
Causa: Ao tentar rodar em modo IPS, a fila NFQUEUE não foi configurada ou o módulo nfnetlink_queue não está carregado.
Sintoma: Suricata sai com erro ao usar configuração nfqueue.
Solução: Certifique-se de que o módulo está carregado (sudo modprobe nfnetlink_queue) e que as regras de iptables/nftables encaminham tráfego para a queue (ex: sudo iptables -I FORWARD -j NFQUEUE –queue-num 0).
Boas Práticas e Dicas Avançadas com Suricata
Após dominar a instalação e a configuração básica, você pode levar seu IDS/IPS a um nível de eficiência operacional muito superior. Aqui estão práticas que aplicamos rotineiramente nos projetos da JRT Technology Solutions.
1. Ajuste de afinidade de CPU e isolamento de threads: Use set-cpu-affinity: yes e especifique cores dedicados para workers. Em sistemas NUMA, garanta que cada worker e sua fila de captura estejam no mesmo nó NUMA para evitar latência de acesso remoto à memória. Isso pode ser feito com numactl ou configurando pinning no yaml.
2. Integração com o Elastic Stack (ELK): O formato eve.json é nativamente suportado pelo Filebeat e Logstash. Envie os logs para o Elasticsearch e crie dashboards no Kibana para monitorar alertas, transações DNS, TLS e HTTP em tempo real. Essa stack transforma o Suricata em uma verdadeira plataforma SOC.
3. Regras customizadas para ameaças específicas: Embora as regras Emerging Threats cubram uma ampla gama de ataques, você pode criar suas próprias assinaturas no arquivo /etc/suricata/rules/local.rules. Exemplo: alertar sobre acesso a um servidor interno específico fora do horário comercial. Use a sintaxe de regras do Suricata (similar à do Snort) e recarregue sem interrupção com sudo suricatasc -c reload-rules.
4. Modo IPS inline para bloqueio ativo: Configure o Suricata para atuar como IPS combinando-o com iptables NFQUEUE. O tráfego é passado para o Suricata, que decide se aceita ou descarta o pacote. Importante: use a opção fail-open: yes para que, em caso de falha do processo Suricata, o tráfego não seja interrompido. Essa configuração exige cuidados com performance, pois adiciona latência.
5. Monitoramento de performance contínuo: Ative o módulo stats no suricata.yaml e colete as métricas periodicamente. Use ferramentas como Prometheus com suricata_exporter para visualizar taxas de pacotes, perdas e uso de CPU, permitindo identificar gargalos antes que causem perda de eventos.
Resumo da Aula 26
Nesta aula de nível avançado, transformamos o Suricata de um simples conceito em uma instalação de IDS/IPS robusta e otimizada. Começamos compreendendo a arquitetura multi-thread que diferencia o Suricata no mercado, passamos pela instalação passo a passo em distribuições Debian e RHEL, detalhamos o arquivo de configuração suricata.yaml com suas seções mais críticas, aprendemos a gerenciar regras com o suricata-update e realizamos testes de validação essenciais. Abordamos a execução em modo IDS, interpretação de logs e, crucialmente, a solução dos erros mais comuns encontrados no mundo real.
Os profissionais da JRT Technology Solutions empregam exatamente esses procedimentos para implementar soluções de segurança de rede que protegem dados sensíveis e garantem conformidade regulatória. Lembre-se: um IDS/IPS é tão bom quanto sua configuração e as regras que o alimentam. Mantenha suas regras atualizadas, monitore a performance constantemente e ajuste os parâmetros de threading conforme a carga.
A tabela abaixo reúne os comandos essenciais utilizados ao longo da aula para sua referência rápida:
| Comando | Descrição |
|---|---|
| sudo apt install -y suricata | Instala o Suricata via repo OISF no Ubuntu/Debian |
| sudo dnf install -y suricata | Instala no Rocky Linux 9 / RHEL 9 |
| sudo suricata -T -c /etc/suricata/suricata.yaml -v | Testa a configuração sem iniciar o motor |
| sudo suricata-update | Baixa e atualiza o conjunto de regras Emerging Threats |
| sudo suricata -c /etc/suricata/suricata.yaml -i eth1 -D | Inicia o Suricata em modo IDS como daemon na interface eth1 |
| sudo tail -f /var/log/suricata/eve.json | jq | Acompanha logs JSON em tempo real com filtro |
| sudo suricatasc -c reload-rules | Recarrega regras sem interromper a captura |
Na próxima aula (Aula 27), mergulharemos na Integração de Suricata com Elastic Stack e Grafana — Dashboards de Segurança Operacional. Você aprenderá a construir um pipeline completo de monitoramento que transforma eventos brutos em inteligência acionável, fechando o ciclo de detecção e resposta. Ative o modo IPS inline em um cenário controlado, explore as regras baixadas e revise o suricata.yaml — o domínio dessa ferramenta é um diferencial poderoso na carreira de qualquer especialista em Segurança Linux.
Quer aprender na prática com especialistas?
A JRT Technology Solutions oferece treinamentos e implementação de Segurança Linux para equipes corporativas.