Suricata es un motor de detección de intrusiones de red (IDS) de código abierto mantenido por la OISF. Inspecciona el tráfico que atraviesa una interfaz, lo compara con miles de firmas y registra alertas, además de metadatos de protocolos como HTTP, DNS y TLS. En este tutorial instalarás Suricata en Ubuntu 24.04 desde el PPA oficial, lo configurarás en modo IDS con AF_PACKET, cargarás el conjunto de reglas gratuito ET Open con suricata-update, comprobarás la detección con una alerta de prueba y automatizarás la actualización diaria de reglas.

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. Con el conjunto ET Open cargado, Suricata usa entre 1 y 2 GB de memoria.
  • Unos 10 GB libres en disco para logs, que crecen según el tráfico.

En esta guía Suricata funciona en modo IDS: observa una copia del tráfico y genera alertas, pero no bloquea nada. Es el modo seguro para empezar, porque un error de configuración no puede cortar tu acceso SSH.

Paso 1: Instalar Suricata desde el PPA oficial

El repositorio de Ubuntu 24.04 incluye Suricata, pero en una versión que se queda atrás durante la vida de la distribución. La OISF mantiene un PPA con la última versión estable. Añádelo:

sudo add-apt-repository ppa:oisf/suricata-stable

Instala Suricata y jq, que usarás para leer los logs en JSON:

sudo apt update
sudo apt install suricata jq

Comprueba la versión instalada:

suricata --build-info | head -n 1

This is Suricata version 8.0.x RELEASE

El paquete del PPA incluye también suricata-update, la herramienta oficial de gestión de reglas. Compruébalo:

suricata-update --version

Si el comando no existe, instálalo con sudo apt install suricata-update.

Detén el servicio mientras lo configuras:

sudo systemctl stop suricata

Paso 2: Identificar la interfaz y la red a proteger

Suricata necesita saber qué interfaz escuchar y qué direcciones son "tuyas". Lista las interfaces y sus direcciones:

ip -br address

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 pública es eth0 y la IP del servidor es 203.0.113.25. En tu servidor el nombre puede ser distinto (por ejemplo ens18); anota el tuyo y usa tus direcciones en los siguientes pasos.

Muchas tarjetas de red virtuales agrupan paquetes antes de entregarlos al sistema (GRO/LRO), lo que hace que Suricata vea paquetes más grandes que los reales. Desactiva esa agrupación en la interfaz:

sudo ethtool -K eth0 gro off lro off

Si ethtool indica que no puede cambiar large-receive-offload, no pasa nada: esa interfaz no lo admite. Este cambio no sobrevive a un reinicio; en el paso 6 lo harás persistente.

Paso 3: Configurar suricata.yaml

La configuración principal está en /etc/suricata/suricata.yaml, un archivo largo en el que solo tienes que cambiar unas pocas secciones. Ábrelo:

sudo nano /etc/suricata/suricata.yaml

Primero define HOME_NET con las direcciones de tu servidor, dentro de vars y address-groups. Para un único VPS basta con su IPv4 y su IPv6:

vars:
  address-groups:
    HOME_NET: "[203.0.113.25/32,2001:db8::25/128]"

Deja EXTERNAL_NET como "!$HOME_NET", su valor por defecto. Si el servidor tiene también una red privada, añade su rango a HOME_NET.

Después busca la sección af-packet y pon el nombre de tu interfaz en la primera entrada:

af-packet:
  - interface: eth0
    cluster-id: 99
    cluster-type: cluster_flow
    defrag: yes

Por último, busca la salida eve-log dentro de outputs y activa community-id, un identificador de flujo estándar que permite correlacionar las alertas de Suricata con otras herramientas:

outputs:
  - eve-log:
      enabled: yes
      filetype: regular
      filename: eve.json
      community-id: true

No sustituyas la sección eve-log entera: solo cambia community-id de false a true y deja el resto de opciones como están.

El paquete del PPA incluye además el archivo /etc/default/suricata, que también define una interfaz. Comprueba que coincide con la tuya:

grep -E '^(IFACE|LISTENMODE)' /etc/default/suricata

LISTENMODE=af-packet
IFACE=eth0

Si IFACE tiene otro valor, edita el archivo y pon tu interfaz.

Paso 4: Descargar las reglas ET Open con suricata-update

Suricata no trae reglas activas de serie. suricata-update descarga por defecto el conjunto ET Open de Proofpoint, gratuito y con decenas de miles de firmas, y lo combina en un único archivo /var/lib/suricata/rules/suricata.rules, que es el que carga la configuración por defecto:

sudo suricata-update

...
Loaded 60000+ rules.
Disabled 14 rules.
Enabled 0 rules.
Modified 0 rules.
Dropped 0 rules.
Enabled 130 rules for flowbit dependencies.
Writing rules to /var/lib/suricata/rules/suricata.rules: total: 60000+; enabled: 45000+; added: 60000+; removed 0; modified: 0
Testing with suricata -T.
Done.

Antes de arrancar, valida la configuración completa junto con las reglas:

sudo suricata -T -c /etc/suricata/suricata.yaml -v

La última línea debe ser similar a:

Notice: suricata: Configuration provided was successfully loaded. Exiting.

Si aparece un error, el mensaje indica la línea del YAML o la regla que falla.

Paso 5: Arrancar Suricata y probar una alerta

Habilita y arranca el servicio:

sudo systemctl enable --now suricata
sudo systemctl status suricata --no-pager

● suricata.service - Suricata ...
     Loaded: loaded (/usr/lib/systemd/system/suricata.service; enabled; preset: enabled)
     Active: active (running) since ...

La carga de reglas tarda entre 20 y 60 segundos. Espera a que termine revisando el log del motor:

sudo tail -f /var/log/suricata/suricata.log

Cuando veas una línea con Engine started, pulsa Ctrl+C. Ahora genera tráfico que active una firma conocida. La página testmynids.org devuelve el texto de una salida de id con privilegios de root, que dispara la regla GPL ATTACK_RESPONSE id check returned root:

curl http://testmynids.org/uid/index.html

Comprueba la alerta en fast.log, el log de alertas en formato de una línea:

sudo grep 2100498 /var/log/suricata/fast.log

09/25/2026-10:32:11.482913  [**] [1:2100498:7] GPL ATTACK_RESPONSE id check returned root [**] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 198.51.100.50:80 -> 203.0.113.25:48212

Si la línea aparece, Suricata está viendo el tráfico de la interfaz y aplicando las reglas.

Paso 6: Analizar las alertas en EVE JSON

fast.log sirve para una comprobación rápida, pero el registro completo está en /var/log/suricata/eve.json: un evento JSON por línea con alertas, flujos y metadatos de HTTP, DNS, TLS y otros protocolos. Es el formato que consumen herramientas como Elastic, Graylog o Wazuh.

Muestra las últimas alertas con los campos más útiles:

sudo jq -c 'select(.event_type=="alert") | {timestamp, src_ip, dest_ip, sig: .alert.signature, sev: .alert.severity}' /var/log/suricata/eve.json | tail -n 5

{"timestamp":"2026-09-25T10:32:11.482913+0000","src_ip":"198.51.100.50","dest_ip":"203.0.113.25","sig":"GPL ATTACK_RESPONSE id check returned root","sev":2}

Para ver qué firmas saltan más a menudo, útil para detectar falsos positivos:

sudo jq -r 'select(.event_type=="alert") | .alert.signature' /var/log/suricata/eve.json | sort | uniq -c | sort -rn | head

También puedes consultar las peticiones DNS que hace el propio servidor, algo muy útil para detectar software que contacta con dominios inesperados:

sudo jq -r 'select(.event_type=="dns" and .dns.type=="request") | .dns.rrname' /var/log/suricata/eve.json | sort | uniq -c | sort -rn | head

El paquete incluye una configuración de logrotate en /etc/logrotate.d/suricata que rota estos archivos a diario.

Para que la desactivación de GRO/LRO del paso 2 sobreviva a los reinicios, añádela al servicio con un archivo drop-in:

sudo systemctl edit suricata

Escribe entre los comentarios indicados:

[Service]
ExecStartPre=-/usr/sbin/ethtool -K eth0 gro off lro off

El guion antes de la ruta hace que systemd ignore el error si la interfaz no admite alguno de los cambios.

Paso 7: Ajustar y actualizar las reglas automáticamente

Si una firma genera falsos positivos en tu entorno, desactívala por su SID en /etc/suricata/disable.conf, que suricata-update lee por defecto:

sudo nano /etc/suricata/disable.conf

# Ejemplo: desactivar una firma concreta por su SID
2100498

La siguiente ejecución de suricata-update la marcará como desactivada. Para ver otras fuentes de reglas disponibles, gratuitas o de pago:

sudo suricata-update update-sources
sudo suricata-update list-sources

ET Open publica actualizaciones a diario. Crea un servicio y un temporizador de systemd que descarguen las reglas y hagan que Suricata las recargue sin reiniciar (la señal USR2 recarga las reglas en caliente):

sudo nano /etc/systemd/system/suricata-update.service

[Unit]
Description=Update Suricata rules
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/bin/suricata-update --reload-command "/usr/bin/systemctl kill --signal=USR2 suricata"

sudo nano /etc/systemd/system/suricata-update.timer

[Unit]
Description=Daily Suricata rule update

[Timer]
OnCalendar=daily
RandomizedDelaySec=1h
Persistent=true

[Install]
WantedBy=timers.target

Activa el temporizador y lanza una ejecución de prueba:

sudo systemctl daemon-reload
sudo systemctl enable --now suricata-update.timer
sudo systemctl start suricata-update.service
journalctl -u suricata-update.service -n 5 --no-pager

En /var/log/suricata/suricata.log verás una línea indicando que las reglas se han recargado.

Solución de problemas

No aparece ninguna alerta en la prueba: comprueba que la interfaz de af-packet y la de /etc/default/suricata son la correcta con ip -br address, y que el motor ha terminado de arrancar (Engine started en suricata.log).

Muchos avisos SURICATA STREAM o invalid checksum: suelen deberse al offload de la tarjeta virtual. Asegúrate de haber desactivado GRO/LRO y deja checksum-checks: auto en la sección af-packet.

Suricata consume demasiada memoria: reduce el número de reglas desactivando categorías que no aplican a tu servidor en /etc/suricata/disable.conf (acepta también expresiones como group:emerging-games.rules) y vuelve a ejecutar suricata-update.

Conclusión

Has instalado Suricata en Ubuntu 24.04 en modo IDS, con AF_PACKET, reglas ET Open actualizadas a diario y alertas en EVE JSON que puedes consultar con jq. Como siguientes pasos, envía eve.json a un sistema centralizado como Elastic o Wazuh, escribe reglas propias en un archivo local y añádelo a rule-files, y, cuando conozcas bien tus falsos positivos, estudia el modo IPS en línea con NFQUEUE o AF_PACKET en una máquina de pruebas antes de llevarlo a producción.