Cómo instalar y configurar Suricata IDS junto con Elastic Stack en Rocky Linux 8
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 su servidor. Puede generar eventos de registro, desencadenar alertas y eliminar el tráfico al detectar cualquier actividad sospechosa.
[**]
Puede instalar Suricata en una sola máquina para supervisar su tráfico o desplegarlo en un host de puerta de enlace para escanear todo el tráfico entrante y saliente de otros servidores conectados a él. Puede combinar Suricata con Elasticsearch, Kibana y Filebeat para crear una herramienta de gestión de eventos e información de seguridad (SIEM).
[**]
En este tutorial, usted instalará Suricata IDS junto con ElasticStack en un servidor Rocky Linux 8. Los diferentes 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 está dividido 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.
[**]
Instalaremos Suricata y Elastic Stack en diferentes servidores para nuestro tutorial.
[**]
Requisitos previos
- Los servidores que alojan Elastic Stack y Suricata deben tener un mínimo de 4GB de RAM y 2 núcleos de CPU.
[**] - Los servidores deben ser capaces de comunicarse entre sí utilizando direcciones IP privadas.
[**] - Los servidores deben ejecutar Rocky Linux 8 con un usuario sudo no root.
[**] - Si desea acceder a los dashboards de Kibana desde cualquier lugar, configure un dominio (kibana.ejemplo.com) que apunte al servidor donde se instalará Suricata.
[**] - Instale los paquetes esenciales en ambos servidores.
[**]$ sudo dnf install yum-utils nano curl
Configurar el Firewall
PARTE 1
Paso 1 – Instalar Suricata
Para instalar Suricata, necesita añadir el repositorio de paquetes de la Open Information Security Foundation (OISF) a su servidor.
[**]
$ sudo dnf install 'dnf-command(copr)' $ sudo dnf copr enable @oisf/suricata-6.0
El primer comando habilita los proyectos comunitarios (copr) para el instalador de paquetes dnf. El segundo comando habilita y añade el repositorio OISF a su sistema. suricata-6.0 habilita el repositorio para la última versión estable del software. Pulse y y ENTER cada vez que se le pida.
[**]
A continuación, añada el repositorio EPEL.
[**]
$ sudo dnf install epel-release
Instale Suricata.[**]
$ sudo dnf install suricata
Habilite 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), donde el tráfico sólo se registra y no se detiene. Si eres nuevo en Suricata, deberías dejar el modo sin cambiar. Una vez que lo hayas configurado y aprendido más, puedes activar el modo IPS (Sistema de Prevención de Intrusiones).
[**]
Habilitar el ID de comunidad
El campo Community ID facilita la correlación de datos entre los registros generados por diferentes herramientas de monitorización. Dado que utilizaremos Suricata con Elasticsearch, habilitar el Community ID puede ser útil.
[**]
Abra el archivo /etc/suricata/suricata.yaml para editarlo.
[**]
$ sudo nano /etc/suricata/suricata.yaml
Localice la línea # Community Flow ID y establezca el valor de la variable community-id a 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, sus eventos llevarán un ID como 1:S+3BA2UmrHK0Pk+u3XH78GAFTtQ= que puede utilizar para hacer coincidir los conjuntos de datos en diferentes 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 su servidor utiliza una interfaz de red diferente, deberá actualizarla en la configuración.
[**]
Compruebe el nombre del dispositivo de su interfaz de red utilizando el siguiente comando.
[**]
$ ip -p -j route show default
Recibirá una salida como la siguiente.
[**]
[ {
"dst": "default",
"gateway": "164.90.192.1",
"dev": "eth0",
"protocol": "static",
"metric": 100,
"flags": [ ]
} ]
La variable dev se refiere al dispositivo de red. En nuestra salida, muestra eth0 como el dispositivo de red. Su salida puede ser diferente dependiendo de su sistema.
[**]
Ahora que sabe el nombre de su dispositivo abra el archivo de configuración.
[**]
$ sudo nano /etc/suricata/suricata.yaml
Encuentre la línea af-packet: alrededor de la línea número 580. Debajo de ella, establezca el valor de la variable interface con el nombre del dispositivo para su 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 quiere añadir interfaces adicionales, puede 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értela justo encima de la sección – interfaz: por defecto, 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
Hemos añadido una nueva interfaz enp0s1 y un valor único para la variable cluster-id en nuestro ejemplo. Debes incluir un id de clúster único con cada interfaz que añadas.
[**]
Recarga de reglas en vivo
Es necesario reiniciar Suricata cada vez que se añaden, eliminan y editan sus reglas. Al habilitar la regla en vivo, Suricata puede procesar cualquier cambio de regla sin reiniciar.
[**]
Para habilitar la recarga en vivo, agregue las siguientes líneas al final del archivo de configuración.
[**]
. . . detect-engine: - rule-reload: true
Con la recarga en vivo habilitada, puede utilizar el siguiente comando para recargar las 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.
[**]
Una vez que haya terminado, guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.
[**]
Configurar los permisos del directorio
Suricata creó automáticamente un usuario y un grupo del sistema llamados suricata durante el proceso de instalación. Es necesario dar los permisos de directorio adecuados para que la instalación funcione correctamente.
[**]
Ejecute el siguiente comando para establecer suricata como el grupo para los directorios de Suricata.
[**]
$ sudo chgrp -R suricata /etc/suricata $ sudo chgrp -R suricata /var/lib/suricata/rules $ sudo chgrp -R suricata /var/lib/suricata/update $ 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/rules $ sudo chmod -R g+rw /var/lib/suricata/update $ sudo chmod -R g+rw /var/log/suricata
Agregue su nombre de usuario actual al grupo suricata para que pueda realizar operaciones directamente sin necesidad de sudo.
[**]
$ sudo usermod -a -G suricata $USER
Para aplicar la nueva membresía del grupo, salga del servidor y vuelva a entrar, o escriba lo siguiente:
[**]
$ su - ${USER}
Se le pedirá que introduzca la contraseña de su usuario para continuar.
[**]
Confirme que su usuario se ha añadido al suricata agrupar escribiendo:
[**]
$ id -nG username sudo 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. Puede añadir más conjuntos de reglas de proveedores externos utilizando una herramienta llamada suricata-update. Ejecute el siguiente comando para incluir reglas adicionales.
[**]
$ suricata-update
16/2/2022 -- 07:00:16 - <Info> -- Using data-directory /var/lib/suricata.
16/2/2022 -- 07:00:16 - <Info> -- Using Suricata configuration /etc/suricata/suricata.yaml
16/2/2022 -- 07:00:16 - <Info> -- Using /usr/share/suricata/rules for Suricata provided rules.
.....
16/2/2022 -- 07:00:16 - <Info> -- No sources configured, will use Emerging Threats Open
('https://rules.emergingthreats.net/open/suricata-6.0.4/emerging.rules.tar.gz', None, True)
16/2/2022 -- 07:00:16 - <Info> -- Checking https://rules.emergingthreats.net/open/suricata-6.0.4/emerging.rules.tar.gz.md5.
16/2/2022 -- 07:00:16 - <Info> -- Fetching https://rules.emergingthreats.net/open/suricata-6.0.4/emerging.rules.tar.gz.
100% - 3162050/3162050
.....
16/2/2022 -- 07:00:23 - <Info> -- Writing rules to /var/lib/suricata/rules/suricata.rules: total: 32004; enabled: 24611; added: 8; removed 1; modified: 1218
16/2/2022 -- 07:00:23 - <Info> -- Writing /var/lib/suricata/rules/classification.config
16/2/2022 -- 07:00:23 - <Info> -- Testing with suricata -T.
16/2/2022 -- 07:01:16 - <Info> -- Done.
Añadir proveedores de conjuntos de reglas
Puede ampliar las reglas de Suricata añadiendo más proveedores. Puede obtener reglas de una variedad de proveedores gratuitos y comerciales.
[**]
Puede listar la lista de proveedores por defecto utilizando el siguiente comando.
[**]
$ suricata-update list-sources
Por ejemplo, si quiere incluir el conjunto de reglas tgreen/hunting, puede activarlo con el siguiente comando.
[**]
$ suricata-update enable-source tgreen/hunting
Vuelva a ejecutar el comando suricata-update para descargar y actualizar las nuevas reglas.
[**]
Paso 4 – Validar la configuración de Suricata
Suricata incluye una herramienta de validación para comprobar si el archivo de configuración y las reglas presentan errores. Ejecute el siguiente comando para ejecutar la herramienta de validación.
[**]
$ sudo suricata -T -c /etc/suricata/suricata.yaml -v 22/2/2022 -- 23:20:10 - <Info> - Running suricata under test mode 22/2/2022 -- 23:20:10 - <Notice> - This is Suricata version 6.0.4 RELEASE running in SYSTEM mode 22/2/2022 -- 23:20:10 - <Info> - CPUs/cores online: 2 22/2/2022 -- 23:20:10 - <Info> - dropped the caps for main thread 22/2/2022 -- 23:20:10 - <Info> - fast output device (regular) initialized: fast.log 22/2/2022 -- 23:20:10 - <Info> - eve-log output device (regular) initialized: eve.json 22/2/2022 -- 23:20:10 - <Info> - stats output device (regular) initialized: stats.log 22/2/2022 -- 23:20:21 - <Info> - 1 rule files processed. 24611 rules successfully loaded, 0 rules failed 22/2/2022 -- 23:20:21 - <Info> - Threshold config parsed: 0 rule(s) found 22/2/2022 -- 23:20:21 - <Info> - 24614 signatures processed. 1216 are IP-only rules, 4120 are inspecting packet payload, 19074 inspect application layer, 108 are decoder event only 22/2/2022 -- 23:21:02 - <Notice> - Configuration provided was successfully loaded. Exiting. 22/2/2022 -- 23:21:03 - <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 verbosa del comando. Dependiendo de la configuración de su sistema y del número de reglas añadidas, el comando puede tardar unos minutos en terminar.
[**]
Paso 5 – Ejecución de Suricata
Ahora que Suricata está configurado e instalado, es el momento de ejecutar la aplicación.
[**]
$ sudo systemctl start suricata
Compruebe el estado del proceso.
[**]
$ sudo systemctl status suricata
Debería ver la siguiente salida si todo está funcionando correctamente.
[**]
? suricata.service - Suricata Intrusion Detection Service
Loaded: loaded (/usr/lib/systemd/system/suricata.service; enabled; vendor preset: disabled)
Active: active (running) since Wed 2022-02-16 07:14:22 UTC; 32min ago
Docs: man:suricata(1)
Process: 1494 ExecStartPre=/bin/rm -f /var/run/suricata.pid (code=exited, status=0/SUCCESS)
Main PID: 1496 (Suricata-Main)
Tasks: 8 (limit: 23479)
Memory: 367.5M
CGroup: /system.slice/suricata.service
??1496 /sbin/suricata -c /etc/suricata/suricata.yaml --pidfile /var/run/suricata.pid -i eth0 --user suricata
Feb 16 07:14:22 suricata systemd[1]: Starting Suricata Intrusion Detection Service...
Feb 16 07:14:22 suricata systemd[1]: Started Suricata Intrusion Detection Service.
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á en marcha y listo. Puede controlar el archivo de registro para ello utilizando el siguiente comando.
[**]
$ sudo tail -f /var/log/suricata/suricata.log
Si ve la siguiente línea en el archivo de registro, significa que Suricata se está ejecutando y está listo para monitorear el tráfico de la red.
[**]
16/02/2022 -- 07:18:39 - <Info> - All AFP capture threads are running.
Paso 6 – Probando las reglas de Suricata
Vamos a comprobar si Suricata detecta algún tráfico sospechoso. La guía de Suricata recomienda probar el número de regla ET Open 2100498 utilizando el siguiente comando.
[**]
$ curl http://testmynids.org/uid/index.html
Obtendrá la siguiente respuesta.
[**]
uid=0(root) gid=0(root) groups=0(root)
El comando anterior pretende devolver la salida del comando id que se puede ejecutar en un sistema comprometido. Para comprobar si Suricata ha detectado el tráfico, es necesario comprobar el archivo de registro utilizando el número de regla especificado.
[**]
$ grep 2100498 /var/log/suricata/fast.log
Si su solicitud utilizó IPv6, debería 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 su solicitud utilizara IPv4, vería 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, es necesario instalar jq, que está fuera del alcance de este tutorial.
[**]
Hemos terminado con la primera parte del tutorial, donde instalamos Suricata y lo probamos. La siguiente parte consiste en instalar la pila ELK y configurarla para visualizar Suricata y sus registros. Esta segunda parte del tutorial se supone que se hace 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 su 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
Pegue el siguiente código en él.
[**]
[elasticsearch] name=Elasticsearch repository for 7.x packages baseurl=https://artifacts.elastic.co/packages/7.x/yum gpgcheck=1 gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch enabled=0 autorefresh=1 type=rpm-md
Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.
[**]
Instalar Elasticsearch y Kibana.
[**]
$ sudo dnf install --enablerepo=elasticsearch elasticsearch kibana
Es necesario utilizar la bandera –enablerepo=elasticsearch cada vez que, hemos mantenido el repositorio deshabilitado por defecto. Esto evita la actualización accidental de estos paquetes.
[**]
Localice la dirección IP privada de su servidor utilizando el siguiente comando.
[**]
$ ip -brief address show lo UNKNOWN 127.0.0.1/8 ::1/128 eth0 UP 164.90.205.77/20 10.18.0.7/16 2a03:b0c0:2:d0::fef:b001/64 fe80::340a:6eff:fe5c:76ed/64 eth1 UP 10.133.0.3/16 fe80::906f:b5ff:fec4:c7b8/64
Anote la IP privada de su servidor (10.133.0.3 en este caso). Nos referiremos a ella como tu_IP_privada. La dirección IP pública del servidor (164.90.205.77) se denominará su_IP_pública en el resto del tutorial. Además, anote el nombre de la red de su servidor, eth1.
[**]
Paso 8 – Configurar Elasticsearch
Elasticsearch almacena su configuración en el archivo /etc/elasticsearch/elasticsearch.yml. Abra el archivo para editarlo.
[**]
$ sudo nano /etc/elasticsearch/elasticsearch.yml
Elasticsearch sólo acepta conexiones locales por defecto. Tenemos que cambiarlo para que Kibana pueda acceder a través de la dirección IP privada.
[**]
Encuentre la línea #network.host: 192.168.0.1 y añada la siguiente línea justo debajo de ella, 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 asegurará que Elastic pueda seguir aceptando conexiones locales mientras está disponible para Kibana a través de la dirección IP privada.
[**]
El siguiente paso es activar algunas características de seguridad y asegurar que Elastic esté configurado para correr en un solo nodo. Para ello, añade las siguientes líneas al final del archivo.
[**]
. . . discovery.type: single-node xpack.security.enabled: true
Si va a utilizar varios nodos de búsqueda de Elastic, puede omitir la primera línea.
[**]
Una vez que haya terminado, guarde el archivo presionando Ctrl + X e introduciendo Y cuando se le solicite.
[**]
Configurar el cortafuegos
Agregue las reglas de firewall adecuadas para Elasticsearch de manera 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 --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 Firewall a interna y abren los puertos 9200, 9300 para Elasticsearch y el puerto 5601 para Kibana.
[**]
Iniciar Elasticsearch
Ahora que ha configurado Elasticsearch, es el momento de iniciar el servicio.
[**]
$ sudo systemctl start elasticsearch
Crear contraseñas de Elasticsearch
Después de 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.
[**]
Cree las contraseñas.
[**]
$ cd /usr/share/elasticsearch/bin $ sudo ./elasticsearch-setup-passwords auto
Obtendrá una salida como la siguiente. Pulse y para continuar cuando se le 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 = EtwMg8maU67o5tvD5rse Changed password for user kibana_system PASSWORD kibana_system = dTanR7Q2HtgDtATRvuJv Changed password for user kibana PASSWORD kibana = dTanR7Q2HtgDtATRvuJv Changed password for user logstash_system PASSWORD logstash_system = XGSjxNktuNMWVfGYibox Changed password for user beats_system PASSWORD beats_system = JXTr7CeHkMue608qVTQa Changed password for user remote_monitoring_user PASSWORD remote_monitoring_user = Q6JTJNl3lPy0fhy6QuMP Changed password for user elastic PASSWORD elastic = bd1YJfhSa8RC8SMvTIwg
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 habilitar la función de seguridad de xpack generando claves secretas. Kibana utiliza estas claves secretas para almacenar datos en Elasticsearch. La utilidad para generar claves secretas se puede acceder 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á una salida como la siguiente.
[**]
xpack.encryptedSavedObjects.encryptionKey: 0f4e5e1cf8fad1874ffed0faac6be0da xpack.reporting.encryptionKey: d435c78a4e37521e539c0e905420c9f5 xpack.security.encryptionKey: 7ba0e2a02747bb90fb0f9a3c267b99ed
Copie la salida. Abra el archivo de configuración de Kibana en /etc/kibana/kibana.yml para editarlo.
[**]
$ sudo nano /etc/kibana/kibana.yml
Pegue 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
Kibana necesita ser configurado para que sea accesible en la dirección IP privada del servidor. Encuentra la línea #server.host: «localhost» en el archivo y añade la siguiente línea justo debajo de ella 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"
Una vez que haya terminado, guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.
[**]
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. Puede 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.
[**]
Ejecute los siguientes comandos para establecer un nombre de usuario. Introduzca kibana_system como nombre de usuario.
[**]
$ cd /usr/share/kibana/bin $ sudo ./kibana-keystore add elasticsearch.username Enter value for elasticsearch.username: *************
Ejecute el comando de nuevo para establecer la contraseña. Asegúrese de utilizar la contraseña que creó 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: ********************
Iniciando Kibana
Ahora que ha configurado el acceso seguro y la red para Kibana, inicie el proceso.
[**]
$ sudo systemctl start kibana
Compruebe el estado para ver si se está ejecutando.
[**]
$ sudo systemctl status kibana
Paso 10 – Instalar y configurar Filebeat
Es importante tener en cuenta que vamos a instalar Filebeat en el servidor de Suricata. Así que vuelve a él y añade la clave GPG de Elastic para empezar.
[**]
$ sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
Cree y abra el repositorio elástico.
[**]
$ sudo nano /etc/yum.repos.d/elasticsearch.repo
Pegue el siguiente código.
[**]
[elasticsearch] name=Elasticsearch repository for 7.x packages baseurl=https://artifacts.elastic.co/packages/7.x/yum gpgcheck=1 gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch enabled=0 autorefresh=1 type=rpm-md
Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.
[**]
Instalar Filebeat.
[**]
$ sudo dnf install --enablerepo=elasticsearch filebeat
Filebeat almacena su configuración en el archivo /etc/filebeat/filebeat.yml. Ábralo para editarlo.
[**]
$ sudo nano /etc/filebeat/filebeat.yml
Lo primero que tienes que hacer es conectarlo al panel de control de Kibana. Encuentra la línea #host: «localhost:5601» en el Kibana y añada 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, busque la sección Salida de Elasticsearch del archivo y edita los valores de hosts, nombre de usuario y contraseña como se muestra a continuación. Para el nombre de usuario, elija elastic como valor, y para la contraseña, utilice 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" . . .
Una vez que haya terminado, guarde el archivo presionando Ctrl + X e introduciendo Y cuando se le solicite.
[**]
A continuación, active el módulo Suricata integrado en Filebeat.
[**]
$ sudo filebeat modules enable suricata
El último paso en la configuración de Filebeat es cargar los paneles y pipelines SIEM en Elasticsearch utilizando el comando de configuración de Filebeat.
[**]
$ sudo filebeat setup
El comando puede tardar unos minutos en terminar. Una vez terminado, debería 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
Inicie el servicio Filebeat.
[**]
$ sudo systemctl start filebeat
Compruebe el estado del servicio.
[**]
$ sudo systemctl status filebeat
Paso 11 – Acceso 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, tiene dos opciones para acceder a él. El primer método es usar un túnel SSH hacia el servidor de Elasticsearch desde su 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 usted no será capaz de acceder desde cualquier otro lugar.
[**]
La opción es instalar Nginx en su Servidor Suricata y utilizarlo como proxy inverso para acceder al servidor de Elasticsearch a través de su dirección IP privada. Discutiremos ambas formas. Puedes elegir cualquiera de las dos formas en función de tus necesidades.
[**]
Usando el túnel local SSH
Si está usando Windows 10 o Windows 11, puede ejecutar el SSH LocalTunnel desde su Windows Powershell. En Linux o macOS, puede utilizar la terminal. Probablemente necesitarás configurar el acceso SSH si aún no lo has hecho.
[**]
Ejecute el siguiente comando en la terminal de su ordenador para crear el túnel SSH.
[**]
$ ssh -L 5601:your_private_IP:5601 [email protected]_public_IP -N
- La bandera -L se refiere al Túnel SSH local, que reenvía el tráfico desde el puerto de su PC al servidor.
- La private_IP:5601 es la dirección IP a la que se reenvía el tráfico en el servidor. En este caso, sustitúyala por la dirección IP privada de su servidor de Elasticsearch.
- La IP_pública es la dirección IP pública del servidor de Elasticsearch, que se utiliza para abrir una conexión SSH.
- La bandera -N le dice a OpenSSH que no ejecute ningún comando pero que mantenga la conexión viva mientras se ejecute el túnel.
Ahora que el túnel está abierto, puede acceder a Kibana abriendo la URL http://localhost:5601 en el navegador de su PC. Obtendrá la siguiente pantalla.
[**]
[**]
Deberá mantener el comando en ejecución durante el tiempo que necesite para acceder a Kibana. Pulse Ctrl + C en tu terminal para cerrar el túnel.
[**]
Usando Nginx Reverse-proxy
Este método es el más adecuado si quiere acceder al panel de control desde cualquier parte del mundo.
[**]
Configurar el cortafuegos
Antes de continuar, debe abrir los puertos HTTP y HTTPS en el cortafuegos.
[**]
$ sudo firewall-cmd --permanent --add-service=http $ sudo firewall-cmd --permanent --add-service=https
Recargue el cortafuegos para habilitar los cambios.
[**]
$ sudo firewall-cmd --reload
Instalar y configurar SSL
El primer paso es instalar el certificado SSL de Let’s Encrypt. Como ya tenemos configurado el repositorio EPEL, instala la herramienta Certbot.
[**]
$ sudo dnf install certbot
Generar el certificado SSL para el dominio kibana.example.com.
[**]
$ sudo certbot certonly --standalone --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 su servidor.
[**]
Generar un Grupo Diffie-Hellman certificado.
[**]
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
Crear un directorio raíz web de desafío para la renovación automática de Let’s Encrypt.
[**]
$ sudo mkdir -p /var/lib/letsencrypt
Crear un Cron Job para renovar el SSL. Se ejecutará cada día para comprobar el certificado y renovarlo si es necesario. Para ello, primero cree el archivo /etc/cron.daily/certbot-renew y ábralo para editarlo.
[**]
$ sudo nano /etc/cron.daily/certbot-renew
Pegue el siguiente código.
[**]
#!/bin/sh certbot renew --cert-name kibana.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"
Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.
[**]
Cambie los permisos del archivo de la tarea para que sea ejecutable.
[**]
$ sudo chmod +x /etc/cron.daily/certbot-renew
Instalar y configurar Nginx
Rocket Linux 8.5 incluye la última versión estable de Nginx como módulo. Instálelo usando el siguiente comando.
[**]
$ sudo dnf module install nginx:1.20
Puede comprobar la versión que desea instalar utilizando el siguiente comando.
[**]
$ dnf module list nginx Rocky Linux 8 - AppStream Name Stream Profiles Summary nginx 1.14 [d] common [d] nginx webserver nginx 1.16 common [d] nginx webserver nginx 1.18 common [d] nginx webserver nginx 1.20 [e] common [d] [i] nginx webserver Extra Packages for Enterprise Linux Modular 8 - x86_64 Name Stream Profiles Summary nginx mainline common nginx webserver nginx 1.20 [e] common [d] [i] nginx webserver
Confirme la instalación de Nginx.
[**]
$ nginx -v nginx version 1.20.1
Habilite el servicio Nginx.
[**]
$ sudo systemctl enable nginx
Cree y abra el archivo de configuración de Nginx para Kibana.
[**]
$ sudo nano /etc/nginx/conf.d/kibana.conf
Pegue el siguiente código en él. 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;
}
}
Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.
[**]
Abra 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 le solicite.
[**]
Verifique 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
Inicie el servicio Nginx.
[**]
$ sudo systemctl start nginx
Su panel de control Kibana debería ser accesible a través de la URL https://kibana.example.com desde cualquier lugar que desee.
[**]
Paso 12 – Gestión de los cuadros de mando de Kibana
Antes de continuar con la gestión de los cuadros de mando, es necesario añadir el campo de la URL base en la configuración de Kibana.
[**]
Abra el archivo de configuración de Kibana.
[**]
$ sudo nano /etc/kibana/kibana.yml
Encuentre la línea comentada #server.publicBaseUrl: «» y cámbiela de la siguiente manera, eliminando el hash delante de ella.
[**]
server.publicBaseUrl: "https://kibana.example.com"
Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.
[**]
Reinicie el servicio Kibana.
[**]
$ sudo systemctl restart kibana
Espera unos minutos y carga la URL https://kibana.example.com en tu navegador. Inicie sesión con el nombre de usuario elástico y la contraseña que generó antes (bd1YJfhSa8RC8SMvTIwg) y obtendrá la siguiente pantalla.
[**]
[**]
Escriba type:data suricata en el cuadro de búsqueda de la parte superior para localizar la información de Suricata.
[**]
[**]
Haga clic en el primer resultado ([Filebeat Suricata] Resumen de la alerta), y obtendrá 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.
[**]
[**]
Haga clic en el Eventos para ver todos los eventos registrados.
[**]
[**]
Al desplazarse hacia abajo en las páginas de eventos y alertas, puede identificar cada evento y alerta por el tipo de protocolo, los puertos de origen y destino, y la dirección IP de la fuente. También puede ver los países desde los que se originó el tráfico.
[**]
Puedes usar Kibana y Filebeat para acceder y generar otros tipos de dashboards. Uno de los cuadros de mando incorporados que puede utilizar de inmediato es el cuadro de mando de seguridad. Haga clic en el Red en el menú hamburguesa de la izquierda, y obtendrá la siguiente pantalla.
[**]
[**]
Puede agregar más tableros como Nginx habilitando y configurando los módulos incorporados de Filebeat.
[**]
Conclusión
Esto concluye el tutorial para instalar y configurar Suricata IDS con Elastic Stack en un servidor basado en Rocky Linux 8. También ha configurado Nginx como proxy inverso para acceder a los dashboards de Kibana de forma externa. Si tienes alguna pregunta, publícala en los comentarios abajo.