Detectar anomalías en Suricata

Introducción

En este laboratorio, aprenderá a detectar anomalías de red utilizando Suricata, un potente motor de detección de amenazas de código abierto. Explorará características clave, como la configuración de reglas, el monitoreo del tráfico y el análisis de alertas, para identificar posibles amenazas de seguridad.

Los ejercicios prácticos lo guiarán a través de la configuración de Suricata, la creación de reglas básicas y la inspección en tiempo real del tráfico. Obtendrá experiencia práctica en la detección de actividades sospechosas, como solicitudes de ping ICMP, y en la personalización de reglas para escenarios de amenazas específicos.

Skills Graph

Instalar Suricata

En este paso, instalará Suricata, un motor de detección de amenazas de red de código abierto. Suricata actúa como una cámara de seguridad para su red, analizando constantemente el tráfico para identificar posibles amenazas. Puede realizar tres funciones clave: detección de intrusiones en tiempo real (IDS, por sus siglas en inglés) para monitorear ataques, prevención de intrusiones en línea (IPS, por sus siglas en inglés) para bloquear tráfico malicioso y monitoreo de seguridad de red para registrar toda la actividad.

Comencemos el proceso de instalación paso a paso:

Primero, necesitamos actualizar la lista de paquetes. Esto asegura que su sistema conozca las últimas versiones de software disponibles antes de instalar cualquier cosa:
```
sudo apt update
```
El comando sudo le otorga privilegios de administrador, mientras que apt update actualiza la lista de paquetes disponibles en su sistema.
Ahora instalaremos Suricata junto con todos sus componentes necesarios (dependencias). La bandera -y confirma automáticamente la instalación:
```
sudo apt install -y suricata
```
Este comando descarga e instala el paquete de software Suricata desde los repositorios oficiales de Ubuntu.
Después de la instalación, verifiquemos que todo haya funcionado correctamente comprobando la versión instalada:
```
suricata -V
```
Debería ver una salida similar a:
```
This is Suricata version 6.0.3 RELEASE
```
La bandera -V le indica a Suricata que muestre su información de versión. Ver esta salida confirma que la instalación fue exitosa.
El comportamiento de Suricata está controlado por un archivo de configuración. Veamos si este archivo importante existe en su ubicación predeterminada:
```
ls /etc/suricata/suricata.yaml
```
El directorio /etc/suricata/ es donde Linux suele almacenar los archivos de configuración para aplicaciones de todo el sistema.
Finalmente, Suricata necesita reglas para saber qué buscar en el tráfico de red. Estas reglas son como un conjunto de instrucciones que le indican a Suricata qué constituye una actividad sospechosa. Las reglas predeterminadas se almacenan en:
```
ls /var/lib/suricata/rules
```
El directorio /var/lib/suricata/rules contiene los archivos de reglas que vienen con la instalación de Suricata. Trabajaremos con estas reglas más adelante en el laboratorio.

Configurar reglas básicas

En este paso, configurará reglas básicas de detección para Suricata. Las reglas son el componente central que le indican a Suricata qué buscar en el tráfico de red. Piénselas como un conjunto de instrucciones que definen patrones sospechosos o amenazas conocidas.

Primero, navegue hasta el directorio de reglas de Suricata donde se almacenan todos los archivos de reglas:
```
cd /var/lib/suricata/rules
```
Aquí es donde Suricata guarda sus archivos de reglas predeterminados y personalizados. La ubicación del directorio se especifica en la configuración de Suricata.
Enumere los archivos de reglas existentes para ver lo que ya está disponible:
```
ls
```
Debería ver varios archivos .rules como suricata.rules. Estos archivos contienen diferentes categorías de reglas que Suricata utiliza para la detección.
Examinemos la estructura de una regla básica. Abra el archivo principal de reglas utilizando el editor nano:
```
sudo nano suricata.rules
```
El editor nano es un editor de texto simple que usaremos para modificar las reglas. Verá muchas reglas existentes con estructuras similares.
Agregue una regla simple para detectar solicitudes de ping ICMP (agregue esto al final del archivo):
```
alert icmp any any -> any any (msg:"ICMP Ping Detected"; itype:8; sid:1000001; rev:1;)
```
Analicemos lo que hace esta regla:
- alert: Le indica a Suricata que genere una alerta cuando se produzca una coincidencia.
- icmp: Se aplica al tráfico del protocolo ICMP.
- any any -> any any: Coincide con cualquier dirección IP/puerto de origen a cualquier dirección IP/puerto de destino.
- msg: El mensaje de alerta que aparecerá en los registros.
- itype:8: Coincide específicamente con el tipo 8 de ICMP (solicitudes de ping).
- sid: Identificador único de la regla (1000001+ para reglas personalizadas).
- rev: Número de revisión de la regla.
Guarde el archivo (Ctrl+O, Enter, Ctrl+X en nano). Esto almacena permanentemente su nueva regla.
Verifique que la sintaxis de la regla sea correcta antes de aplicarla:
```
sudo suricata -T -c /etc/suricata/suricata.yaml -v
```
La bandera -T prueba la configuración. Debería ver una salida que termine con:
```
Configuration provided was successfully loaded. Exiting.
```
Esto confirma que su regla está correctamente formateada.
Reinicie Suricata para cargar las nuevas reglas y comenzar a monitorear:
```
sudo pkill suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0
```
El primer comando detiene cualquier instancia de Suricata en ejecución, mientras que el segundo la inicia de nuevo con sus nuevas reglas, monitoreando la interfaz eth0.

Monitorear tráfico en vivo

En este paso, observaremos cómo Suricata monitorea el tráfico de red en tiempo real y genera alertas basadas en las reglas que configuramos anteriormente. Esta es la funcionalidad central de cualquier sistema de detección de intrusiones (IDS, por sus siglas en inglés): observar los paquetes de red y marcar la actividad sospechosa.

Primero, necesitamos iniciar Suricata en modo de captura en vivo. Los siguientes comandos detendrán cualquier instancia de Suricata en ejecución (si existe) y luego iniciarán una nueva que monitoree la interfaz eth0:
```
sudo pkill suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0
```
La bandera -c especifica nuestro archivo de configuración, mientras que -i le indica a Suricata qué interfaz de red monitorear.
Ahora generemos algunos tráficos de prueba que deberían activar nuestra regla ICMP del paso anterior. Abra una nueva terminal y ejecute:
```
ping -c 3 8.8.8.8
```
Esto envía 3 paquetes de ping ICMP al servidor DNS de Google (8.8.8.8). Dado que creamos una regla para detectar tráfico ICMP, Suricata debería registrar esta actividad.
Suricata escribe las alertas en /var/log/suricata/fast.log. Para ver estas alertas en tiempo real, use:
```
sudo tail -f /var/log/suricata/fast.log
```
El comando tail -f muestra continuamente las nuevas líneas agregadas al archivo. Debería ver una salida similar a:
```
01/01/2023-12:34:56.123456  [**] [1:1000001:1] ICMP Ping Detected [**] [Classification: (null)] [Priority: 3] {ICMP} 192.168.1.1 -> 8.8.8.8
```
Esto muestra la marca de tiempo, el ID de la regla (1:1000001:1), el mensaje de alerta y las direcciones IP de origen/destino.
Para un registro más detallado en formato JSON, podemos examinar el archivo eve.json. El siguiente comando filtra y muestra solo los eventos de alerta de manera legible:
```
sudo tail -f /var/log/suricata/eve.json | jq '. | select(.event_type == "alert")'
```
La herramienta jq ayuda a analizar y formatear la salida JSON, haciéndola más fácil de leer.
Para ver estadísticas sobre el tráfico que Suricata está procesando, incluyendo cuántas alertas se generaron:
```
sudo suricatasc -c stats
```
Busque contadores como detect.alert en la salida; esto muestra cuántas veces nuestras reglas activaron alertas.
Cuando termine de observar el tráfico, presione Ctrl+C en cualquier ventana de terminal donde esté monitoreando los registros para detener la salida continua.

Revisar las alertas generadas

En este paso, analizará las alertas generadas por Suricata durante la sesión de monitoreo anterior. Esto ayuda a entender qué patrones de tráfico activaron sus reglas. Cuando se trabaja con sistemas de detección de intrusiones, revisar las alertas es crucial para identificar posibles amenazas de seguridad y ajustar sus reglas de detección.

Primero, verifique el registro básico de alertas:
```
sudo cat /var/log/suricata/fast.log
```
Este comando muestra las alertas con marca de tiempo en un formato simple y legible por humanos. El archivo fast.log es el archivo de salida de alertas predeterminado de Suricata. Busque entradas que contengan "ICMP Ping Detected"; estas indican solicitudes de ping que coincidieron con su regla de detección.
Para un análisis más detallado, examine el registro JSON estructurado:
```
sudo cat /var/log/suricata/eve.json | jq '. | select(.event_type == "alert")'
```
El archivo eve.json contiene registros completos legibles por máquina en formato JSON. Usamos jq para filtrar solo los eventos de alerta. Esto proporciona información detallada, incluyendo:
- Direcciones IP de origen y destino
- Marcas de tiempo precisas
- Detalles completos de la regla
- Información de la carga útil del paquete (cuando está configurado)
Para contar cuántas veces se activó cada alerta:
```
sudo grep -o "ICMP Ping Detected" /var/log/suricata/fast.log | wc -l
```
Esta tubería primero extrae todas las ocurrencias de "ICMP Ping Detected" usando grep -o, luego las cuenta con wc -l. Esto ayuda a cuantificar con qué frecuencia se produce este evento.
Para un resumen de los tipos de alertas:
```
sudo jq -r '.alert.signature' /var/log/suricata/eve.json | sort | uniq -c
```
Este comando extrae todas las firmas de alerta (nombres de reglas), las ordena alfabéticamente y luego cuenta las ocurrencias únicas. Le da una visión general de qué reglas se activan con mayor frecuencia.
Para ver las alertas con información de la dirección IP de origen:
```
sudo jq -r 'select(.event_type == "alert") | [.timestamp, .src_ip, .alert.signature] | @tsv' /var/log/suricata/eve.json
```
Esta consulta avanzada de jq crea una salida separada por tabulaciones que muestra la marca de tiempo, la dirección IP de origen y la firma de alerta para cada evento. El formato @tsv facilita la importación a hojas de cálculo.
Para ver las últimas 5 alertas:
```
sudo tail -n 5 /var/log/suricata/fast.log
```
El comando tail muestra las últimas líneas de un archivo. Esto es útil para verificar rápidamente la actividad reciente sin tener que desplazarse por todo el registro.

Agregar una regla personalizada

En este paso, aprenderá cómo crear y probar su propia regla de Suricata para detectar patrones específicos en el tráfico de red. Nos centraremos en detectar solicitudes HTTP a un dominio de prueba (example.com) como un ejemplo práctico. Las reglas personalizadas le permiten extender las capacidades de detección de Suricata más allá de su conjunto de reglas predeterminado.

Primero, navegue al directorio de reglas donde Suricata almacena sus reglas de detección:
```
cd /var/lib/suricata/rules
```
Aquí es donde normalmente se almacenan todos los archivos de reglas de Suricata. Agregaremos nuestras reglas personalizadas aquí para mantenerlas organizadas con las reglas existentes.
Cree un nuevo archivo de reglas específicamente para sus reglas personalizadas:
```
sudo nano custom.rules
```
Es necesario usar sudo porque el directorio de reglas requiere privilegios de administrador para modificarse. Estamos nombrando el archivo custom.rules para distinguirlo claramente de los archivos de reglas predeterminados de Suricata.
Agregue la siguiente regla para detectar solicitudes HTTP a example.com:
```
alert http any any -> any any (msg:"HTTP Request to example.com"; flow:to_server; http.host; content:"example.com"; nocase; sid:1000002; rev:1;)
```
Analicemos lo que hace esta regla:
- alert http: Activa una alerta para el tráfico HTTP
- any any -> any any: Se aplica al tráfico desde cualquier puerto de origen a cualquier puerto de destino
- msg: Proporciona un mensaje de alerta legible por humanos
- flow:to_server: Solo coincide con el tráfico dirigido a servidores
- http.host: Examina el encabezado HTTP Host
- content:"example.com": Busca este dominio específico
- nocase: Hace que la coincidencia sea insensible a mayúsculas y minúsculas
- sid:1000002: Da a la regla un ID único (por encima de 1.000.000 para reglas personalizadas)
- rev:1: Indica que esta es la primera versión de la regla
Guarde el archivo en el editor nano presionando Ctrl+O (escribir), luego Enter para confirmar y Ctrl+X para salir.
Ahora necesitamos decirle a Suricata que cargue nuestro nuevo archivo de reglas. Edite la configuración principal:
```
sudo nano /etc/suricata/suricata.yaml
```
Encuentre la sección rule-files: (generalmente alrededor de la línea 50 - 60) y agregue:
```
- custom.rules
```
Esta adición asegura que Suricata cargará nuestras reglas personalizadas cuando se inicie.
Antes de aplicar los cambios, verifique que la sintaxis de la regla sea correcta:
```
sudo suricata -T -c /etc/suricata/suricata.yaml -v
```
La bandera -T le dice a Suricata que pruebe la configuración sin ejecutarse realmente. Esto ayuda a detectar cualquier error de sintaxis en sus reglas antes de que se utilicen.
Reinicie Suricata para cargar la nueva regla:
```
sudo pkill suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0
```
El primer comando detiene cualquier instancia de Suricata en ejecución, mientras que el segundo la inicia de nuevo con nuestra configuración actualizada.
Para probar si nuestra regla funciona, genere algún tráfico HTTP a example.com:
```
curl http://example.com
```
Este comando realiza una solicitud HTTP simple que debería activar nuestra nueva regla.
Finalmente, verifique si Suricata detectó el tráfico viendo las últimas alertas:
```
sudo tail -n 5 /var/log/suricata/fast.log
```
Debería ver una alerta que coincida con el mensaje de nuestra regla personalizada sobre solicitudes HTTP a example.com. Si no es así, revise cada paso y verifique la sintaxis de la regla.

Resumen

En este laboratorio, has aprendido cómo instalar y configurar Suricata, un motor de detección de amenazas de red de código abierto. El proceso incluyó actualizar paquetes, instalar dependencias y verificar la instalación comprobando el archivo de configuración y el directorio de reglas.

También has explorado la creación de reglas de detección personalizadas agregando una regla para solicitudes de ping ICMP, comprendiendo su estructura y componentes. Finalmente, has verificado la sintaxis de la regla para garantizar que Suricata pueda monitorear eficazmente el tráfico de red y generar alertas para anomalías.