Cómo instalar y configurar Suricata IDS junto con Elastic Stack en Ubuntu 22.04

Suricata es una herramienta de Monitorización de Red que examina y procesa cada paquete de tráfico de Internet que fluye a través de tu servidor. Puede generar eventos de registro, activar alertas y eliminar tráfico al detectar cualquier actividad sospechosa.

Puedes instalar Suricata en una sola máquina para supervisar su tráfico o desplegarla en un host de puerta de enlace para escanear todo el tráfico entrante y saliente de otros servidores conectados a ella. Puedes combinar Suricata con Elasticsearch, Kibana y Filebeat para crear una herramienta de Información de Seguridad y Gestión de Eventos (SIEM).

En este tutorial, instalarás Suricata IDS junto con ElasticStack en un servidor Ubuntu 22.04. Los distintos componentes de la pila son

• Elasticsearch para almacenar, indexar, correlacionar y buscar los eventos de seguridad del servidor.
• Kibana para mostrar los registros almacenados en Elasticsearch.
• Filebeat para analizar el archivo de registro eve.json de Suricata y enviar cada evento a Elasticsearch para su procesamiento.
• Suricata para escanear el tráfico de red en busca de eventos sospechosos y descartar los paquetes no válidos.

El tutorial se divide en dos partes, la primera tratará sobre la instalación y configuración de Suricata, y la segunda sobre la instalación y configuración de Elastic Stack.

Instalaremos Suricata y la pila Elastic en diferentes servidores para nuestro tutorial.

Requisitos previos

• Los servidores que alojen Elastic Stack y Suricata deben tener un mínimo de 4 GB de RAM y 2 núcleos de CPU.
• Los servidores deben poder comunicarse entre sí utilizando direcciones IP privadas.
• Los servidores deben ejecutar Ubuntu 22.04 con un usuario sudo no root.
• Si quieres acceder a los cuadros de mando de Kibana desde cualquier lugar, configura un dominio (kibana.example.com) que apunte al servidor donde se instalará Elasticsearch.
• Instala los paquetes esenciales en ambos servidores. Es posible que algunos de ellos ya estén instalados.

  $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
  

• Asegúrate de que todo está actualizado en ambos servidores.

  $ sudo apt update
  

PARTE 1

Paso 1 – Instalar Suricata

Para instalar Suricata, tienes que añadir el repositorio de paquetes de la Open Information Security Foundation (OISF) a tu servidor.

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

Instala Suricata.

$ sudo apt install suricata

Habilita el servicio Suricata.

$ sudo systemctl enable suricata

Antes de continuar, detén el servicio Suricata, ya que primero tenemos que configurarlo.

$ sudo systemctl stop suricata

Paso 2 – Configurar Suricata

Suricata almacena su configuración en el archivo /etc/suricata/suricata.yaml. El modo por defecto de Suricata es el Modo IDS (Sistema de Detección de Intrusos), en el que sólo se registra el tráfico y no se detiene. Si eres nuevo en Suricata, deberías dejar el modo sin cambios. Una vez que lo hayas configurado y hayas aprendido más, puedes activar el modo IPS (Sistema de Prevención de Intrusiones).

Activar ID de Comunidad

El campo ID de Comunidad facilita la correlación de datos entre registros generados por distintas herramientas de monitorización. Dado que utilizaremos Suricata con Elasticsearch, habilitar el ID de Comunidad puede ser útil.

Abre el archivo /etc/suricata/suricata.yaml para editarlo.

$ sudo nano /etc/suricata/suricata.yaml

Localiza la línea # Community Flow ID y establece el valor de la variable community-id en true.

. . .
      # Community Flow ID
      # Adds a 'community_id' field to EVE records. These are meant to give
      # records a predictable flow ID that can be used to match records to
      # output of other tools such as Zeek (Bro).
      #
      # Takes a 'seed' that needs to be same across sensors and tools
      # to make the id less predictable.

      # enable/disable the community id feature.
      community-id: true
. . .

Ahora, tus eventos llevarán un ID como 1:S+3BA2UmrHK0Pk+u3XH78GAFTtQ= que podrás utilizar para hacer coincidir conjuntos de datos entre distintas herramientas de monitorización.

Selecciona la interfaz de red

El archivo de configuración predeterminado de Suricata inspecciona el tráfico en el dispositivo/interfaz de red eth0. Si tu servidor utiliza una interfaz de red diferente, tendrás que actualizarla en la configuración.

Comprueba el nombre del dispositivo de tu interfaz de red utilizando el siguiente comando.

$ ip -p -j route show default

Recibirás una salida como la siguiente.

[ {
        "dst": "default",
        "gateway": "95.179.184.1",
        "dev": "enp1s0",
        "protocol": "dhcp",
        "prefsrc": "95.179.185.42",
        "metric": 100,
        "flags": [ ]
    } ]

La variable dev se refiere al dispositivo de red. En nuestra salida, aparece enp1s0 como dispositivo de red. Tu salida puede ser diferente dependiendo de tu sistema.

Ahora que sabes el nombre de tu dispositivo, abre el archivo de configuración.

$ sudo nano /etc/suricata/suricata.yaml

Busca la línea af-packet: alrededor de la línea número 580. Bajo ella, establece el valor de la variable interface al nombre del dispositivo de tu sistema.

# Linux high speed capture support
af-packet:
  - interface: enp1s0
    # Number of receive threads. "auto" uses the number of cores
    #threads: auto
    # Default clusterid. AF_PACKET will load balance packets based on flow.
    cluster-id: 99
. . .

Si quieres añadir interfaces adicionales, puedes hacerlo añadiéndolas al final de la sección af-packet, alrededor de la línea 650.

Para añadir una nueva interfaz, insértala justo encima de la sección - interface: default, como se muestra a continuación.

    #  For eBPF and XDP setup including bypass, filter and load balancing, please
    #  see doc/userguide/capture-hardware/ebpf-xdp.rst for more info.

  - interface: enp0s1
    cluster-id: 98
...
  - interface: default
    #threads: auto
    #use-mmap: no
    #tpacket-v3: yes

En nuestro ejemplo hemos añadido una nueva interfaz enp0s1 y un valor único para la variable cluster-id. Debes incluir un identificador de clúster único con cada interfaz que añadas.

Busca la línea pcap: y, debajo de ella, establece el valor de la variable interface en el nombre del dispositivo de tu sistema.

# Cross platform libpcap capture support
pcap:
  - interface: enp1s0
    # On Linux, pcap will try to use mmap'ed capture and will use "buffer-size"
    # as total memory used by the ring. So set this to something bigger
    # than 1% of your bandwidth.

Para añadir una nueva interfaz igual que antes, insértala justo encima de la sección - interface: default, como se muestra a continuación.

- interface: enp0s1
# Put default values here
  - interface: default
    #checksum-checks: auto

Cuando hayas terminado, guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Paso 3 – Configurar las reglas de Suricata

Suricata, por defecto, sólo utiliza un conjunto limitado de reglas para detectar el tráfico de red. Puedes añadir más conjuntos de reglas de proveedores externos utilizando una herramienta llamada suricata-update. Ejecuta el siguiente comando para incluir reglas adicionales.

$ sudo suricata-update
25/2/2023 -- 06:48:14 - <Info> -- Using data-directory /var/lib/suricata.
25/2/2023 -- 06:48:14 - <Info> -- Using Suricata configuration /etc/suricata/suricata.yaml
25/2/2023 -- 06:48:14 - <Info> -- Using /etc/suricata/rules for Suricata provided rules.
.....
25/2/2023 -- 06:48:14 - <Info> -- No sources configured, will use Emerging Threats Open
25/2/2023 -- 06:48:14 - <Info> -- Fetching https://rules.emergingthreats.net/open/suricata-6.0.10/emerging.rules.tar.gz.
 100% - 3744681/3744681
.....
25/2/2023 -- 06:48:19 - <Info> -- Writing rules to /var/lib/suricata/rules/suricata.rules: total: 41022; enabled: 33278; added: 41022; removed 0; modified: 0
25/2/2023 -- 06:48:19 - <Info> -- Writing /var/lib/suricata/rules/classification.config
25/2/2023 -- 06:48:19 - <Info> -- Testing with suricata -T.
25/2/2023 -- 06:48:41 - <Info> -- Done.

Añadir proveedores de conjuntos de reglas

Puedes ampliar las reglas de Suricata añadiendo más proveedores. Puede obtener reglas de diversos proveedores gratuitos y comerciales.

Puedes listar la lista de proveedores por defecto utilizando el siguiente comando.

$ sudo suricata-update list-sources

Por ejemplo, si quieres incluir el conjunto de reglas tgreen/hunting, puedes activarlo con el siguiente comando.

$ sudo suricata-update enable-source tgreen/hunting

Ejecuta de nuevo el comando suricata-update para descargar y actualizar las nuevas reglas. Suricata, por defecto, puede procesar cualquier cambio en las reglas sin reiniciarse.

Paso 4 – Validar la configuración de Suricata

Suricata incluye una herramienta de validación para comprobar si hay errores en el archivo de configuración y en las reglas. Ejecuta el siguiente comando para ejecutar la herramienta de validación.

$ sudo suricata -T -c /etc/suricata/suricata.yaml -v
25/2/2023 -- 06:51:11 - <Info> - Running suricata under test mode
25/2/2023 -- 06:51:11 - <Notice> - This is Suricata version 6.0.10 RELEASE running in SYSTEM mode
25/2/2023 -- 06:51:11 - <Info> - CPUs/cores online: 2
25/2/2023 -- 06:51:11 - <Info> - fast output device (regular) initialized: fast.log
25/2/2023 -- 06:51:11 - <Info> - eve-log output device (regular) initialized: eve.json
25/2/2023 -- 06:51:11 - <Info> - stats output device (regular) initialized: stats.log
25/2/2023 -- 06:51:22 - <Info> - 1 rule files processed. 33519 rules successfully loaded, 0 rules failed
25/2/2023 -- 06:51:22 - <Info> - Threshold config parsed: 0 rule(s) found
25/2/2023 -- 06:51:22 - <Info> - 33522 signatures processed. 1189 are IP-only rules, 5315 are inspecting packet payload, 26814 inspect application layer, 108 are decoder event only
25/2/2023 -- 06:51:34 - <Notice> - Configuration provided was successfully loaded. Exiting.
25/2/2023 -- 06:51:34 - <Info> - cleaning up signature grouping structure... complete

La bandera -T indica a Suricata que se ejecute en modo de prueba, la bandera -c configura la ubicación del archivo de configuración y la bandera -v imprime la salida detallada del comando. Dependiendo de la configuración de tu sistema y del número de reglas añadidas, el comando puede tardar unos minutos en finalizar.

Paso 5 – Ejecutar Suricata

Ahora que Suricata está configurado e instalado, es el momento de ejecutar la aplicación.

$ sudo systemctl start suricata

Comprueba el estado del proceso.

$ sudo systemctl status suricata

Deberías ver la siguiente salida si todo funciona correctamente.

? suricata.service - LSB: Next Generation IDS/IPS
     Loaded: loaded (/etc/init.d/suricata; generated)
     Active: active (running) since Sat 2023-02-25 07:04:23 UTC; 5s ago
       Docs: man:systemd-sysv-generator(8)
    Process: 2701 ExecStart=/etc/init.d/suricata start (code=exited, status=0/SUCCESS)
      Tasks: 1 (limit: 4575)
     Memory: 190.6M
        CPU: 5.528s
     CGroup: /system.slice/suricata.service
             ??2710 /usr/bin/suricata -c /etc/suricata/suricata.yaml --pidfile /var/run/suricata.pid --af-packet -D -vvv

Feb 25 07:04:23 kibana systemd[1]: Starting LSB: Next Generation IDS/IPS...
Feb 25 07:04:23 kibana suricata[2701]: Starting suricata in IDS (af-packet) mode... done.
Feb 25 07:04:23 kibana systemd[1]: Started LSB: Next Generation IDS/IPS.

El proceso puede tardar unos minutos en terminar de analizar todas las reglas. Por lo tanto, la comprobación de estado anterior no es una indicación completa de si Suricata está funcionando y listo. Para ello, puedes controlar el archivo de registro mediante el siguiente comando.

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

Si ves la siguiente línea en el archivo de registro, significa que Suricata se está ejecutando y está lista para supervisar el tráfico de la red.

25/2/2023 -- 07:04:44 - <Info> - All AFP capture threads are running.

Paso 6 – Probar las reglas de Suricata

Comprobaremos si Suricata detecta algún tráfico sospechoso. La guía de Suricata recomienda probar la regla ET Open número 2100498 utilizando el siguiente comando.

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

Obtendrás la siguiente respuesta.

uid=0(root) gid=0(root) groups=0(root)

El comando anterior simula devolver la salida del comando id que se puede ejecutar en un sistema comprometido. Para comprobar si Suricata detectó el tráfico, debes comprobar el archivo de registro utilizando el número de regla especificado.

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

Si tu solicitud utilizó IPv6, deberías ver la siguiente salida.

02/25/2023-07:06:09.513208  [**] [1:2100498:7] GPL ATTACK_RESPONSE id check returned root [**] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 2600:9000:2250:3200:0018:30b3:e400:93a1:80 -> 2001:19f0:5001:225f:5400:04ff:fe52:2ca2:36770

Si tu solicitud utilizó IPv4, deberías ver la siguiente salida.

02/19/2023-10:13:17.872335  [**] [1:2100498:7] GPL ATTACK_RESPONSE id check returned root [**] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 108.158.221.5:80 -> 95.179.185.42:36364

Suricata también registra eventos en el archivo /var/log/suricata/eve.log utilizando el formato JSON. Para leer e interpretar esas reglas, necesitas instalar jq, lo cual queda fuera del alcance de este tutorial.

PARTE 2

Hemos terminado con la primera parte del tutorial, en la que instalamos Suricata y lo probamos. La siguiente parte consiste en instalar la pila ELK y configurarla para visualizar Suricata y sus registros. La segunda parte del tutorial debe realizarse en el segundo servidor, a menos que se especifique lo contrario.

Paso 7 – Instalar Elasticsearch y Kibana

El primer paso para instalar Elasticsearch consiste en añadir la clave GPG de Elastic a tu servidor.

$ wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg

Crea un repositorio para el paquete Elasticsearch creando el archivo /etc/apt/sources.list.d/elastic-7.x.list.

$ echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-7.x.list

Actualiza la lista de repositorios de tu sistema.

$ sudo apt update

Instala Elasticsearch y Kibana.

$ sudo apt install elasticsearch kibana

Localiza la dirección IP privada de tu servidor utilizando el siguiente comando.

$ ip -brief address show
lo               UNKNOWN        127.0.0.1/8 ::1/128 
enp1s0           UP             78.141.220.30/23 metric 100 2001:19f0:5001:b35:5400:4ff:fe52:2ca3/64 fe80::5400:4ff:fe52:2ca3/64 
enp6s0           UP             10.7.96.4/20 fe80::5800:4ff:fe52:2ca3/64

Anota la IP privada de tu servidor (10.7.96.4 en este caso). Nos referiremos a ella como your_private_IP. La dirección IP pública del servidor (78.141.220.30) la denominaremos your_public_IP en el resto del tutorial. Anota también el nombre de red de tu servidor, enp6s0.

Paso 8 – Configurar Elasticsearch

Elasticsearch almacena su configuración en el archivo /etc/elasticsearch/elasticsearch.yml. Abre el archivo para editarlo.

$ sudo nano /etc/elasticsearch/elasticsearch.yml

Por defecto, Elasticsearch sólo acepta conexiones locales. Tenemos que cambiarlo para que Kibana pueda acceder a él a través de la dirección IP privada.

Busca la línea #network.host: 192.168.0.1 y añade la siguiente línea justo debajo, como se muestra a continuación.

# By default Elasticsearch is only accessible on localhost. Set a different
# address here to expose this node on the network:
#
#network.host: 192.168.0.1
network.bind_host: ["127.0.0.1", "your_private_IP"]
#
# By default Elasticsearch listens for HTTP traffic on the first free port it
# finds starting at 9200. Set a specific HTTP port here:

Esto garantizará que Elastic pueda seguir aceptando conexiones locales y, al mismo tiempo, esté disponible para Kibana a través de la dirección IP privada.

El siguiente paso es activar algunas funciones de seguridad y asegurarnos de que Elastic está configurado para ejecutarse en un único nodo. Para ello, añade las siguientes líneas al final del archivo.

. . .
discovery.type: single-node
xpack.security.enabled: true

Si vas a utilizar varios nodos de búsqueda Elastic, puedes omitir la primera línea.

Cuando hayas terminado, guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Configurar el Cortafuegos

Añade las reglas de cortafuegos adecuadas para Elasticsearch, de forma que sea accesible a través de la red privada.

$ sudo ufw allow in on enp6s0
$ sudo ufw allow out on enp6s0

Asegúrate de elegir el nombre de la interfaz en el primer comando como el que obtuviste en el paso 7.

Inicia Elasticsearch

Recarga el demonio de servicio.

$ sudo systemctl daemon-reload

Habilita el servicio Elasticsearch.

$ sudo systemctl enable elasticsearch

Ahora que ya has configurado Elasticsearch, es el momento de iniciar el servicio.

$ sudo systemctl start elasticsearch

Crea contraseñas para Elasticsearch

Tras habilitar la configuración de seguridad de Elasticsearch, el siguiente paso es generar algunas contraseñas para el usuario por defecto. Elasticsearch incluye una utilidad de creación de contraseñas en /usr/share/elasticsearch/bin/elasticsearch-setup-passwords que puede generar contraseñas aleatorias.

Crea las contraseñas.

$ cd /usr/share/elasticsearch/bin
$ sudo ./elasticsearch-setup-passwords auto

Obtendrás un resultado como el siguiente. Pulsa y para continuar cuando se te solicite.

Initiating the setup of passwords for reserved users elastic,apm_system,kibana,kibana_system,logstash_system,beats_system,remote_monitoring_user.
The passwords will be randomly generated and printed to the console.
Please confirm that you would like to continue [y/N]y


Changed password for user apm_system
PASSWORD apm_system = y5uilzBu8akwRChvXFEq

Changed password for user kibana_system
PASSWORD kibana_system = nEeGIo9YJysUITU0ywLO

Changed password for user kibana
PASSWORD kibana = nEeGIo9YJysUITU0ywLO

Changed password for user logstash_system
PASSWORD logstash_system = VmumYBdNAwjsjwql6F5j

Changed password for user beats_system
PASSWORD beats_system = NZJxIPySwsNwPwCD2rsy

Changed password for user remote_monitoring_user
PASSWORD remote_monitoring_user = c2GafzJIueAxZEAAC6tZ

Changed password for user elastic
PASSWORD elastic = l4r7CyCHPw5p4c43RfA1

Sólo puedes ejecutar la utilidad una vez, así que guarda todas las contraseñas en un lugar seguro.

Paso 9 – Configurar Kibana

El primer paso para configurar Kibana es activar la función de seguridad xpack generando claves secretas. Kibana utiliza estas claves secretas para almacenar datos en Elasticsearch. Se puede acceder a la utilidad para generar claves secretas desde el directorio /usr/share/kibana/bin.

$ cd /usr/share/kibana/bin/
$ sudo ./kibana-encryption-keys generate -q --force

La bandera -q suprime las instrucciones del comando, y la bandera --force asegura que se generen secretos frescos. Recibirás una salida como la siguiente.

xpack.encryptedSavedObjects.encryptionKey: 20cabb5381ad09aeb6cccd1136c8138f
xpack.reporting.encryptionKey: d5293c386d14479f72bb2f6f6f984ad9
xpack.security.encryptionKey: 9cda918cc718fb58f022423b97e3171a

Copia la salida. Abre el archivo de configuración de Kibana en /etc/kibana/kibana.yml para editarlo.

$ sudo nano /etc/kibana/kibana.yml

Pega el código del comando anterior al final del archivo.

. . .

# Specifies locale to be used for all localizable strings, dates and number formats.
# Supported languages are the following: English - en , by default , Chinese - zh-CN .
#i18n.locale: "en"

xpack.encryptedSavedObjects.encryptionKey: 0f4e5e1cf8fad1874ffed0faac6be0da
xpack.reporting.encryptionKey: d435c78a4e37521e539c0e905420c9f5
xpack.security.encryptionKey: 7ba0e2a02747bb90fb0f9a3c267b99ed

Configurar el puerto de Kibana

Es necesario configurar Kibana para que sea accesible en la dirección IP privada del servidor. Busca la línea #server.host: "localhost" en el archivo y añade la siguiente línea justo debajo, como se muestra.

# Kibana is served by a back end server. This setting specifies the port to use.
#server.port: 5601

# Specifies the address to which the Kibana server will bind. IP addresses and host names are both valid values.
# The default is 'localhost', which usually means remote machines will not be able to connect.
# To allow connections from remote users, set this parameter to a non-loopback address.
#server.host: "localhost"
server.host: "your_private_IP"

Cuando hayas terminado, guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Configurar el acceso a Kibana

El siguiente paso es crear un nombre de usuario y una contraseña que Kibana pueda utilizar para la autenticación. Puedes hacerlo editando directamente el archivo de configuración de Kibana, pero puede causar un problema de seguridad. El método seguro implica el uso de la aplicación kibana-keystore.

Ejecuta los siguientes comandos para establecer un nombre de usuario. Introduce kibana_system como nombre de usuario.

$ cd /usr/share/kibana/bin
$ sudo ./kibana-keystore add elasticsearch.username
Enter value for elasticsearch.username: *************

Ejecuta de nuevo el comando para establecer la contraseña. Asegúrate de utilizar la contraseña que creaste para Kibana en el paso 8. Para nuestro tutorial, la contraseña es dTanR7Q2HtgDtATRvuJv.

$ sudo ./kibana-keystore add elasticsearch.password
Enter value for elasticsearch.password: ********************

Iniciar Kibana

Ahora que has configurado el acceso seguro y la red para Kibana, inicia y habilita el proceso.

$ sudo systemctl enable kibana --now

Comprueba el estado para ver si se está ejecutando.

$ sudo systemctl status kibana
? kibana.service - Kibana
     Loaded: loaded (/etc/systemd/system/kibana.service; enabled; vendor preset: enabled)
     Active: active (running) since Sat 2023-02-25 07:24:37 UTC; 6s ago
       Docs: https://www.elastic.co
   Main PID: 3884 (node)
      Tasks: 11 (limit: 4575)
     Memory: 181.8M
        CPU: 6.700s
     CGroup: /system.slice/kibana.service
             ??3884 /usr/share/kibana/bin/../node/bin/node /usr/share/kibana/bin/../src/cli/dist --logging.dest=/var/log/kibana/kibana.log --pid.file=/run/kibana/kibana.pid "--deprecation.skip_de>
Feb 25 07:24:37 elasticsearch systemd[1]: Started Kibana.

Paso 10 – Instalar y configurar Filebeat

Es importante tener en cuenta que instalaremos Filebeat en el servidor Suricata. Así que vuelve a él y añade la clave GPG elástica para empezar.

$ wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg

Crea el repositorio elástico.

$ echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-7.x.list

Actualiza la lista de repositorios del sistema.

$ sudo apt update

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Instala Filebeat.

$ sudo apt install filebeat

Filebeat almacena su configuración en el archivo /etc/filebeat/filebeat.yml. Ábrelo para editarlo.

$ sudo nano /etc/filebeat/filebeat.yml

Lo primero que tienes que hacer es conectarlo al panel de control de Kibana. Busca la línea #host: "localhost:5601" en la sección Kibana y añade la siguiente línea justo debajo, como se muestra.

. . .
# Starting with Beats version 6.0.0, the dashboards are loaded via the Kibana API.
# This requires a Kibana endpoint configuration.
setup.kibana:

  # Kibana Host
  # Scheme and port can be left out and will be set to the default (http and 5601)
  # In case you specify and additional path, the scheme is required: http://localhost:5601/path
  # IPv6 addresses should always be defined as: https://[2001:db8::1]:5601
  #host: "localhost:5601"
  host: "your_private_IP:5601"

. . .

A continuación, busca la sección Elasticsearch Output del archivo y edita los valores de hosts, username y password como se muestra a continuación. Para el nombre de usuario, elige elastic como valor, y para la contraseña, utiliza el valor generado en el paso 8 de este tutorial.

output.elasticsearch:
  # Array of hosts to connect to.
  hosts: ["your_private_IP:9200"]

  # Protocol - either `http` (default) or `https`.
  #protocol: "https"

  # Authentication credentials - either API key or username/password.
  #api_key: "id:api_key"
  username: "elastic"
  password: "bd1YJfhSa8RC8SMvTIwg"

. . .

Cuando hayas terminado, guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

A continuación, activa el módulo Suricata integrado en Filebeat.

$ sudo filebeat modules enable suricata

El último paso para configurar Filebeat es cargar los cuadros de mando y las canalizaciones SIEM en Elasticsearch mediante el comando filebeat setup.

$ sudo filebeat setup

El comando puede tardar unos minutos en finalizar. Una vez finalizado, deberías recibir la siguiente salida.

Overwriting ILM policy is disabled. Set `setup.ilm.overwrite: true` for enabling.

Index setup finished.
Loading dashboards (Kibana must be running and reachable)
Loaded dashboards
Setting up ML using setup --machine-learning is going to be removed in 8.0.0. Please use the ML app instead.
See more: https://www.elastic.co/guide/en/machine-learning/current/index.html
It is not possble to load ML jobs into an Elasticsearch 8.0.0 or newer using the Beat.
Loaded machine learning job configurations
Loaded Ingest pipelines

Inicia el servicio Filebeat.

$ sudo systemctl start filebeat

Comprueba el estado del servicio.

$ sudo systemctl status filebeat

Paso 11 – Acceder al panel de control de Kibana

Dado que KIbana está configurado para acceder únicamente a Elasticsearch a través de su dirección IP privada, tienes dos opciones para acceder a él. El primer método es utilizar un túnel SSH al servidor de Elastic search desde tu PC. Esto reenviará el puerto 5601 desde tu PC a la dirección IP privada del servidor, y podrás acceder a Kibana desde tu PC en http://localhost:5601. Pero este método significa que no podrás acceder a él desde ningún otro lugar.

La otra opción es instalar Nginx en tu servidor Suricata y utilizarlo como proxy inverso para acceder al servidor de Elasticsearch a través de su dirección IP privada. Hablaremos de ambas formas. Puedes elegir cualquiera de ellas en función de tus necesidades.

Usando el Túnel Local SSH

Si utilizas Windows 10 o Windows 11, puedes ejecutar el SSH LocalTunnel desde tu Windows Powershell. En Linux o macOS, puedes utilizar el terminal. Probablemente necesitarás configurar el acceso SSH si aún no lo has hecho.

Ejecuta el siguiente comando en el terminal de tu ordenador para crear el Túnel SSH.

$ ssh -L 5601:your_private_IP:5601 navjot@your_public_IP -N

• La bandera -L se refiere al Túnel SSH local, que reenvía el tráfico desde el puerto de tu PC al servidor.
• El private_IP:5601 es la dirección IP a la que se reenvía tu tráfico en el servidor. En este caso, sustitúyela por la dirección IP privada de tu servidor Elasticsearch.
• El your_public_IP es la dirección IP pública del servidor Elasticsearch, que se utiliza para abrir una conexión SSH.
• La bandera -N indica a OpenSSH que no ejecute ningún comando, sino que mantenga viva la conexión mientras se ejecute el túnel.

Ahora que el túnel está abierto, puedes acceder a Kibana abriendo la URL http://localhost:5601 en el navegador de tu PC. Obtendrás la siguiente pantalla.

Tendrás que mantener el comando en ejecución mientras necesites acceder a Kibana. Pulsa Ctrl + C en tu terminal para cerrar el túnel.

Utilizar el proxy inverso Nginx

Este método es el más adecuado si quieres acceder al panel de control desde cualquier parte del mundo.

Configurar el cortafuegos

Antes de continuar, necesitas abrir los puertos HTTP y HTTPS en el cortafuegos.

$ sudo ufw allow http
$ sudo ufw allow https

Instalar Nginx

Ubuntu 22.04 viene con una versión antigua de Nginx. Para instalar la última versión, necesitas descargar el repositorio oficial de Nginx.

Importa la clave de firma de Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Añade el repositorio de la versión estable de Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Actualiza los repositorios del sistema.

$ sudo apt update

Instala Nginx.

$ sudo apt install nginx

Verifica la instalación.

$ nginx -v
nginx version: nginx/1.22.1

Iniciar el servidor Nginx.

$ sudo systemctl start nginx

Instalar y configurar SSL

El primer paso es instalar el certificado SSL Let’s Encrypt. Necesitamos instalar Certbot para generar el certificado SSL. Puedes instalar Certbot utilizando el repositorio de Ubuntu o descargar la última versión utilizando la herramienta Snapd. Nosotros utilizaremos la versión Snapd.

Ubuntu 22.04 viene con Snapd instalado por defecto. Ejecuta los siguientes comandos para asegurarte de que tu versión de Snapd está actualizada.

$ sudo snap install core && sudo snap refresh core

Instala Certbot.

$ sudo snap install --classic certbot

Utiliza el siguiente comando para asegurarte de que se puede ejecutar el comando Certbot creando un enlace simbólico al directorio /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Genera el certificado SSL para el dominio kibana.example.com.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d kibana.example.com

El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/kibana.example.com de tu servidor.

Genera un certificado de grupo Diffie-Hellman.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Para comprobar si la renovación SSL funciona correctamente, realiza una ejecución en seco del proceso.

$ sudo certbot renew --dry-run

Si no ves ningún error, ya está todo listo. Tu certificado se renovará automáticamente.

Configurar Nginx

Crea y abre el archivo de configuración de Nginx para Kibana.

$ sudo nano /etc/nginx/conf.d/kibana.conf

Pega en él el siguiente código. Sustituye la dirección IP por la dirección IP privada de tu servidor Elasticsearch.

server {
        listen 80; listen [::]:80;
        server_name kibana.example.com;
        return 301 https://$host$request_uri;
}

server {
        server_name kibana.example.com;
        charset utf-8;

        listen 443 ssl http2;
        listen [::]:443 ssl http2;

        access_log /var/log/nginx/kibana.access.log;
        error_log /var/log/nginx/kibana.error.log;

        ssl_certificate /etc/letsencrypt/live/kibana.example.com/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/kibana.example.com/privkey.pem;
        ssl_trusted_certificate /etc/letsencrypt/live/kibana.example.com/chain.pem;
        ssl_session_timeout 1d;
        ssl_session_cache shared:MozSSL:10m;
        ssl_session_tickets off;

        ssl_protocols TLSv1.2 TLSv1.3;
        ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
		
		resolver 8.8.8.8;

        ssl_stapling on;
        ssl_stapling_verify on;
        ssl_dhparam /etc/ssl/certs/dhparam.pem;
 
        location / {
                proxy_pass http://your_private_IP:5601;
                proxy_set_header Host $host;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header X-Forwarded-Proto $scheme;
        }
}

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Abre el archivo /etc/nginx/nginx.conf para editarlo.

$ sudo nano /etc/nginx/nginx.conf

Añade la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Verifica la configuración.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Reinicia el servicio Nginx.

$ sudo systemctl restart nginx

Tu panel de control de Kibana debería ser accesible a través de la URL https://kibana.example.com desde cualquier lugar que desees.

Paso 12 – Gestión de los paneles de control de Kibana

Antes de continuar con la gestión de los cuadros de mando, tienes que añadir el campo URL base en la configuración de Kibana.

Abre el archivo de configuración de Kibana.

$ sudo nano /etc/kibana/kibana.yml

Busca la línea comentada #server.publicBaseUrl: "" y cámbiala como se indica a continuación, eliminando la almohadilla que aparece delante de ella.

server.publicBaseUrl: "https://kibana.example.com"

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Reinicia el servicio Kibana.

$ sudo systemctl restart kibana

Espera unos minutos y carga la URL https://kibana.example.com en tu navegador. Accede con el nombre de usuario elastic y la contraseña que generaste antes (bd1YJfhSa8RC8SMvTIwg) y obtendrás la siguiente pantalla.

Escribe type:data suricata en el cuadro de búsqueda de la parte superior para localizar la información de Suricata.

Haz clic en el primer resultado ([Filebeat Suricata] Resumen de alertas), y obtendrás una pantalla similar a la siguiente. Por defecto, sólo muestra las entradas de los últimos 15 minutos, pero nosotros la mostramos en un intervalo de tiempo mayor para mostrar más datos para el tutorial.

Haz clic en el botón Eventos para ver todos los eventos registrados.

Al desplazarte hacia abajo en las páginas de eventos y alertas, puedes identificar cada evento y alerta por el tipo de protocolo, los puertos de origen y destino, y la dirección IP de origen. También puedes ver los países desde los que se originó el tráfico.

Puedes utilizar Kibana y Filebeat para acceder y generar otros tipos de cuadros de mando. Uno de los cuadros de mando incorporados que puedes utilizar es el de Seguridad. Haz clic en el panel Red del menú hamburguesa de la izquierda, y obtendrás la siguiente pantalla.

Puedes añadir más paneles, como el de Nginx, activando y configurando los módulos Filebeat incorporados.

Conclusión

Con esto concluye el tutorial para instalar y configurar Suricata IDS con Elastic Stack en un servidor Ubuntu 22.04. También has configurado Nginx como proxy inverso para acceder externamente a los paneles de control de Kibana. Si tienes alguna pregunta, publícala en los comentarios a continuación.