Aula 26: Suricata — IDS/IPS de alta performance com multi-thread e detecção avançada

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.

1. 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

2. 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.

3. 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.

4. 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.

1. 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

2. 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

3. Instale o Suricata:

# Instalar o Suricata
sudo dnf install -y suricata

4. 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.

1. 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

2. Verificar o arquivo de regras gerado:

# Listar primeiras linhas das regras baixadas
head -20 /var/lib/suricata/rules/suricata.rules

3. 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

4. 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.

1. 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.

2. 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:

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.