---
title: "Cómo instalar y configurar Snort 3 IDS en Ubuntu 24.04"
description: "Compila Snort 3 y LibDAQ en Ubuntu 24.04, configura HOME_NET en snort.lua, carga reglas propias y comunitarias y ejecútalo como servicio systemd con alertas."
category: "Seguridad de Red Avanzada"
language: es
source: https://cubepath.com/es/docs/seguridad-de-red-avanzada/configuracion-del-sistema-de-deteccion-de-intrusiones-snort
updated: 2026-09-25
---

# Cómo instalar y configurar Snort 3 IDS en Ubuntu 24.04

Snort es el sistema de detección de intrusiones de red (IDS) de código abierto de Cisco. Su versión actual, Snort 3, es una reescritura completa con configuración en Lua, soporte multihilo y un formato de reglas simplificado. En este tutorial compilarás Snort 3 y su biblioteca de captura LibDAQ en Ubuntu 24.04, configurarás tu red en `snort.lua`, escribirás una regla propia, cargarás las reglas comunitarias y dejarás Snort funcionando como servicio de systemd que escribe alertas en un archivo.

## Requisitos previos

Para seguir esta guía necesitas:

- Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath.
- Un usuario no root con privilegios `sudo`.
- Al menos 2 CPU y 4 GB de RAM. La compilación tarda entre 10 y 30 minutos según la CPU.
- Otra máquina desde la que hacer `ping` al servidor para probar la detección.

> Nota: el paquete `snort` de los repositorios de Ubuntu 24.04 es Snort 2.9, una rama antigua con otro formato de configuración. Esta guía usa Snort 3 compilado desde el código fuente oficial, que es la forma de instalación que documenta el proyecto.

## Paso 1: Instalar las dependencias de compilación

Snort 3 necesita un compilador de C++, CMake y varias bibliotecas: libpcap para capturar paquetes, PCRE2 para las expresiones regulares de las reglas, LuaJIT para la configuración, hwloc y libdnet, entre otras. Instálalas todas de una vez:

```bash
sudo apt update
sudo apt install build-essential cmake pkg-config autoconf automake libtool git \
  flex bison libpcap-dev libpcre2-dev libdumbnet-dev libhwloc-dev \
  libluajit-5.1-dev libssl-dev zlib1g-dev liblzma-dev uuid-dev \
  libmnl-dev libnetfilter-queue-dev ethtool
```

`libmnl-dev` y `libnetfilter-queue-dev` permiten compilar el módulo NFQ de LibDAQ, que necesitarás si en el futuro quieres usar Snort en modo IPS.

Crea un directorio de trabajo para el código fuente:

```bash
mkdir -p ~/snort-src
cd ~/snort-src
```

## Paso 2: Compilar e instalar LibDAQ

LibDAQ es la capa de adquisición de datos de Snort 3: abstrae cómo se reciben los paquetes (pcap, AF_PACKET, NFQ). Se compila antes que Snort. Clona el repositorio oficial:

```bash
git clone https://github.com/snort3/libdaq.git
cd libdaq
```

Genera el script de configuración, compila e instala:

```bash
./bootstrap
./configure
make -j"$(nproc)"
sudo make install
sudo ldconfig
```

Al final de `./configure` verás un resumen de los módulos que se van a compilar. Comprueba que `afpacket`, `pcap` y `nfq` aparecen como `yes`:

```output
    Build AFPacket DAQ module.. : yes
    ...
    Build NFQ DAQ module....... : yes
    Build PCAP DAQ module...... : yes
```

Si alguno sale como `no`, falta su biblioteca de desarrollo; revisa el paso 1.

## Paso 3: Compilar e instalar Snort 3

Vuelve al directorio de trabajo y clona Snort 3. La rama principal del repositorio corresponde a la última versión publicada:

```bash
cd ~/snort-src
git clone https://github.com/snort3/snort3.git
cd snort3
```

Genera el directorio de compilación con el prefijo `/usr/local` y compila:

```bash
./configure_cmake.sh --prefix=/usr/local
cd build
make -j"$(nproc)"
sudo make install
sudo ldconfig
```

Si la compilación falla por falta de memoria (`g++: fatal error: Killed signal terminated program`), vuelve a lanzar `make` con menos trabajos en paralelo, por ejemplo `make -j2`.

Comprueba la instalación:

```bash
snort -V
```

```output
   ,,_     -*> Snort++ <*-
  o"  )~   Version 3.x.x.x
   ''''    By Martin Roesch & The Snort Team
           http://snort.org/contact#team
           Copyright (C) 2014-2026 Cisco and/or its affiliates. All rights reserved.
           Copyright (C) 1998-2013 Sourcefire, Inc., et al.
           Using DAQ version 3.0.x
           Using LuaJIT version 2.1.x
           Using OpenSSL 3.0.13 30 Jan 2024
           Using libpcap version 1.10.4 (with TPACKET_V3)
           Using PCRE2 version 10.42 2022-12-11
           Using ZLIB version 1.3
           Using LZMA version 5.4.5
```

Comprueba también que Snort encuentra los módulos DAQ:

```bash
snort --daq-list
```

La lista debe incluir `afpacket`, `pcap` y `nfq`.

## Paso 4: Preparar la interfaz de red

Muchas tarjetas de red, también las virtuales, agrupan paquetes antes de entregarlos al sistema (GRO y LRO). Snort necesita ver los paquetes tal como circulan por la red, y con esas funciones activas puede truncar o interpretar mal el tráfico. Identifica tu interfaz:

```bash
ip -br address
```

```output
lo               UNKNOWN        127.0.0.1/8 ::1/128
eth0             UP             203.0.113.25/24 2001:db8::25/64 fe80::.../64
```

En este ejemplo la interfaz es `eth0` y la IP del servidor `203.0.113.25`; usa los valores de tu servidor en el resto de la guía. Desactiva GRO y LRO:

```bash
sudo ethtool -K eth0 gro off lro off
```

Si `ethtool` indica que no puede cambiar `large-receive-offload`, la interfaz no lo admite y puedes ignorar el aviso. En el paso 8 harás este cambio persistente.

## Paso 5: Configurar HOME_NET en snort.lua

La configuración de Snort 3 está en `/usr/local/etc/snort/`. El archivo principal es `snort.lua`, que carga los valores por defecto de `snort_defaults.lua`. Ábrelo:

```bash
sudo nano /usr/local/etc/snort/snort.lua
```

Al principio del archivo, cambia `HOME_NET` de `'any'` a las direcciones de tu servidor. Deja `EXTERNAL_NET` como está:

```lua
HOME_NET = '[203.0.113.25/32, 2001:db8::25/128]'

EXTERNAL_NET = '!$HOME_NET'
```

Valida la configuración. Sin interfaz ni archivo de captura, Snort solo comprueba la configuración y termina:

```bash
snort -c /usr/local/etc/snort/snort.lua
```

La salida termina con:

```output
Snort successfully validated the configuration (with 0 warnings).
o")~   Snort exiting
```

## Paso 6: Escribir y probar una regla propia

Las reglas de Snort 3 siguen el formato `acción protocolo origen puerto -> destino puerto (opciones)`. Crea un directorio para las reglas y un archivo de reglas locales:

```bash
sudo mkdir -p /usr/local/etc/rules
sudo nano /usr/local/etc/rules/local.rules
```

Añade una regla que genere una alerta con cada `ping` dirigido al servidor. Los SID a partir de 1000000 están reservados para reglas locales:

```text
alert icmp any any -> $HOME_NET any ( msg:"ICMP detectado hacia el servidor"; itype:8; sid:1000001; rev:1; )
```

Valida la configuración junto con la regla:

```bash
snort -c /usr/local/etc/snort/snort.lua -R /usr/local/etc/rules/local.rules
```

Ahora ejecuta Snort en primer plano sobre la interfaz, mostrando las alertas en la consola en formato de una línea (`-A alert_fast`). La opción `-k none` desactiva la verificación de checksums, que en máquinas virtuales falla a menudo por el offload de la tarjeta:

```bash
sudo snort -c /usr/local/etc/snort/snort.lua -R /usr/local/etc/rules/local.rules \
  -i eth0 -A alert_fast -s 65535 -k none
```

Desde otra máquina, haz `ping` a la IP del servidor. En la consola de Snort aparecerán líneas como esta:

```output
09/25-10:41:07.315842 [**] [1:1000001:1] "ICMP detectado hacia el servidor" [**] [Priority: 0] {ICMP} 198.51.100.7 -> 203.0.113.25
```

Pulsa `Ctrl+C` para detener Snort. Al salir muestra un resumen de los paquetes procesados y las alertas generadas.

## Paso 7: Cargar las reglas comunitarias y activar el log de alertas

Las reglas comunitarias de Snort son un conjunto gratuito mantenido por Talos que no requiere registro. Descárgalas y extráelas en el directorio de reglas:

```bash
cd /tmp
curl -LO https://www.snort.org/downloads/community/snort3-community-rules.tar.gz
tar xzf snort3-community-rules.tar.gz
sudo cp snort3-community-rules/snort3-community.rules /usr/local/etc/rules/
```

Para no tener que pasar `-R` en cada ejecución, incluye los dos archivos de reglas en la configuración. Abre `snort.lua`:

```bash
sudo nano /usr/local/etc/snort/snort.lua
```

Busca el bloque `ips = { ... }` y déjalo así, con las rutas absolutas a tus archivos:

```lua
ips =
{
    enable_builtin_rules = true,
    rules = [[
        include /usr/local/etc/rules/local.rules
        include /usr/local/etc/rules/snort3-community.rules
    ]],
    variables = default_variables
}
```

`enable_builtin_rules` activa además las alertas internas de los decodificadores e inspectores (paquetes malformados, anomalías de protocolo).

En el mismo archivo, busca la sección de salidas (`Configure outputs`) y añade la salida `alert_fast` a un archivo. `limit` es el tamaño máximo en MB antes de rotar el archivo:

```lua
alert_fast =
{
    file = true,
    packet = false,
    limit = 100,
}
```

Valida de nuevo la configuración. Ahora el resumen muestra cuántas reglas se han cargado:

```bash
snort -c /usr/local/etc/snort/snort.lua
```

```output
--------------------------------------------------
rule counts
       total rules loaded: 4000+
               text rules: 4000+
            option chains: 4000+
            chain headers: 300+
--------------------------------------------------
...
Snort successfully validated the configuration (with 0 warnings).
```

## Paso 8: Ejecutar Snort como servicio de systemd

Para que Snort arranque con el sistema y no se ejecute como root, crea un usuario de sistema sin shell y el directorio de logs:

```bash
sudo useradd --system --no-create-home --shell /usr/sbin/nologin snort
sudo mkdir -p /var/log/snort
sudo chown snort:snort /var/log/snort
sudo chmod 750 /var/log/snort
```

Crea la unidad de systemd:

```bash
sudo nano /etc/systemd/system/snort3.service
```

```ini
[Unit]
Description=Snort 3 NIDS
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
ExecStartPre=-/usr/sbin/ethtool -K eth0 gro off lro off
ExecStart=/usr/local/bin/snort -c /usr/local/etc/snort/snort.lua -i eth0 -s 65535 -k none -l /var/log/snort -u snort -g snort -m 0x1b
Restart=on-failure

[Install]
WantedBy=multi-user.target
```

Cambia `eth0` por tu interfaz en las dos líneas. Snort arranca como root para abrir la interfaz y después cede privilegios al usuario `snort` (`-u` y `-g`); `-l` indica el directorio de logs y el guion en `ExecStartPre` hace que systemd ignore el error si la interfaz no admite alguno de los cambios de `ethtool`.

Arranca y habilita el servicio:

```bash
sudo systemctl daemon-reload
sudo systemctl enable --now snort3
sudo systemctl status snort3 --no-pager
```

```output
● snort3.service - Snort 3 NIDS
     Loaded: loaded (/etc/systemd/system/snort3.service; enabled; preset: enabled)
     Active: active (running) since ...
```

Haz de nuevo `ping` desde otra máquina y comprueba que las alertas se escriben en el archivo:

```bash
sudo tail -n 5 /var/log/snort/alert_fast.txt
```

```output
09/25-10:52:30.118203 [**] [1:1000001:1] "ICMP detectado hacia el servidor" [**] [Priority: 0] {ICMP} 198.51.100.7 -> 203.0.113.25
```

Una vez comprobado que funciona, puedes borrar o comentar la regla ICMP de `local.rules` para no llenar el log con cada `ping`, y reiniciar el servicio con `sudo systemctl restart snort3`.

## Solución de problemas

**`FATAL: ... can't load snort3-community.rules` o error de sintaxis en una regla**: la salida indica el archivo y la línea. Comprueba las rutas del bloque `ips` y ejecuta `snort -c /usr/local/etc/snort/snort.lua` hasta que valide sin errores antes de reiniciar el servicio.

**El servicio falla con `Can't start DAQ` o `permission denied` en la interfaz**: revisa `journalctl -u snort3 -n 50`. Suele ser un nombre de interfaz incorrecto en la unidad. Comprueba el tuyo con `ip -br address`.

**`snort: error while loading shared libraries: libdaq.so.3`**: no se ejecutó `sudo ldconfig` tras instalar LibDAQ. Ejecútalo y vuelve a probar.

## Conclusión

Has compilado Snort 3 y LibDAQ en Ubuntu 24.04, has configurado tu red en `snort.lua`, has probado la detección con una regla propia, has cargado las reglas comunitarias y has dejado Snort como servicio de systemd con alertas en `/var/log/snort/alert_fast.txt`. Como siguientes pasos, regístrate en snort.org para obtener un *oinkcode* y descargar el conjunto de reglas Registered con PulledPork 3, cambia a la salida `alert_json` para enviar las alertas a un SIEM y, cuando tengas las reglas afinadas, prueba el modo IPS en línea con el módulo NFQ en un entorno de pruebas.