Cómo instalar y configurar Suricata IDS junto con Elastic Stack en Rocky Linux 9

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 Gestión de Información y Eventos de Seguridad (SIEM).

En este tutorial, instalarás Suricata IDS y ElasticStack en un servidor Rocky Linux 9. Los distintos componentes de la pila son

• Elasticsearch para almacenar, indexar, correlacionar y buscar los eventos de seguridad del servidor.
• Kibana para visualizar 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 analiza el tráfico de red en busca de eventos sospechosos y elimina los paquetes no válidos.

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

Para nuestro tutorial, instalaremos Suricata y la pila Elastic en diferentes servidores.

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 utilizando direcciones IP privadas.
• Los servidores deben ejecutar Rocky Linux 9 con un usuario sudo no root.
• Los servidores deben estar actualizados.

  $ sudo dnf update
  

• 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á Suricata.
• Instala los paquetes esenciales en ambos servidores.

  $ sudo dnf install yum-utils nano curl wget policycoreutils-python-utils -y
  

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 dnf install 'dnf-command(copr)'
$ sudo dnf copr enable @oisf/suricata-7.0

El primer comando habilita los proyectos comunitarios (copr) para el instalador de paquetes dnf. El segundo comando permite añadir el repositorio OISF a tu sistema. suricata-7.0 Habilita el repositorio para acceder a la última versión estable del software. Pulsa y y ENTER cada vez que se te solicite.

A continuación, añade el repositorio EPEL.

$ sudo dnf install -y epel-release dnf-plugins-core

Instala Suricata.

$ sudo dnf install -y suricata

Habilita el servicio Suricata.

$ sudo systemctl enable 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. Como 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
. . .

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

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.

Seleccionar 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": "172.31.1.1",
        "dev": "eth0",
        "protocol": "dhcp",
        "prefsrc": "65.108.61.177",
        "metric": 100,
        "flags": [ ]
    } ]

La variable dev se refiere al dispositivo de red. En nuestra salida, aparece eth0 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: eth0
    # 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: eth0
    # 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.

Recarga de la regla en vivo

Necesitas reiniciar Suricata cada vez que añadas, elimines y edites sus reglas. Sin embargo, no necesitas hacer nada para activarla, ya que está activada por defecto.

Con la recarga en vivo activada, puedes utilizar el siguiente comando para recargar reglas sin reiniciar el proceso de Suricata.

$ sudo kill -usr2 $(pidof suricata)

La bandera $(pidof suricata) localiza el ID del proceso Suricata. La parte -usr2 del comando kill envía una señal SIGUSR2 al proceso Suricata. La señal SIGUSR2 se configura con Suricata para recargar las reglas.

Configurar los permisos del directorio

Suricata creó automáticamente un usuario del sistema y un grupo llamado suricata durante el proceso de instalación. Necesitas dar los permisos de directorio adecuados para que la instalación funcione correctamente.

Ejecuta el siguiente comando para establecer suricata como grupo para los directorios de Suricata.

$ sudo chgrp -R suricata /etc/suricata
$ sudo chgrp -R suricata /var/lib/suricata
$ sudo chgrp -R suricata /var/log/suricata 

Establece los permisos del grupo para lectura y escritura.

$ sudo chmod -R g+r /etc/suricata/
$ sudo chmod -R g+rw /var/lib/suricata
$ sudo chmod -R g+rw /var/log/suricata

Añadir el usuario actual al grupo Suricata

Suricata creó automáticamente un usuario del sistema y un grupo llamado suricata durante el proceso de instalación. Añade tu usuario actual al grupo suricata para que puedas realizar operaciones directamente sin necesidad de sudo.

$ sudo usermod -a -G suricata $USER

Para aplicar la nueva pertenencia al grupo, sal del servidor y vuelve a entrar, o escribe lo siguiente:

$ su - ${USER}

Se te pedirá que introduzcas la contraseña de tu usuario para continuar.

Confirma que tu usuario está ahora añadido al grupo suricata escribiendo:

$ id -nG
username wheel suricata

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.

$ suricata-update
14/4/2024 -- 01:32:58 - <Info> -- Using data-directory /var/lib/suricata.
14/4/2024 -- 01:32:58 - <Info> -- Using Suricata configuration /etc/suricata/suricata.yaml
14/4/2024 -- 01:32:58 - <Info> -- Using /usr/share/suricata/rules for Suricata provided rules.
14/4/2024 -- 01:32:58 - <Info> -- Found Suricata version 7.0.4 at /usr/sbin/suricata.
.....
14/4/2024 -- 01:32:58 - <Info> -- No sources configured, will use Emerging Threats Open
14/4/2024 -- 01:32:58 - <Info> -- Fetching https://rules.emergingthreats.net/open/suricata-7.0.4/emerging.rules.tar.gz.
 100% - 4243799/4243799               
14/4/2024 -- 01:33:00 - <Info> -- Done.
14/4/2024 -- 01:33:00 - <Info> -- Loading distribution rule file /usr/share/suricata/rules/app-layer-events.rules
.....
14/4/2024 -- 01:33:04 - <Info> -- Writing rules to /var/lib/suricata/rules/suricata.rules: total: 48646; enabled: 37144; added: 48646; removed 0; modified: 0
14/4/2024 -- 01:33:04 - <Info> -- Writing /var/lib/suricata/rules/classification.config
14/4/2024 -- 01:33:04 - <Info> -- Testing with suricata -T.
14/4/2024 -- 01:33: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.

$ suricata-update list-sources

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

$ suricata-update enable-source tgreen/hunting
14/4/2024 -- 01:37:07 - <Info> -- Using data-directory /var/lib/suricata.
14/4/2024 -- 01:37:07 - <Info> -- Using Suricata configuration /etc/suricata/suricata.yaml
14/4/2024 -- 01:37:07 - <Info> -- Using /usr/share/suricata/rules for Suricata provided rules.
14/4/2024 -- 01:37:07 - <Info> -- Found Suricata version 7.0.4 at /usr/sbin/suricata.
14/4/2024 -- 01:37:07 - <Warning> -- Source index does not exist, will use bundled one.
14/4/2024 -- 01:37:07 - <Warning> -- Please run suricata-update update-sources.
14/4/2024 -- 01:37:07 - <Info> -- Creating directory /var/lib/suricata/update/sources
14/4/2024 -- 01:37:07 - <Info> -- Enabling default source et/open
14/4/2024 -- 01:37:07 - <Info> -- Source tgreen/hunting enabled

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.

$ suricata -T -c /etc/suricata/suricata.yaml -v
Notice: suricata: This is Suricata version 7.0.4 RELEASE running in SYSTEM mode
Info: cpu: CPUs/cores online: 2
Info: suricata: Running suricata under test mode
Info: suricata: Setting engine mode to IDS mode by default
Info: exception-policy: master exception-policy set to: auto
Info: logopenfile: fast output device (regular) initialized: fast.log
Info: logopenfile: eve-log output device (regular) initialized: eve.json
Info: logopenfile: stats output device (regular) initialized: stats.log
Info: detect: 1 rule files processed. 37144 rules successfully loaded, 0 rules failed, 0
Info: threshold-config: Threshold config parsed: 0 rule(s) found
Info: detect: 37147 signatures processed. 1194 are IP-only rules, 4892 are inspecting packet payload, 30849 inspect application layer, 108 are decoder event only
Notice: suricata: Configuration provided was successfully loaded. Exiting.

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 - Suricata Intrusion Detection Service
     Loaded: loaded (/usr/lib/systemd/system/suricata.service; enabled; preset: disabled)
     Active: active (running) since Sun 2024-04-14 01:45:43 UTC; 4s ago
       Docs: man:suricata(1)
    Process: 6081 ExecStartPre=/bin/rm -f /var/run/suricata.pid (code=exited, status=0/SUCCESS)
   Main PID: 6082 (Suricata-Main)
      Tasks: 1 (limit: 22569)
     Memory: 111.8M
        CPU: 4.318s
     CGroup: /system.slice/suricata.service
             ??6082 /sbin/suricata -c /etc/suricata/suricata.yaml --pidfile /var/run/suricata.pid -i eth0 --user suricata

Apr 14 01:45:43 suricata systemd[1]: Starting Suricata Intrusion Detection Service...
Apr 14 01:45:43 suricata systemd[1]: Started Suricata Intrusion Detection Service.
Apr 14 01:45:43 suricata suricata[6082]: i: suricata: This is Suricata version 7.0.4 RELEASE running in SYSTEM mode

Es posible que veas los siguientes errores en el estado del servicio.

Apr 15 02:20:13 suricata suricata[5554]: E: logopenfile: Error opening file: "/var/log/suricata//fast.log": Permission denied
Apr 15 02:20:13 suricata suricata[5554]: W: runmodes: output module "fast": setup failed
Apr 15 02:20:13 suricata suricata[5554]: E: logopenfile: Error opening file: "/var/log/suricata//eve.json": Permission denied
Apr 15 02:20:13 suricata suricata[5554]: W: runmodes: output module "eve-log": setup failed
Apr 15 02:20:13 suricata suricata[5554]: E: logopenfile: Error opening file: "/var/log/suricata//stats.log": Permission denied
Apr 15 02:20:13 suricata suricata[5554]: W: runmodes: output module "stats": setup failed

Tendrás que volver a configurar los permisos.

$ sudo chown -R suricata:suricata /var/log/suricata

Reinicia el servicio Suricata.

$ sudo systemctl restart suricata

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 las siguientes líneas, significa que Suricata se está ejecutando y está listo para supervisar el tráfico de la red.

[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: exception-policy: master exception-policy set to: auto
[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: ioctl: eth0: MTU 1500
[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: privs: dropped the caps for main thread
[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: conf: Running in live mode, activating unix socket
[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: logopenfile: fast output device (regular) initialized: fast.log
[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: logopenfile: eve-log output device (regular) initialized: eve.json
[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: logopenfile: stats output device (regular) initialized: stats.log
[5577 - Suricata-Main] 2024-04-15 02:23:03 Info: detect: 1 rule files processed. 37144 rules successfully loaded, 0 rules failed, 0
[5577 - Suricata-Main] 2024-04-15 02:23:03 Info: threshold-config: Threshold config parsed: 0 rule(s) found
[5577 - Suricata-Main] 2024-04-15 02:23:04 Info: detect: 37147 signatures processed. 1194 are IP-only rules, 4892 are inspecting packet payload, 30849 inspect application layer, 108 are decoder event only
[5577 - Suricata-Main] 2024-04-15 02:23:32 Info: runmodes: eth0: creating 2 threads
[5577 - Suricata-Main] 2024-04-15 02:23:32 Info: unix-manager: unix socket '/var/run/suricata/suricata-command.socket'
[5577 - Suricata-Main] 2024-04-15 02:23:32 Notice: threads: Threads created -> W: 2 FM: 1 FR: 1   Engine started.

Pulsa Ctrl + C para salir de la salida.

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/22/2022-23:24:33.997371  [**] [1:2100498:7] GPL ATTACK_RESPONSE id check returned root [**] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 2600:9000:2204:5c00:0018:30b3:e400:93a1:80 -> 2a03:b0c0:0002:00d0:0000:0000:0fc2:b001:41468

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

02/22/2022-23:21:46.783476  [**] [1:2100498:7] GPL ATTACK_RESPONSE id check returned root [**] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 204.246.178.81:80 -> 164.90.192.1: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.

$ sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

Crea un repositorio para el paquete Elasticsearch creando y abriendo el archivo /etc/yum/yum.repos.d/elasticsearch.repo para editarlo.

$ sudo nano /etc/yum.repos.d/elasticsearch.repo

Pega en él el siguiente código.

[elasticsearch]
name=Elasticsearch repository for 8.x packages
baseurl=https://artifacts.elastic.co/packages/8.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=0
autorefresh=1
type=rpm-md

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

Instala Elasticsearch y Kibana.

$ sudo dnf install --enablerepo=elasticsearch elasticsearch kibana

Necesitas utilizar la bandera --enablerepo=elasticsearch cada vez, ya que hemos mantenido el repositorio desactivado por defecto. Esto evita la actualización accidental de estos paquetes.

Obtendrás la siguiente salida en la instalación de Elasticsearch.

--------------------------- Security autoconfiguration information ------------------------------

Authentication and authorization are enabled.
TLS for the transport and HTTP layers is enabled and configured.

The generated password for the elastic built-in superuser is : ilc+Gju=gZTxQHI4cSkF

If this node should join an existing cluster, you can reconfigure this with
'/usr/share/elasticsearch/bin/elasticsearch-reconfigure-node --enrollment-token <token-here>'
after creating an enrollment token on your existing cluster.

You can complete the following actions at any time:

Reset the password of the elastic built-in superuser with 
'/usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic'.

Generate an enrollment token for Kibana instances with 
 '/usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana'.

Generate an enrollment token for Elasticsearch nodes with 
'/usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s node'.

-------------------------------------------------------------------------------------------------

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 
eth0             UP             37.27.84.123/32 2a01:4f9:c012:db02::1/64 fe80::9400:3ff:fe34:d589/64 
eth1             UP             10.0.0.2/32 fe80::8400:ff:fe84:5baf/64

Anota la IP privada de tu servidor ( 10.0.0.2 en este caso). Nos referiremos a ella como your_private_IP. A la dirección IP pública del servidor ( 37.27.84.123) nos referiremos como your_public_IP en el resto del tutorial. Anota también el nombre de red de tu servidor, eth1.

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

Si vas a utilizar varios nodos de búsqueda de Elastic, puedes omitirla.

Además, comenta la siguiente línea añadiendo una almohadilla (#) delante de ella.

#cluster.initial_master_nodes: ["elastic"]

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

Configurar el tamaño del montón de la JVM

Antes de iniciar Elasticsearch, necesitamos configurar la memoria utilizada por Elasticsearch. Crea y abre el archivo /etc/elasticsearch/jvm.options.d/jvm-heap.options para editarlo.

$ sudo nano /etc/elasticsearch/jvm.options.d/jvm-heap.options

Pega las siguientes líneas en él.

-Xms3g
-Xmx3g

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida. Aquí, estamos dando a Elasticsearch 3GB de espacio. Elige el valor en función del tamaño de tu servidor.

Configura el Cortafuegos

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

$ sudo firewall-cmd --permanent --zone=internal --change-interface=eth1
$ sudo firewall-cmd --permanent --zone=internal --add-service=elasticsearch
$ sudo firewall-cmd --permanent --zone=internal --add-service=kibana
$ sudo firewall-cmd --permanent --add-port=5601/tcp
$ sudo firewall-cmd --reload

Asegúrate de elegir el nombre de la interfaz en el primer comando como el que obtuviste en el paso 7. Los comandos anteriores cambian la zona por defecto del Cortafuegos a interna y abren los puertos 9200, y 9300 para Elasticsearch, y el puerto 5601 para Kibana.

Inicia Elasticsearch

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

Recarga el demonio del sistema.

$ sudo systemctl daemon-reload

Habilita e Inicia el servidor Elasticsearch.

$ sudo systemctl enable elasticsearch --now

Comprueba el estado del servicio.

$ sudo systemctl status elasticsearch
? elasticsearch.service - Elasticsearch
     Loaded: loaded (/usr/lib/systemd/system/elasticsearch.service; enabled; preset: disabled)
     Active: active (running) since Sun 2024-04-14 03:51:12 UTC; 1min 20s ago
       Docs: https://www.elastic.co
   Main PID: 5987 (java)
      Tasks: 74 (limit: 22569)
     Memory: 3.4G
        CPU: 50.532s
     CGroup: /system.slice/elasticsearch.service

Crear contraseñas de Elasticsearch

Tras habilitar la configuración de seguridad de Elasticsearch, el siguiente paso es generar la contraseña para el superusuario de Elasticsearch. La contraseña por defecto se proporcionó durante la instalación y puedes utilizarla, pero se recomienda modificarla.

Ejecuta el siguiente comando para restablecer la contraseña de Elasticsearch. Elige una contraseña fuerte.

$ sudo /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic -i
This tool will reset the password of the [elastic] user.
You will be prompted to enter the password.
Please confirm that you would like to continue [y/N]y


Enter password for [elastic]: <ENTER-PASSWORD>
Re-enter password for [elastic]: <CONFIRM-PASSWORD>
Password for the [elastic] user successfully reset.

Ahora, probemos si Elasticsearch responde a las consultas.

$ sudo curl --cacert /etc/elasticsearch/certs/http_ca.crt -u elastic https://localhost:9200
Enter host password for user 'elastic':
{
  "name" : "elastic",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "VSP7LEZURF6SR8I1BPF9RQ",
  "version" : {
    "number" : "8.13.2",
    "build_flavor" : "default",
    "build_type" : "rpm",
    "build_hash" : "16cc90cd2d08a3147ce02b07e50894bc060a4cbf",
    "build_date" : "2024-04-05T14:45:26.420424304Z",
    "build_snapshot" : false,
    "lucene_version" : "9.10.0",
    "minimum_wire_compatibility_version" : "7.17.0",
    "minimum_index_compatibility_version" : "7.0.0"
  },
  "tagline" : "You Know, for Search"
}

Esto confirma que Elasticsearch es totalmente funcional y funciona sin problemas.

Paso 9 – Configurar Kibana

El primer paso para configurar Kibana es copiar el certificado de Elasticsearch al directorio de Kibana.

$ sudo cp /etc/elasticsearch/certs/http_ca.crt /etc/kibana/

A continuación, activa la función de seguridad xpack generando claves secretas. Kibana utiliza estas claves secretas para almacenar datos en Elasticsearch. Puedes acceder a la utilidad para generar claves secretas desde el directorio /usr/share/kibana/bin.

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

La bandera -q suprime las instrucciones del comando. Recibirás una salida como la siguiente.

xpack.encryptedSavedObjects.encryptionKey: fdce3576894a0a7b12a639a40f643acd
xpack.reporting.encryptionKey: 92f426be0f487b7d8dd191b86443f2a6
xpack.security.encryptionKey: 34bf00781dbe85d1dcd99dc94ef1c9b7

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.

. . .

# Maximum number of documents loaded by each shard to generate autocomplete suggestions.
# This value must be a whole number greater than zero. Defaults to 100_000
#unifiedSearch.autocomplete.valueSuggestions.terminateAfter: 100000

xpack.encryptedSavedObjects.encryptionKey: fdce3576894a0a7b12a639a40f643acd
xpack.reporting.encryptionKey: 92f426be0f487b7d8dd191b86443f2a6
xpack.security.encryptionKey: 34bf00781dbe85d1dcd99dc94ef1c9b7

Configurar el host 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"

Desactiva la Telemetría

Kibana envía datos a sus servidores por defecto. Esto puede afectar al rendimiento y también es un riesgo para la privacidad. Por lo tanto, debes desactivar la Telemetría. Añade el siguiente código al final del archivo para desactivar la Telemetría. La primera configuración desactiva la Telemetría y la segunda deshabilita la sobrescritura de la primera configuración desde la sección Configuración Avanzada en Kibana.

telemetry.optIn: false
telemetry.allowChangingOptInStatus: false

Configurar SSL

Busca la variable elasticsearch.ssl.certificateAuthorities, descoméntala y cambia su valor como se muestra a continuación.

elasticsearch.ssl.certificateAuthorities: [ "/etc/kibana/http_ca.crt" ]

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

Configurar el acceso a Kibana

El siguiente paso es generar un token de acceso que utilizaremos más adelante para iniciar sesión en la interfaz web de Kibana.

$ sudo /usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana
eyJ2ZXIiOiI4LjEzLjIiLCJhZHIiOlsiMzcuMjcuODQuMTIzOjkyMDAiXSwiZmdyIjoiMmI2ZjhhOWRiOWJjMDU5NDk0NGE0OGFkMjMxODg2NzYxNTViZGViN2U5YjY4MmY3N2MzYmI3ZDk2Nzc3YjY0NyIsImtleSI6InppVU0zSTRCOE5lSHBLU3k2T0owOnBLNHJiWjBZVHYybWNTbmxrTXlqbncifQ==

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 (/usr/lib/systemd/system/kibana.service; enabled; preset: disabled)
     Active: active (running) since Sun 2024-04-14 04:25:54 UTC; 963ms ago
       Docs: https://www.elastic.co
   Main PID: 6464 (node)
      Tasks: 7 (limit: 22569)
     Memory: 48.2M
        CPU: 1.238s
     CGroup: /system.slice/kibana.service
             ??6464 /usr/share/kibana/bin/../node/bin/node /usr/share/kibana/bin/../src/cli/dist

Apr 14 04:25:54 elastic systemd[1]: Started Kibana.
.....

Paso 10 – 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 desde tu PC al servidor de Elasticsearch. 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 desde ningún otro sitio.

La 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, pero mantiene 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. Todos estos comandos deben ejecutarse en el servidor Elasticsearch.

Instalar Nginx

Rocky Linux 9 viene con una versión antigua de Nginx. Necesitas utilizar el repositorio oficial de Nginx para instalar la última versión.

Crea y abre el archivo /etc/yum.repos.d/nginx.repo para editarlo.

$ sudo nano /etc/yum.repos.d/nginx.repo

Pega en él el siguiente código.

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

Cuando hayas terminado, guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida. Utilizaremos la versión mainline de Nginx y, por tanto, hemos habilitado el repositorio mainline en el archivo anterior utilizando enabled=1 en la sección mainline en lugar de la estable. Puedes elegir cualquiera de las dos.

Instala Nginx.

$ sudo dnf install -y nginx

Verifica la instalación.

$ nginx -v
nginx version: nginx/1.25.4

Habilita e inicia el servicio del servidor Nginx.

$ sudo systemctl enable nginx --now

Configurar el cortafuegos

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

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https

Recarga el cortafuegos para activar los cambios.

$ sudo firewall-cmd --reload

Instalar y configurar SSL

El primer paso es instalar el certificado SSL Let’s Encrypt. Para ello, necesitamos instalar primero el repositorio EPEL.

$ sudo dnf install -y epel-release

Instala Certbot y el plugin de Nginx correspondiente.

$ sudo dnf install -y certbot python3-certbot-nginx

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

Activa e inicia el temporizador de renovación automática de Certbot.

$ sudo systemctl enable certbot-renew.timer
$ sudo systemctl start certbot-renew.timer

Visualiza la lista de Temporizadores.

$ sudo systemctl list-timers
NEXT                        LEFT         LAST                        PASSED    UNIT                         ACTIVATES
---------------------------------------------------------------------------------------------------------------------------------
Mon 2024-04-15 00:00:00 UTC 19min left   Sun 2024-04-14 08:20:34 UTC 15h ago   logrotate.timer              logrotate.service
Mon 2024-04-15 00:43:16 UTC 1h 2min left Sun 2024-04-14 09:01:33 UTC 14h ago   fstrim.timer                 fstrim.service
Mon 2024-04-15 00:44:47 UTC 1h 4min left Sun 2024-04-14 23:30:19 UTC 10min ago dnf-makecache.timer          dnf-makecache.service
Mon 2024-04-15 06:52:31 UTC 7h left      -                           -         certbot-renew.timer          certbot-renew.service

Realiza un simulacro del proceso para comprobar si la renovación SSL funciona correctamente.

$ 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;
  listen [::]:443 ssl;
  http2 on;
  http3 on;
  quic_retry on;


  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;
  ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
  ssl_prefer_server_ciphers off;

  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

Inicia el servicio Nginx.

$ sudo systemctl start nginx

A continuación, debes 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

Configura SELinux para habilitar Nginx

Aplica la política para permitir que se establezcan conexiones con hosts externos.

$ sudo setsebool -P httpd_can_network_connect 1

Finaliza la configuración de ElasticSearch con Kibana

Espera unos minutos y carga la URL https://kibana.example.com en tu navegador.

Aparecerá el campo del código de registro. Rellena el token de inscripción que generaste en el paso 9.

Haz clic en el botón Configurar Elastic para continuar. A continuación, se te pedirá el código de verificación.

Vuelve al terminal de Elasticsearch y ejecuta el siguiente comando para generar el código. Introduce este código en la página y haz clic en el botón Verificar para continuar.

$ sudo /usr/share/kibana/bin/kibana-verification-code
Your verification code is:  232 001

A continuación, espera a que se complete la configuración de Elastic. Tardará varios minutos.

A continuación, serás redirigido a la pantalla de inicio de sesión.

Paso 11 – 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.

$ sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

Crea y abre el repositorio elástico.

$ sudo nano /etc/yum.repos.d/elasticsearch.repo

Pega el siguiente código.

[elasticsearch]
name=Elasticsearch repository for 8.x packages
baseurl=https://artifacts.elastic.co/packages/8.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=0
autorefresh=1
type=rpm-md

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

Instala Filebeat.

$ sudo dnf install --enablerepo=elasticsearch filebeat

Antes de configurar Filebeat, tenemos que copiar el archivo http_ca.crt del servidor Elasticsearch al servidor Filebeat. Ejecuta el siguiente comando en el servidor Filebeat.

$ scp username@your_public_ip:/etc/elasticsearch/certs/http_ca.crt /etc/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"
  protocol: "http"
  ssl.enabled: true
  ssl.certificate_authorities: ["/etc/filebeat/http_ca.crt"]

. . .

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. Además, establece protocol como HTTPS.

output.elasticsearch:
  # Array of hosts to connect to.
  hosts: ["your_private_IP:9200"]
  
  # Performance preset - one of "balanced", "throughput", "scale",
  # "latency", or "custom".
  preset: balanced

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

  # Authentication credentials - either API key or username/password.
  #api_key: "id:api_key"
  username: "elastic"
  password: "<yourelasticpassword>"
  ssl.certificate_authorities: ["/etc/filebeat/http_ca.crt"]
  ssl.verification_mode: full

. . .

Añade la siguiente línea al final del archivo.

setup.ilm.overwrite: true

Cuando hayas terminado, guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida. Hay un paso más para asegurarnos de que Filebeat se conecta a Elasticsearch. Tenemos que pasar la información SSL de Elasticsearch a Filebeat para que pueda conectarse.

Prueba la conexión desde Filebeat al servidor Elasticsearch. Se te pedirá la contraseña de Elasticsearch.

$ sudo curl -v --cacert /etc/filebeat/http_ca.crt https://your_private_ip:9200 -u elastic

Obtendrás la siguiente salida.

Enter host password for user 'elastic':
*   Trying 10.0.0.2:9200...
* Connected to 10.0.0.2 (10.0.0.2) port 9200 (#0)
* ALPN, offering h2
* ALPN, offering http/1.1
*  CAfile: /etc/filebeat/http_ca.crt
* TLSv1.0 (OUT), TLS header, Certificate Status (22):
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
* TLSv1.2 (IN), TLS header, Certificate Status (22):
* TLSv1.3 (IN), TLS handshake, Server hello (2):
* TLSv1.2 (IN), TLS header, Finished (20):
* TLSv1.2 (IN), TLS header, Unknown (23):
* TLSv1.3 (IN), TLS handshake, Encrypted Extensions (8):
* TLSv1.3 (IN), TLS handshake, Certificate (11):
* TLSv1.3 (IN), TLS handshake, CERT verify (15):
* TLSv1.3 (IN), TLS handshake, Finished (20):
* TLSv1.2 (OUT), TLS header, Finished (20):
* TLSv1.3 (OUT), TLS change cipher, Change cipher spec (1):
* TLSv1.2 (OUT), TLS header, Unknown (23):
* TLSv1.3 (OUT), TLS handshake, Finished (20):
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384
* ALPN, server did not agree to a protocol
* Server certificate:
*  subject: CN=elastic
*  start date: Apr 14 08:37:21 2024 GMT
*  expire date: Apr 14 08:37:21 2026 GMT
*  subjectAltName: host "10.0.0.2" matched cert's IP address!
*  issuer: CN=Elasticsearch security auto-configuration HTTP CA
*  SSL certificate verify ok.
* Server auth using Basic with user 'elastic'
* TLSv1.2 (OUT), TLS header, Unknown (23):
> GET / HTTP/1.1
> Host: 10.0.0.2:9200
> Authorization: Basic ZWxhc3RpYzpsaWZlc3Vja3M2NjIwMDI=
> User-Agent: curl/7.76.1
> Accept: */*
> 
* TLSv1.2 (IN), TLS header, Unknown (23):
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
* TLSv1.2 (IN), TLS header, Unknown (23):
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< X-elastic-product: Elasticsearch
< content-type: application/json
< content-length: 532
< 
{
  "name" : "elastic",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "vnUn8l1bQ1qkF-VjCoiWmQ",
  "version" : {
    "number" : "8.13.2",
    "build_flavor" : "default",
    "build_type" : "rpm",
    "build_hash" : "16cc90cd2d08a3147ce02b07e50894bc060a4cbf",
    "build_date" : "2024-04-05T14:45:26.420424304Z",
    "build_snapshot" : false,
    "lucene_version" : "9.10.0",
    "minimum_wire_compatibility_version" : "7.17.0",
    "minimum_index_compatibility_version" : "7.0.0"
  },
  "tagline" : "You Know, for Search"
}
* Connection #0 to host 10.0.0.2 left intact

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

$ sudo filebeat modules enable suricata
Enabled suricata

Abre el archivo /etc/filebeat/modules.d/suricata.yml para editarlo.

$ sudo nano /etc/filebeat/modules.d/suricata.yml

Edita el archivo como se muestra a continuación. Debes cambiar el valor de la variable enabled por true. Además, descomenta la variable var.paths y establece su valor como se muestra.

# Module: suricata
# Docs: https://www.elastic.co/guide/en/beats/filebeat/8.10/filebeat-module-suricata.html

- module: suricata
  # All logs
  eve:
    enabled: true

    # Set custom paths for the log files. If left empty,
    # Filebeat will choose the paths depending on your OS.
    var.paths: ["/var/log/suricata/eve.json"]

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

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.

Index setup finished.
Loading dashboards (Kibana must be running and reachable)
Loaded dashboards
Loaded Ingest pipelines

Inicia y activa el servicio Filebeat.

$ sudo systemctl enable filebeat --now

Comprueba el estado del servicio.

$ sudo systemctl status filebeat
? filebeat.service - Filebeat sends log files to Logstash or directly to Elasticsearch.
     Loaded: loaded (/usr/lib/systemd/system/filebeat.service; enabled; preset: disabled)
     Active: active (running) since Sun 2024-04-14 10:12:51 UTC; 31s ago
       Docs: https://www.elastic.co/beats/filebeat
   Main PID: 7299 (filebeat)
      Tasks: 8 (limit: 22569)
     Memory: 407.2M
        CPU: 7.640s
     CGroup: /system.slice/filebeat.service
             ??7299 /usr/share/filebeat/bin/filebeat --environment systemd -c /etc/filebeat/filebeat.yml --path.home /usr/share/filebeat --path.config /etc/filebeat..........

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

Abre https://kibana.example.com y accederás de nuevo a la pantalla de inicio de sesión.

Inicia sesión con el nombre de usuario elastic, y la contraseña que generaste anteriormente y obtendrás la siguiente pantalla.

Haz clic en el enlace Explorar por mi cuenta para acceder al panel de control.

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. Por defecto, sólo muestra las entradas de los últimos 15 minutos, pero nosotros las mostramos a lo largo de un 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 Seguridad en el menú hamburguesa de la izquierda, selecciona Explorar y, a continuación, elige Panel de red en la parte derecha.

Verás la siguiente página.

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 Rocky Linux 9. 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.