---
title: "Cómo instalar Suricata IDS en Ubuntu 24.04 con ET Open"
description: "Instala Suricata en Ubuntu 24.04 con el PPA oficial, configura AF_PACKET y HOME_NET, carga las reglas ET Open con suricata-update y analiza alertas en EVE JSON."
category: "Seguridad de Red Avanzada"
language: es
source: https://cubepath.com/es/docs/seguridad-de-red-avanzada/instalacion-de-suricata-ids-ips
updated: 2026-09-25
---

# Cómo instalar Suricata IDS en Ubuntu 24.04 con ET Open

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:

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

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

```bash
sudo apt update
sudo apt install suricata jq
```

Comprueba la versión instalada:

```bash
suricata --build-info | head -n 1
```

```output
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:

```bash
suricata-update --version
```

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

Detén el servicio mientras lo configuras:

```bash
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:

```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 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:

```bash
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:

```bash
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:

```yaml
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:

```yaml
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:

```yaml
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:

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

```output
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:

```bash
sudo suricata-update
```

```output
...
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:

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

La última línea debe ser similar a:

```output
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:

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

```output
● 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:

```bash
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`:

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

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

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

```output
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:

```bash
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
```

```output
{"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:

```bash
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:

```bash
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:

```bash
sudo systemctl edit suricata
```

Escribe entre los comentarios indicados:

```ini
[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:

```bash
sudo nano /etc/suricata/disable.conf
```

```text
# 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:

```bash
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):

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

```ini
[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"
```

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

```ini
[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:

```bash
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.