Aula 25: Snort — IDS/IPS open source: instalação, regras e detecção de ameaças

Quando falamos de monitoramento ativo de rede e detecção de intrusões em ambientes Linux, o Snort ocupa um lugar de destaque absoluto. Ele é, sem dúvida, o sistema de detecção e prevenção de intrusões (IDS/IPS) open source mais consolidado do mercado — e dominar sua instalação, configuração e operação é um diferencial competitivo para qualquer profissional de segurança da informação ou infraestrutura. Em nossos projetos na JRT Technology Solutions, utilizamos diariamente o Snort como peça central de arquiteturas de defesa em profundidade, combinando-o com firewalls, proxies e SIEMs para oferecer visibilidade completa sobre o tráfego que atravessa redes corporativas.

Esta aula marca a entrada definitiva no bloco avançado do nosso curso, e você perceberá que o nível de exigência sobe consideravelmente. Não se trata apenas de instalar um pacote e iniciar um serviço: trabalhar com Snort exige compreensão profunda de protocolos de rede, assinaturas de ataques, tuning de falsos positivos e, principalmente, muita prática laboratorial. Ao final desta aula, você terá percorrido todo o caminho — da instalação em distribuições diferentes (Ubuntu/Debian e CentOS/Rocky Linux) até a criação de regras personalizadas e análise de alertas reais. Cada comando, cada arquivo de configuração e cada saída de terminal será mostrada na íntegra, sem resumos ou atalhos que comprometam seu aprendizado.

Por que o Snort é tão relevante ainda hoje, mesmo com o surgimento de alternativas como Suricata e Zeek? A resposta está na maturidade do projeto, na gigantesca base de regras mantida pela comunidade e pela Talos (Cisco), e na flexibilidade para operar em três modos distintos — sniffer, packet logger e sistema de detecção de intrusões (NIDS). Além disso, o Snort pode atuar como IPS inline, bloqueando ativamente ameaças quando integrado ao netfilter do Linux. É uma ferramenta que exige investimento de tempo para dominar, mas que devolve esse esforço em forma de controle granular sobre cada pacote que trafega em seus segmentos de rede.

Antes de mergulharmos nos procedimentos práticos, é fundamental que você tenha concluído as aulas anteriores, especialmente a Aula 22 (sobre iptables e netfilter) e a Aula 23 (sobre tcpdump e análise de pacotes), pois vamos nos apoiar fortemente nesses conhecimentos. Se você já domina a anatomia de pacotes TCP/IP, entende como funcionam chains e regras de firewall, e sabe interpretar arquivos pcap, estará perfeitamente preparado. Caso contrário, recomendo fortemente revisitar essas aulas antes de prosseguir — a curva de aprendizado aqui não perdoa gaps nos fundamentos de redes.

Ao final desta aula, você terá instalado e configurado um sensor Snort funcional em modo IDS, será capaz de escrever suas próprias regras de detecção, executará testes controlados de ataque para gerar alertas e verificará passo a passo se tudo está funcionando conforme o esperado. Abordaremos também os erros mais comuns que surgem nesse percurso — e como resolvê-los de forma definitiva. Prepare seu laboratório, reserve algumas horas de concentração e vamos começar.

O que você vai aprender nesta aula

• Compreender a arquitetura interna do Snort e seus modos de operação (sniffer, packet logger e NIDS)
• Instalar o Snort do zero em distribuições baseadas em Debian (Ubuntu 24.04 LTS) e RHEL (Rocky Linux 9)
• Configurar o arquivo snort.conf de forma completa, linha por linha, adaptado ao seu ambiente de rede
• Baixar e ativar as regras oficiais da comunidade e regras registradas da Cisco Talos
• Escrever regras personalizadas de detecção para cenários reais (scan de portas, tentativas de login SSH, tráfego malicioso conhecido)
• Executar o Snort em modo IDS com logging em alertas, realizar testes de detecção e interpretar os resultados
• Diagnosticar e corrigir os principais erros de configuração que impedem o funcionamento correto
• Integrar o Snort com ferramentas complementares como Barnyard2 e bancos de dados (visão geral)

Pré-requisitos e Ambiente

Antes de iniciar os procedimentos, você precisará de um ambiente Linux limpo, de preferência em máquina virtual ou container com duas interfaces de rede (uma para gerenciamento e outra para análise). Para esta aula, utilizaremos como base dois sistemas: Ubuntu 24.04 LTS (representando o ecossistema Debian) e Rocky Linux 9 (representando o ecossistema RHEL). Ambos devem estar atualizados e com acesso à internet para download de pacotes e regras.

É altamente recomendável que a interface de rede dedicada à análise esteja em modo promíscuo e sem endereço IP configurado, para operar como sensor passivo. Isso garante que o tráfego espelhado de um switch (port mirroring/SPAN) seja capturado sem que o sensor interfira na comunicação. Se você não dispuser de um switch gerenciável, pode testar com tráfego local da própria máquina, utilizando a interface lo ou a interface principal com IP, embora isso limite alguns cenários avançados que exploraremos.

Verifique também se os seguintes pacotes básicos estão instalados em ambos os sistemas:

• gcc, make, cmake — compiladores e ferramentas de build (necessários se optar por compilar da fonte, embora usemos binários pré-compilados)
• libpcap-dev (Debian) ou libpcap-devel (RHEL) — biblioteca de captura de pacotes, essencial para o funcionamento do Snort
• libdnet — biblioteca de manipulação de rede de baixo nível
• daq — Data AcQuisition library, abstração de captura de pacotes
• openssl e libssl-dev — para suporte a criptografia e análise de tráfego TLS (inspeção limitada)
• pcre2 — biblioteca de expressões regulares compatível com Perl, usada nas regras

Em nossos projetos na JRT Technology Solutions, padronizamos a instalação do Snort diretamente a partir dos repositórios oficiais da distribuição sempre que possível, complementando com compilação manual apenas quando necessitamos de módulos específicos (como suporte a JSON ou plugins personalizados). Nesta aula, adotaremos a instalação via gerenciador de pacotes para garantir reprodutibilidade e estabilidade.

Entendendo a Arquitetura do Snort: Como o Motor de Detecção Funciona

Antes de executar comandos, é crucial compreender a anatomia interna do Snort. A ferramenta é composta por diversos componentes que atuam em pipeline: o tráfego de rede é capturado pela camada DAQ (Data AcQuisition), que abstrai a interface física e entrega os pacotes ao motor principal. Em seguida, o decoder interpreta os cabeçalhos de cada camada de protocolo (Ethernet, IP, TCP/UDP, ICMP, etc.), montando uma representação estruturada de cada pacote. Esses dados são então passados aos pré-processadores — módulos que realizam tarefas como remontagem de fragmentação IP, normalização de tráfego e detecção de anomalias baseadas em estado (como portscans).

O coração do Snort é o motor de detecção (detection engine), que aplica milhares de regras carregadas em memória contra cada pacote e fluxo. As regras são organizadas em uma estrutura de árvore otimizada (rule tree), onde os cabeçalhos das regras (protocolo, portas, direção) formam nós de decisão rápida (fast pattern matcher). Quando um pacote corresponde aos critérios de cabeçalho, as opções de regra — que incluem palavras-chave de conteúdo (content), expressões regulares (pcre), flags, profundidade de inspeção e metadados — são avaliadas em sequência. Se todas as condições forem satisfeitas, o alerta é gerado e encaminhado para os plugins de saída (output plugins), que podem registrar em arquivos de log, syslog, banco de dados MySQL/PostgreSQL, JSON, ou enviar para ferramentas SIEM via Unix sockets.

O Snort oferece três modos de operação distintos, que você pode alternar com flags de linha de comando:

O arquivo de configuração central é o snort.conf, que controla todas as variáveis de rede (HOME_NET, EXTERNAL_NET), caminhos de regras, importação de classificações, ativação de pré-processadores e formatos de saída. Qualquer erro de sintaxe ou referência quebrada nesse arquivo impede a inicialização do Snort. Nas seções seguintes, abordaremos cada bloco desse arquivo de forma exaustiva.

Instalação Completa do Snort no Ubuntu/Debian

Nesta seção, executaremos a instalação do Snort em um sistema Ubuntu 24.04 LTS passo a passo, com todos os comandos e respectivas saídas esperadas. O procedimento é idêntico para Debian 12 (Bookworm), com pequenas variações nos nomes de pacotes. Vamos começar atualizando o sistema e instalando todas as dependências necessárias.

Passo 1 — Atualize a lista de pacotes e instale as dependências obrigatórias:

# Atualiza o cache de repositórios e faz upgrade completo do sistema
sudo apt update && sudo apt upgrade -y

# Instala dependências de compilação, bibliotecas e ferramentas essenciais
sudo apt install -y build-essential libpcap-dev libpcre3-dev libdumbnet-dev \
zlib1g-dev liblzma-dev libssl-dev libdnet-dev pkg-config bison flex \
libdaq-dev daq-modules-daq-pcap daq-modules-daq-afpacket daq-modules-daq-nfq \
libnetfilter-queue-dev cmake wget tar gzip

O pacote libdaq-dev é crítico: ele instala a biblioteca de abstração de aquisição de dados que permite ao Snort capturar pacotes via PCAP, AF_PACKET (alta performance) e NFQUEUE (modo IPS inline). Os pacotes daq-modules-* fornecem os módulos de captura compilados. Se algum desses pacotes não for encontrado, você pode compilar a libdaq da fonte, mas em Ubuntu 24.04 eles estão disponíveis no repositório oficial universe. Certifique-se de que o repositório universe está habilitado:

# Habilita o repositório universe, se necessário
sudo add-apt-repository universe
sudo apt update

Passo 2 — Agora instalamos o pacote principal do Snort. No Ubuntu 24.04, o Snort está disponível diretamente no repositório oficial com a versão 2.9.x (a branch estável legada). Para a versão 3.x (Snort3), seria necessário compilar da fonte ou utilizar repositórios da Cisco. Nesta aula, focaremos no Snort 2.9.x, que ainda é amplamente utilizado e tem documentação farta:

# Instala o Snort a partir do repositório oficial
sudo apt install -y snort

Durante a instalação, o assistente do pacote (debconf) perguntará qual a sua rede local (HOME_NET). Informe o endereço CIDR da sua rede, por exemplo: 192.168.1.0/24. Se você não tiver certeza no momento, pode deixar em branco ou usar o padrão any; editaremos essa configuração posteriormente no arquivo snort.conf. O instalador também perguntará sobre a interface de rede a ser monitorada — indique a interface correta, por exemplo eth1 ou ens34. Essas respostas são armazenadas no arquivo /etc/snort/snort.conf e podem ser alteradas a qualquer momento.

Passo 3 — Verifique se os binários foram instalados corretamente:

# Verifica versão do Snort
snort --version

# Verifica caminho do binário
which snort

# Lista interfaces disponíveis para captura
snort --list-intfs

,,_     -*> Snort! <*-
o"  )~   Version 2.9.20-1build1 IPv6 GRE (Build 82)
 ''''    By Martin Roesch & The Snort Team: http://www.snort.org/contact#team
         Copyright (C) 2014-2021 Cisco and/or its affiliates. All rights reserved.
         Copyright (C) 1998-2013 Sourcefire, Inc., et al.
         Using libpcap version 1.10.4 (with TPACKET_V3)
         Using PCRE version 8.39 2016-06-14
         Using ZLIB version 1.3

Interface       Device  Description
--------------- ------- --------------------------------------------------
1               eth0    Up
2               eth1    Up
3               lo      Up

A saída esperada mostra a versão do Snort, as bibliotecas linkadas (libpcap, PCRE, ZLIB) e a lista de interfaces de rede disponíveis para monitoramento. É fundamental que a interface que você pretende utilizar (por exemplo, eth1) apareça com estado Up. Se a interface não aparecer, verifique com ip link show e certifique-se de que o adaptador de rede está ativo no hypervisor (VirtualBox, VMware, etc.).

Instalação Completa do Snort no CentOS/RHEL/Rocky Linux

Em sistemas da família RHEL, como Rocky Linux 9, o Snort não está disponível nos repositórios oficiais padrão. Precisamos habilitar o repositório EPEL (Extra Packages for Enterprise Linux) e, em alguns casos, compilar a partir do código fonte ou utilizar repositórios de terceiros confiáveis. Mostraremos aqui o método via compilação a partir do código fonte oficial, que garante controle total sobre a versão e módulos habilitados. Este procedimento funciona identicamente em CentOS Stream 9, RHEL 9 e AlmaLinux 9.

Passo 1 — Instalar dependências de desenvolvimento e ferramentas:

# Habilita CRB (CodeReady Builder / PowerTools) e EPEL
sudo dnf install -y epel-release
sudo dnf config-manager --set-enabled crb

# Instala grupo de ferramentas de desenvolvimento e bibliotecas
sudo dnf groupinstall -y "Development Tools"
sudo dnf install -y libpcap-devel pcre2-devel libdnet-devel \
zlib-devel xz-devel openssl-devel bison flex cmake \
libnetfilter_queue-devel wget tar gzip

Passo 2 — Baixar e compilar a biblioteca libdaq diretamente do site oficial do Snort. A versão utilizada deve ser compatível com a versão do Snort que instalaremos:

# Diretório temporário para compilação
mkdir -p ~/snort_build && cd ~/snort_build

# Baixa a libdaq versão 2.0.7 (estável e compatível com Snort 2.9.20)
wget https://www.snort.org/downloads/snort/daq-2.0.7.tar.gz
tar -xzf daq-2.0.7.tar.gz
cd daq-2.0.7

# Configura, compila e instala
./configure --prefix=/usr/local --with-daq-includes=/usr/local/include --with-daq-libraries=/usr/local/lib
make -j$(nproc)
sudo make install

# Atualiza o cache de bibliotecas compartilhadas
sudo ldconfig
cd ..

Passo 3 — Baixar e compilar o Snort 2.9.20 (a versão estável mais recente da branch 2.x):

# Download do código fonte do Snort
wget https://www.snort.org/downloads/snort/snort-2.9.20.tar.gz
tar -xzf snort-2.9.20.tar.gz
cd snort-2.9.20

# Configuração com suporte a IPv6, GRE e os prefixos corretos para a libdaq customizada
./configure --prefix=/usr/local --enable-sourcefire \
--enable-ipv6 --enable-gre --with-daq-includes=/usr/local/include \
--with-daq-libraries=/usr/local/lib

# Compilação e instalação
make -j$(nproc)
sudo make install

# Atualiza cache de libs e verifica instalação
sudo ldconfig
snort --version

,,_     -*> Snort! <*-
o"  )~   Version 2.9.20 (Build 82)
 ''''    By Martin Roesch & The Snort Team: http://www.snort.org/contact#team
         Copyright (C) 2014-2021 Cisco and/or its affiliates. All rights reserved.
         Copyright (C) 1998-2013 Sourcefire, Inc., et al.
         Using libpcap version 1.10.4 (with TPACKET_V3)
         Using PCRE version 10.42 2022-12-11
         Using ZLIB version 1.2.11

Se a saída exibir a versão 2.9.20 com as bibliotecas corretas, a instalação foi bem-sucedida. O binário snort estará em /usr/local/bin/snort. Certifique-se de que este diretório está no PATH ou utilize o caminho completo nos comandos seguintes.

Configuração Detalhada do Arquivo snort.conf

O arquivo snort.conf é o cérebro da operação. Cada seção define parâmetros críticos que afetam diretamente a capacidade de detecção, o desempenho e a precisão dos alertas. Iremos agora criar um arquivo de configuração funcional completo, adequado para um ambiente de produção básico, com comentários explicativos em cada bloco. Este arquivo deve ser salvo como /etc/snort/snort.conf no Ubuntu/Debian ou /usr/local/etc/snort.conf no Rocky Linux (crie o diretório se necessário: sudo mkdir -p /usr/local/etc).

Apresentamos a seguir o conteúdo integral do arquivo. Leia cada seção com atenção antes de copiar; ajustes nos endereços IP da sua rede local são obrigatórios para que as regras funcionem corretamente.

# ============================================================================
# SEGURANCA LINUX - Aula 25: Arquivo snort.conf completo
# JRT Technology Solutions - www.jrt.com.br
# Adapte HOME_NET e EXTERNAL_NET para seus segmentos de rede
# ============================================================================

# ---------- 1. Variaveis de Rede ----------
# Defina corretamente o intervalo da sua rede interna. Use 'any' se nao tiver certeza.
ipvar HOME_NET 192.168.1.0/24

# Defina a rede externa. Normalmente !$HOME_NET (tudo que nao e HOME_NET).
ipvar EXTERNAL_NET !$HOME_NET

# Lista de servidores DNS internos (para regras de exfiltracao DNS)
ipvar DNS_SERVERS $HOME_NET

# Lista de servidores SMTP internos (para regras de malware que usam SMTP)
ipvar SMTP_SERVERS $HOME_NET

# Lista de servidores HTTP internos (para regras de ataque web)
ipvar HTTP_SERVERS $HOME_NET

# Portas de servicos que expoe a rede interna
portvar HTTP_PORTS [80,443,8080,8443]
portvar ORACLE_PORTS 1521

# Caminho para as regras (ajuste conforme seu sistema)
var RULE_PATH /etc/snort/rules
var PREPROC_RULE_PATH /etc/snort/preproc_rules
var WHITE_LIST_PATH /etc/snort/rules
var BLACK_LIST_PATH /etc/snort/rules

# ---------- 2. Pre-processadores ----------
# Configuracao do pre-processador frag3 (remontagem de fragmentacao IP)
preprocessor frag3_global: max_frags 65536
preprocessor frag3_engine: policy linux bind_to 192.168.1.0/24 detect_anomalies

# Pre-processador stream5 (remontagem de fluxo TCP, essencial)
preprocessor stream5_global: track_tcp yes, track_udp no, track_icmp no, max_tcp 8192
preprocessor stream5_tcp: policy linux, detect_anomalies, require_3whs 180, overlap_limit 10

# Pre-processador de normalizacao HTTP (inspecao de trafego web)
preprocessor http_inspect: global iis_unicode_map /etc/snort/unicode.map 1252 compress_depth 65535 decompress_depth 65535
preprocessor http_inspect_server: server default profile all ports { 80 443 8080 8443 } extended_response_inspection enable_cookie

# Pre-processador sfPortscan (deteccao de varreduras de porta)
preprocessor sfportscan: proto { all } memcap { 10000000 } sense_level { medium }

# Pre-processador de backdoor (deteccao de traffic patterns de backdoors conhecidos)
preprocessor bo: enable

# ---------- 3. Plugins de Saida ----------
# Alerta rapido em arquivo de log (modo texto, legivel)
output alert_fast: alert.ids fast

# Alerta completo com payload (verbose, para analise detalhada)
output alert_full: alert_full.ids

# Log em formato syslog (enviar para SIEM via rsyslog)
# output alert_syslog: LOG_LOCAL3 LOG_ALERT

# Log em formato unificado (para Barnyard2 processar e inserir em BD)
# output unified2: filename snort.u2, limit 128

# ---------- 4. Inclusao de Regras ----------
# Regras de classificacao (prioridade e tipo de ataque)
include classification.config

# Regras de referencia (URLs de CVEs, Bugtraq, etc.)
include reference.config

# Regras da comunidade (baixe do site do Snort)
include $RULE_PATH/community.rules

# Regras de ICMP e outros protocolos
include $RULE_PATH/icmp.rules

# Regras de varredura e reconhecimento
include $RULE_PATH/scan.rules

# Regras para ataques web (SQLi, XSS, etc.)
include $RULE_PATH/web-attacks.rules

# Regras para backdoors e trojans
include $RULE_PATH/backdoor.rules

# Regras especificas de malware
include $RULE_PATH/malware-cnc.rules

# Regras de tentativa de brute force SSH, FTP, etc.
include $RULE_PATH/brute-force.rules

# Regras para shellcode e buffer overflows
include $RULE_PATH/shellcode.rules

# ---------- 5. Listas de IPs (whitelist/blacklist) ----------
# Whitelist: IPs que jamais devem gerar alertas (ex: servidores de monitoracao)
# whitelist $WHITE_LIST_PATH/white_list.rules

# Blacklist: IPs sempre bloqueados/alertados
# blacklist $BLACK_LIST_PATH/black_list.rules

# ========== FIM DO ARQUIVO snort.conf ==========

Observações importantes sobre este arquivo: a variável HOME_NET deve refletir exatamente o seu segmento de rede local. Se você utiliza múltiplas sub-redes, pode defini-las como [192.168.1.0/24,10.0.0.0/16]. A diretiva ipvar (IP variable) suporta listas e permite o uso da macro $HOME_NET em outras variáveis. O caminho RULE_PATH aponta para o diretório onde ficarão os arquivos de regras; em sistemas Debian, geralmente é /etc/snort/rules, enquanto em compilações manuais pode ser /usr/local/etc/rules ou outro de sua escolha — o importante é criar o diretório e garantir permissão de leitura para o usuário que executa o Snort.

A seção de pré-processadores é vital: o frag3 cuida da remontagem de pacotes IP fragmentados (técnica clássica de evasão de IDS), o stream5 reconstrói sessões TCP completas para que o motor de regras possa inspecionar o fluxo como um todo (e não apenas pacotes isolados), e o sfPortscan implementa um sofisticado algoritmo de detecção de varreduras baseado em limiares e análise estatística. Alterar parâmetros nesses pré-processadores sem conhecimento profundo pode gerar avalanches de falsos positivos ou, pior, cegueira para ataques reais.

Criando Regras Personalizadas de Detecção

As regras oficiais da comunidade e da Cisco Talos cobrem milhares de ameaças conhecidas, mas em cenários corporativos específicos — como detectar acessos a um servidor interno fora do horário comercial ou identificar strings particulares em aplicações legadas — é indispensável escrever suas próprias regras. A sintaxe de uma regra Snort segue uma estrutura rigorosa, composta por cabeçalho e opções:

ação protocolo origem porto direção destino porto (opções)

Onde:

Vamos criar um arquivo de regras personalizadas chamado local.rules dentro do diretório /etc/snort/rules/ (ou o caminho correspondente em seu sistema) com exemplos práticos e funcionais que você pode testar imediatamente. Cada regra é acompanhada de uma explicação detalhada.

# local.rules - Regras Personalizadas para Aula 25
# JRT Technology Solutions

# Regra 1: Alerta quando qualquer IP externo tentar conexao SSH para nossa rede
# (Util para detectar brute force em portas SSH expostas)
alert tcp $EXTERNAL_NET any -> $HOME_NET 22 ( \
    msg:"SSH - Tentativa de conexao de rede externa"; \
    flow:to_server,established; \
    content:"SSH-"; \
    nocase; \
    classtype:attempted-user; \
    sid:1000001; rev:1; \
    priority:3; \
)

# Regra 2: Alerta para trafego ICMP Echo Request (ping) de possivel scan
alert icmp $EXTERNAL_NET any -> $HOME_NET any ( \
    msg:"ICMP - Echo Request de IP externo (possivel varredura)"; \
    itype:8; \
    threshold: type threshold, track by_src, count 5, seconds 60; \
    classtype:network-scan; \
    sid:1000002; rev:1; \
)

# Regra 3: Deteccao de tentativa de acesso a /etc/passwd via HTTP
alert tcp $EXTERNAL_NET any -> $HOME_NET $HTTP_PORTS ( \
    msg:"WEB-ATTACK - Tentativa de path traversal para /etc/passwd"; \
    flow:to_server,established; \
    content:"/etc/passwd"; \
    nocase; \
    classtype:web-application-attack; \
    sid:1000003; rev:1; \
    reference:url,owasp.org/index.php/Path_Traversal; \
)

# Regra 4: Alerta para downloads de executaveis PE via HTTP (extensoes comuns de malware)
alert tcp $HOME_NET any -> $EXTERNAL_NET $HTTP_PORTS ( \
    msg:"MALWARE - Possivel download de executavel via HTTP"; \
    flow:to_client,established; \
    content:".exe"; \
    http_uri; \
    nocase; \
    classtype:malware-activity; \
    sid:1000004; rev:1; \
)

# Regra 5: Deteccao de strings suspeitas em payload UDP (exemplo didatico)
alert udp any any -> any 53 ( \
    msg:"DNS - Query suspeita com path traversal"; \
    content:"../"; \
    nocase; \
    classtype:attempted-admin; \
    sid:1000005; rev:1; \
)

# Regra 6: Monitoramento de trafego Telnet (protocolo inseguro, deve ser alertado)
alert tcp any any -> $HOME_NET 23 ( \
    msg:"TELNET - Conexao detectada para porta telnet (protocolo inseguro)"; \
    flow:to_server,established; \
    classtype:policy-violation; \
    sid:1000006; rev:1; \
)

Cada regra possui um sid (Snort ID) único, essencial para identificação e gerenciamento. SIDs de 1 a 999.999 são reservados para regras oficiais; SIDs acima de 1.000.000 podem ser usados para regras personalizadas locais. O campo classtype referencia categorias definidas no arquivo classification.config, que por sua vez mapeia para prioridades (1 = crítica, 2 = alta, 3 = média, 4 = baixa). A opção threshold na regra 2 implementa um limitador: só gera alerta se o mesmo IP de origem enviar pelo menos 5 pings em 60 segundos — isso reduz drasticamente falsos positivos de monitoramento legítimo.

Agora inclua o arquivo de regras local no snort.conf adicionando a seguinte linha ao final da seção de inclusão de regras:

include $RULE_PATH/local.rules

Certifique-se de que o diretório /etc/snort/rules/ existe e contém pelo menos os arquivos classification.config e reference.config. Caso não existam, você pode baixá-los do repositório oficial do Snort ou criá-los manualmente:

# Cria diretorio de regras (se nao existir)
sudo mkdir -p /etc/snort/rules

# Baixa classification.config e reference.config do GitHub do Snort
cd /etc/snort/rules
sudo wget https://raw.githubusercontent.com/snort3/snort2_demo/master/classification.config
sudo wget https://raw.githubusercontent.com/snort3/snort2_demo/master/reference.config

# Baixa regras da comunidade (opcional, mas recomendado)
sudo wget https://www.snort.org/downloads/community/community-rules.tar.gz
sudo tar -xzf community-rules.tar.gz
sudo cp community-rules/community.rules /etc/snort/rules/community.rules
sudo rm -rf community-rules community-rules.tar.gz

Executando o Snort em Modo IDS e Gerando Alertas

Com a configuração e as regras prontas, chegou o momento de executar o Snort em modo IDS e realizar testes práticos de detecção. Primeiro, validaremos a sintaxe do arquivo de configuração e das regras — um passo que evita horas de frustração caçando erros de digitação ou caminhos incorretos.

# Testa a configuracao e regras (modo de verificacao -T)
# Substitua eth1 pela sua interface de captura
sudo snort -T -c /etc/snort/snort.conf -i eth1

Running in Test mode

        --== Initializing Snort ==--
Initializing Output Plugins!
Initializing Preprocessors!
Initializing Plug-ins!
Parsing Rules file "/etc/snort/snort.conf"
Tagged Packet Limit: 256
Log directory = /var/log/snort

+++++++++++++++++++++++++++++++++++++++++++++++++++
Initializing rule chains...
10001 Snort rules read
     detection: 7843
     decoder: 0
     preprocessor: 2158
10001 rules in total
+++++++++++++++++++++++++++++++++++++++++++++++++++

Rule application order: activation->dynamic->pass->drop->sdrop->reject->alert->log
Verifying Preprocessor Configurations!

[ Port Based Pattern Matching Memory ]
+-[AC-BNFA Search Info Summary]------------------------------
| Instances        : 496
| Patterns         : 218076
| Pattern Chars    : 1784332
| Num States       : 983456
| Num Match States : 88732
| Memory           : 34.91 MBytes
| Patterns         : 324.56 K
+-----------------------------------------------------------

Snort successfully validated the configuration!
Snort exiting

A mensagem "Snort successfully validated the configuration!" é o sinal verde que esperamos. Nesta saída, vemos que o Snort carregou 10.001 regras no total, entre regras da comunidade e nossas regras personalizadas. O número pode variar conforme os arquivos de regra que você incluiu. Se, em vez disso, aparecerem erros como "ERROR: ...", "FATAL: ..." ou "Undefined variable", prossiga imediatamente para a seção Erros Comuns e Como Resolver.

Agora executaremos o Snort em modo IDS com logging de alertas. Este comando deve ser executado em um terminal que permanecerá aberto (ou use nohup/screen para daemonizá-lo):

# Executa Snort em modo IDS, gerando alertas em tempo real
# -A console: mostra alertas no terminal
# -c: arquivo de config
# -i: interface de captura
# -l: diretorio de logs (-l /var/log/snort)
sudo snort -A console -c /etc/snort/snort.conf -i eth1 -l /var/log/snort

Assim que o Snort estiver em execução, você verá uma série de mensagens de inicialização e, em seguida, o prompt ficará aguardando pacotes. Para gerar tráfego malicioso e testar as regras, abra outro terminal na mesma máquina (ou em outra máquina da rede) e execute alguns comandos que disparem as regras que criamos:

# Teste 1: Ping múltiplo para disparar regra de varredura ICMP (sid:1000002)
ping -c 10 192.168.1.100

# Teste 2: Tentativa de acesso via Telnet na porta 23 (sid:1000006)
telnet 192.168.1.100 23

# Teste 3: Requisicao web maliciosa simulando path traversal (sid:1000003)
curl http://192.168.1.100/../../../../etc/passwd

# Teste 4: Tentativa de conexao SSH (sid:1000001)
ssh root@192.168.1.100

No terminal onde o Snort está rodando, você deverá ver alertas similares a estes (exemplo real):

04/15-22:34:18.123456  [**] [1:1000001:1] SSH - Tentativa de conexao de rede externa [**] [Classification: Attempted User Privilege Gain] [Priority: 3] {TCP} 192.168.1.50:54321 -> 192.168.1.100:22
04/15-22:34:25.654321  [**] [1:1000002:1] ICMP - Echo Request de IP externo (possivel varredura) [**] [Classification: Network Scan] [Priority: 3] {ICMP} 192.168.1.50 -> 192.168.1.100
04/15-22:34:30.987654  [**] [1:1000006:1] TELNET - Conexao detectada para porta telnet (protocolo inseguro) [**] [Classification: Policy Violation] [Priority: 3] {TCP} 192.168.1.50:60000 -> 192.168.1.100:23

Os alertas gerados comprovam que o Snort está inspecionando o tráfego e disparando as regras corretamente. O formato de saída inclui timestamp, SID, mensagem, classificação, prioridade, protocolo e tupla de endereços IP e portas. Para interromper o Snort, pressione Ctrl+C; ele exibirá um resumo estatístico da sessão.

Verificando a Instalação / Testando a Configuração

Esta seção consolida os testes de verificação que garantem que tudo está operacional. Execute os comandos a seguir em sequência e confira as saídas.

Teste 1: Verificar versão e funcionalidades compiladas

snort --version

Confira se aparecem as bibliotecas libpcap, PCRE e ZLIB nos créditos. A ausência de alguma delas indica compilação incompleta.

Teste 2: Listar interfaces de rede disponíveis

snort --list-intfs

Certifique-se de que a interface que você usará para captura (ex.: eth1 ou ens34) está listada e com estado Up. Se estiver Down, ative-a com sudo ip link set eth1 up.

Teste 3: Validação de configuração e regras (modo de teste)

sudo snort -T -c /etc/snort/snort.conf -i eth1

A saída deve terminar com "Snort successfully validated the configuration!". Qualquer mensagem de erro deve ser investigada antes de prosseguir.

Teste 4: Gerar tráfego de teste e verificar alertas

Com o Snort rodando em modo IDS (-A console), execute comandos de tráfego suspeito (ping múltiplo, telnet, curl com path traversal) e observe os alertas aparecendo no terminal. Se nenhum alerta surgir, revise as variáveis HOME_NET e EXTERNAL_NET no snort.conf — é o erro mais comum (HOME_NET definido incorretamente faz com que o tráfego não case com as regras).

Teste 5: Verificar logs em disco

ls -la /var/log/snort/
cat /var/log/snort/alert.ids

O arquivo alert.ids (ou alert_full.ids, dependendo dos plugins de saída configurados) deve conter os mesmos alertas exibidos no console. Se o arquivo estiver vazio, verifique permissões de escrita no diretório de log — o usuário que roda o Snort (normalmente root) precisa ter permissão de gravação.

Erros Comuns e Como Resolver

Durante anos de implementação de sensores Snort em ambientes corporativos na JRT Technology Solutions, catalogamos os erros mais recorrentes e suas soluções definitivas. Abaixo estão quatro situações clássicas que você provavelmente encontrará.

• Erro "FATAL ERROR: Undefined variable: HOME_NET"
  Causa: O arquivo snort.conf não está definindo a variável HOME_NET antes de utilizá-la em outras diretivas.
  Sintoma: O Snort aborta imediatamente ao iniciar, sem carregar regras.
  Solução: Verifique se a linha ipvar HOME_NET 192.168.1.0/24 (ou equivalente) está presente e sem erros de sintaxe (não use var em vez de ipvar para variáveis de IP). Certifique-se de que não há espaços ou caracteres especiais indevidos. Ajuste o CIDR para corresponder exatamente à sua rede local.
• Erro "ERROR: Unable to open rules file: /etc/snort/rules/local.rules"
  Causa: O arquivo de regras referenciado no snort.conf não existe no caminho especificado ou o usuário não tem permissão de leitura.
  Sintoma: O Snort valida a configuração, mas emite erro durante a fase de parsing de regras e não carrega o