Búsqueda de sitios web

Cómo instalar y configurar Suricata IDS junto con Elastic Stack en Debian 12


Suricata es una herramienta de monitoreo 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, activar alertas y reducir el tráfico al detectar cualquier actividad sospechosa.

Puede instalar Suricata en una sola máquina para monitorear su tráfico o implementarlo 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, instalará Suricata IDS junto con ElasticStack en un servidor Debian 12. 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 la red en busca de eventos sospechosos y descartar 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.

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 4 GB de RAM y 2 núcleos de CPU.

    Los servidores deberían poder comunicarse entre sí mediante direcciones IP privadas.

    Los servidores deberían ejecutar Debian 12 con un usuario sudo no root.

    Si desea acceder a los paneles de Kibana desde cualquier lugar, configure un dominio (kibana.example.com) que apunte al servidor donde se instalará Elasticsearch.

    Instale paquetes esenciales en ambos servidores. Es posible que algunos de ellos ya estén instalados.

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

    Asegúrese de que todo esté actualizado en ambos servidores.

    $ sudo apt update
    

PARTE 1

Paso 1 - Instalar Suricata

Suricata está disponible en los repositorios oficiales de Debian. Instálelo usando el siguiente comando.

$ sudo apt install suricata

El servicio Suricata se habilita e inicia automáticamente. Antes de continuar, detenga el servicio Suricata ya que primero debemos configurarlo.

$ sudo systemctl stop suricata

Paso 2: configurar Suricata

Suricata almacena su configuración en el archivo /etc/suricata/suricata.yaml. El modo predeterminado para Suricata es el modo IDS (Sistema de detección de intrusiones), donde el tráfico solo se registra y no se detiene. Si eres nuevo en Suricata, debes dejar el modo sin cambios. Una vez que lo haya configurado y haya aprendido más, puede activar el modo IPS (Sistema de prevención de intrusiones).

Habilitar ID de comunidad

El campo ID de comunidad facilita la correlación de datos entre registros generados por diferentes herramientas de monitoreo. Dado que usaremos Suricata con Elasticsearch, habilitar Community ID puede resultar ú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 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
. . .

Guarde el archivo presionando Ctrl + X e ingresando Y cuando se le solicite.

Ahora, sus eventos llevarán una identificación como 1:S+3BA2UmrHK0Pk+u3XH78GAFTtQ= que puede usar para hacer coincidir conjuntos de datos en diferentes herramientas de monitoreo.

Seleccionar interfaz de red

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

Verifique el nombre del dispositivo de su interfaz de red usando el siguiente comando.

$ ip -p -j route show default

Recibirá un resultado como el siguiente.

[ {
        "dst": "default",
        "gateway": "159.223.208.1",
        "dev": "eth0",
        "protocol": "static",
        "flags": [ ]
    } ]

La variable dev se refiere al dispositivo de red. En nuestro resultado, muestra eth0 como dispositivo de red. Su salida puede ser diferente dependiendo de su sistema.

Ahora que conoce el nombre de su dispositivo, abra el archivo de configuración.

$ sudo nano /etc/suricata/suricata.yaml

Busque la línea af-packet: alrededor de la línea número 580. Debajo de ella, establezca el valor de la variable interface en 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 desea agregar interfaces adicionales, puede hacerlo agregándolas en la parte inferior de la sección af-packet alrededor de la línea 650.

Para agregar una nueva interfaz, insértela 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

Hemos agregado una nueva interfaz enp0s1 y un valor único para la variable cluster-id en nuestro ejemplo. Debe incluir una ID de clúster única con cada interfaz que agregue.

Busque la línea pcap: y debajo de ella, establezca el valor de la variable interface en el nombre del dispositivo para su 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 agregar una nueva interfaz como antes, insértela 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

Una vez que haya terminado, guarde el archivo presionando Ctrl + X e ingresando Y cuando se le solicite.

Paso 3: configurar las reglas de Suricata

Suricata, de forma predeterminada, sólo utiliza un conjunto limitado de reglas para detectar el tráfico de la red. Puede agregar más conjuntos de reglas de proveedores externos utilizando una herramienta llamada suricata-update. Ejecute el siguiente comando para incluir reglas adicionales.

$ sudo suricata-update -o /etc/suricata/rules
4/10/2023 -- 14:12:05 - <Info> -- Using data-directory /var/lib/suricata.
4/10/2023 -- 14:12:05 - <Info> -- Using Suricata configuration /etc/suricata/suricata.yaml
4/10/2023 -- 14:12:05 - <Info> -- Using /etc/suricata/rules for Suricata provided rules.
.....
4/10/2023 -- 14:12:05 - <Info> -- No sources configured, will use Emerging Threats Open
4/10/2023 -- 14:12:05 - <Info> -- Fetching https://rules.emergingthreats.net/open/suricata-6.0.10/emerging.rules.tar.gz.
 100% - 4073339/4073339
.....
4/10/2023 -- 14:12:09 - <Info> -- Writing rules to /etc/suricata/rules/suricata.rules: total: 45058; enabled: 35175; added: 45058; removed 0; modified: 0
4/10/2023 -- 14:12:10 - <Info> -- Writing /etc/suricata/rules/classification.config
4/10/2023 -- 14:12:10 - <Info> -- Testing with suricata -T.
4/10/2023 -- 14:12:33 - <Info> -- Done.

La parte -o /etc/suricata/rules del comando indica a la herramienta de actualización que guarde las reglas en el directorio /etc/suricata/rules. Este parámetro es importante; de lo contrario, obtendrá el siguiente error durante la validación.

<Warning> - [ERRCODE: SC_ERR_NO_RULES(42)] - No rule files match the pattern /etc/suricata/rules/suricata.rules

Agregar proveedores de conjuntos de reglas

Puede ampliar las reglas de Suricata agregando más proveedores. Puede obtener reglas de una variedad de proveedores comerciales y gratuitos.

Puede enumerar la lista de proveedores predeterminados utilizando el siguiente comando.

$ sudo suricata-update list-sources

Por ejemplo, si desea incluir el conjunto de reglas tgreen/hunting, puede habilitarlo con el siguiente comando.

$ sudo suricata-update enable-source tgreen/hunting
4/10/2023 -- 14:24:26 - <Info> -- Using data-directory /var/lib/suricata.
4/10/2023 -- 14:24:26 - <Info> -- Using Suricata configuration /etc/suricata/suricata.yaml
4/10/2023 -- 14:24:26 - <Info> -- Using /etc/suricata/rules for Suricata provided rules.
4/10/2023 -- 14:24:26 - <Info> -- Found Suricata version 6.0.10 at /usr/bin/suricata.
4/10/2023 -- 14:24:26 - <Info> -- Creating directory /var/lib/suricata/update/sources
4/10/2023 -- 14:24:26 - <Info> -- Enabling default source et/open
4/10/2023 -- 14:24:26 - <Info> -- Source tgreen/hunting enabled

Ejecute el comando suricata-update nuevamente para descargar y actualizar las nuevas reglas. Suricata, de forma predeterminada, puede procesar cualquier cambio de regla sin reiniciar.

Paso 4: validar la configuración de Suricata

Suricata se entrega con una herramienta de validación para verificar si hay errores en el archivo de configuración y las reglas. Ejecute el siguiente comando para ejecutar la herramienta de validación.

$ sudo suricata -T -c /etc/suricata/suricata.yaml -v
4/10/2023 -- 14:24:43 - <Info> - Running suricata under test mode
4/10/2023 -- 14:24:43 - <Notice> - This is Suricata version 6.0.10 RELEASE running in SYSTEM mode
4/10/2023 -- 14:24:43 - <Info> - CPUs/cores online: 2
4/10/2023 -- 14:24:43 - <Info> - fast output device (regular) initialized: fast.log
4/10/2023 -- 14:24:43 - <Info> - eve-log output device (regular) initialized: eve.json
4/10/2023 -- 14:24:43 - <Info> - stats output device (regular) initialized: stats.log
4/10/2023 -- 14:24:53 - <Info> - 1 rule files processed. 35175 rules successfully loaded, 0 rules failed
4/10/2023 -- 14:24:53 - <Info> - Threshold config parsed: 0 rule(s) found
4/10/2023 -- 14:24:54 - <Info> - 35178 signatures processed. 1255 are IP-only rules, 5282 are inspecting packet payload, 28436 inspect application layer, 108 are decoder event only
4/10/2023 -- 14:25:07 - <Notice> - Configuration provided was successfully loaded. Exiting.
4/10/2023 -- 14:25:07 - <Info> - cleaning up signature grouping structure... complete

El indicador -T indica a Suricata que se ejecute en modo de prueba, el indicador -c configura la ubicación del archivo de configuración y el indicador -v imprime la salida detallada del comando. Dependiendo de la configuración de su sistema y la cantidad de reglas agregadas, el comando puede tardar unos minutos en finalizar.

Paso 5: ejecutar Suricata

Ahora que Suricata está configurado y configurado, es hora de ejecutar la aplicación.

$ sudo systemctl start suricata

Consultar el estado del proceso.

$ sudo systemctl status suricata

Debería ver el siguiente resultado si todo funciona correctamente.

? suricata.service - Suricata IDS/IDP daemon
     Loaded: loaded (/lib/systemd/system/suricata.service; enabled; preset: enabled)
     Active: active (running) since Wed 2023-10-04 14:25:49 UTC; 6s ago
       Docs: man:suricata(8)
             man:suricatasc(8)
             https://suricata-ids.org/docs/
    Process: 1283 ExecStart=/usr/bin/suricata -D --af-packet -c /etc/suricata/suricata.yaml --pidfile /run/suricata.pid (code=exited, status=0/SUCCESS)
   Main PID: 1284 (Suricata-Main)
      Tasks: 1 (limit: 4652)
     Memory: 211.7M
        CPU: 6.132s
     CGroup: /system.slice/suricata.service
             ??1284 /usr/bin/suricata -D --af-packet -c /etc/suricata/suricata.yaml --pidfile /run/suricata.pid

Oct 04 14:25:49 suricata systemd[1]: Starting suricata.service - Suricata IDS/IDP daemon...
Oct 04 14:25:49 suricata suricata[1283]: 4/10/2023 -- 14:25:49 - <Notice> - This is Suricata version 6.0.10 RELEASE running in SYSTEM mode
Oct 04 14:25:49 suricata systemd[1]: Started suricata.service - Suricata IDS/IDP daemon.

El proceso puede tardar unos minutos en finalizar el análisis de todas las reglas. Por lo tanto, la verificación de estado anterior no es una indicación completa de si Suricata está en funcionamiento y listo. Puede monitorear el archivo de registro usando 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 listo para monitorear el tráfico de la red. Salga del comando tail presionando las teclas CTRL+C.

4/10/2023 -- 14:26:12 - <Info> - All AFP capture threads are running.

Paso 6: prueba de las reglas de Suricata

Comprobaremos si Suricata detecta tráfico sospechoso. La guía de Suricata recomienda probar el número de regla de ET Open 2100498 usando 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 el resultado del comando id que se puede ejecutar en un sistema comprometido. Para probar si Suricata detectó el tráfico, debe verificar el archivo de registro usando el número de regla especificado.

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

Si su solicitud utilizó IPv6, debería ver el siguiente resultado.

10/04/2023-14:26:37.511168  [**] [1:2100498:7] GPL ATTACK_RESPONSE id check returned root [**] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 2600:9000:23d0:a200:0018:30b3:e400:93a1:80 -> 2a03:b0c0:0002:00d0:0000:0000:0e1f:c001:53568

Si su solicitud utilizó IPv4, verá el siguiente resultado.

10/04/2023-14:26:37.511168  [**] [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 usando formato JSON. Para leer e interpretar esas reglas, necesita instalar jq, que está fuera del alcance de este tutorial.

PARTE 2

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. Se supone que la segunda parte del tutorial debe realizarse en el segundo servidor, a menos que se especifique lo contrario.

Paso 7: instale Elasticsearch

El primer paso para instalar Elasticsearch implica agregar la clave Elastic GPG a su servidor.

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

Cree 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/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list

Actualice la lista de repositorios de su sistema.

$ sudo apt update

Instale Elasticsearch y Kibana.

$ sudo apt install elasticsearch

Obtendrá el siguiente resultado 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 : IuRTjJr+=NqIClxZwKBn

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'.

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

Usaremos esta información más adelante.

Localice la dirección IP privada de su servidor usando el siguiente comando.

$ ip -brief address show
lo               UNKNOWN        127.0.0.1/8 ::1/128
eth0             UP             159.223.220.228/20 10.18.0.5/16 2a03:b0c0:2:d0::e0e:c001/64 fe80::841e:feff:fee4:e653/64
eth1             UP             10.133.0.2/16 fe80::d865:d5ff:fe29:b50f/64

Anota la IP privada de tu servidor (10.133.0.2 en este caso). Nos referiremos a él como your_private_IP. La dirección IP pública del servidor (159.223.220.228) se denominará your_public_IP en el tutorial restante. Además, anote el nombre de la interfaz de 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 solo acepta conexiones locales de forma predeterminada. Necesitamos cambiarlo para que Kibana pueda acceder a él a través de la dirección IP privada.

Busque la línea #network.host: 192.168.0.1 y agregue 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 aún pueda aceptar conexiones locales mientras esté disponible para Kibana a través de la dirección IP privada.

El siguiente paso es activar algunas funciones de seguridad y garantizar que Elastic esté configurado para ejecutarse en un solo nodo. Si va a utilizar varios nodos de búsqueda de Elastic, omita los cambios siguientes y guarde el archivo.

Para hacer eso, agregue la siguiente línea al final del archivo.

. . .
discovery.type: single-node

Además, comente la siguiente línea agregando un hash (#) delante de ella.

#cluster.initial_master_nodes: ["kibana"]

Una vez que haya terminado, guarde el archivo presionando Ctrl + X e ingresando Y cuando se le solicite.

Configurar cortafuegos

Agregue las reglas de firewall adecuadas para Elasticsearch para que sea accesible a través de la red privada.

$ sudo ufw allow in on eth1
$ sudo ufw allow out on eth1

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

Iniciar búsqueda elástica

Vuelva a cargar el demonio de servicio.

$ sudo systemctl daemon-reload

Habilite el servicio Elasticsearch.

$ sudo systemctl enable elasticsearch

Ahora que ha configurado Elasticsearch, es hora de iniciar el servicio.

$ sudo systemctl start elasticsearch

Consultar el estado del servicio.

$ sudo systemctl status elasticsearch
? elasticsearch.service - Elasticsearch
     Loaded: loaded (/lib/systemd/system/elasticsearch.service; enabled; preset: enabled)
     Active: active (running) since Wed 2023-10-04 14:30:55 UTC; 8s ago
       Docs: https://www.elastic.co
   Main PID: 1731 (java)
      Tasks: 71 (limit: 4652)
     Memory: 2.3G
        CPU: 44.355s
     CGroup: /system.slice/elasticsearch.service

Crear contraseñas de Elasticsearch

Después de habilitar la configuración de seguridad de Elasticsearch, el siguiente paso es generar la contraseña para el superusuario de Elasticsearch. La contraseña predeterminada se proporcionó durante la instalación y puede usarla, pero se recomienda modificarla.

Ejecute el siguiente comando para restablecer la contraseña de Elasticsearch. Elija una contraseña segura.

$ 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" : "kibana",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "KGYx4poLSxKhPyOlYrMq1g",
  "version" : {
    "number" : "8.10.2",
    "build_flavor" : "default",
    "build_type" : "deb",
    "build_hash" : "6d20dd8ce62365be9b1aca96427de4622e970e9e",
    "build_date" : "2023-09-19T08:16:24.564900370Z",
    "build_snapshot" : false,
    "lucene_version" : "9.7.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 completamente funcional y funciona sin problemas.

Paso 9: instalar y configurar Kibana

Instale Kibana.

$ sudo apt install kibana

El primer paso para configurar Kibana es habilitar 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.

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

El indicador -q suprime las instrucciones del comando y el indicador --force garantiza que se generen nuevos secretos. Recibirá un resultado como el siguiente.

xpack.encryptedSavedObjects.encryptionKey: 248eb61d444215a6e710f6d1d53cd803
xpack.reporting.encryptionKey: aecd17bf4f82953739a9e2a9fcad1891
xpack.security.encryptionKey: 2d733ae5f8ed5f15efd75c6d08373f36

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.

. . .
# 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: 3ff21c6daf52ab73e932576c2e981711
xpack.reporting.encryptionKey: edf9c3863ae339bfbd48c713efebcfe9
xpack.security.encryptionKey: 7841fd0c4097987a16c215d9429daec1

Copie el archivo de certificado de CA /etc/elasticsearch/certs/http_ca.crt al directorio /etc/kibana.

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

Configurar el host Kibana

Kibana debe configurarse para que sea accesible desde la dirección IP privada del servidor. Busque la línea #server.host: "localhost" en el archivo y agregue 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"

Desactivar la telemetría

Kibana envía datos a sus servidores de forma predeterminada. Esto puede afectar el rendimiento y también supone un riesgo para la privacidad. Por lo tanto, debes desactivar la Telemetría. Agregue el siguiente código al final del archivo para desactivar la telemetría. La primera configuración desactiva la telemetría y la segunda configuración no permite sobrescribir la primera configuración de la sección Configuración avanzada en Kibana.

telemetry.optIn: false
telemetry.allowChangingOptInStatus: false

Una vez que haya terminado, guarde el archivo presionando Ctrl + X e ingresando Y cuando se le solicite.

Configurar SSL

Busque la variable elasticsearch.ssl.certificateAuthorities, descomentela y cambie su valor como se muestra a continuación.

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

Configurar el acceso a Kibana

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

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

Iniciando Kibana

Ahora que ha configurado el acceso seguro y la red para Kibana, inicie y habilite el proceso.

$ sudo systemctl enable kibana --now

Verifique el estado para ver si se está ejecutando.

$ sudo systemctl status kibana
? kibana.service - Kibana
     Loaded: loaded (/lib/systemd/system/kibana.service; enabled; preset: enabled)
     Active: active (running) since Wed 2023-10-04 15:27:28 UTC; 9s ago
       Docs: https://www.elastic.co
   Main PID: 2686 (node)
      Tasks: 11 (limit: 4652)
     Memory: 241.5M
        CPU: 9.902s
     CGroup: /system.slice/kibana.service
             ??2686 /usr/share/kibana/bin/../node/bin/node /usr/share/kibana/bin/../src/cli/dist

Oct 04 15:27:28 kibana systemd[1]: Started kibana.service - Kibana.

Paso 10: instalar y configurar Filebeat

Es importante tener en cuenta que instalaremos Filebeat en el servidor de Suricata. Así que vuelva a él y agregue la clave Elastic GPG para comenzar.

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

Cree el repositorio elástico.

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

Actualice la lista de repositorios del sistema.

$ sudo apt update

Guarde el archivo presionando Ctrl + X e ingresando Y cuando se le solicite.

Instale Filebeat.

$ sudo apt install filebeat

Antes de configurar Filebeat, debemos copiar el archivo http_ca.crt del servidor Elasticsearch al servidor Filebeat. Ejecute 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 debes hacer es conectarlo al panel de Kibana. Busque la línea #host: "localhost:5601" en la sección Kibana y agregue las siguientes líneas 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, busque la sección Salida de Elasticsearch del archivo y edite los valores de hosts, protocol, username y contraseña como se muestra a continuación. Para el nombre de usuario, elija elastic como valor y, para la contraseña, use 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"
  ssl.certificate_authorities: ["/etc/filebeat/http_ca.crt"]
  ssl.verification_mode: full

. . .

Agregue la siguiente línea al final del archivo.

setup.ilm.overwrite: true

Una vez que haya terminado, guarde el archivo presionando Ctrl + X e ingresando Y cuando se le solicite. Hay un paso más para garantizar que Filebeat se conecte a Elasticsearch. Necesitamos pasar la información SSL de Elasticsearch a Filebeat para que pueda conectarse.

Pruebe la conexión desde Filebeat al servidor Elasticsearch. Se le pedirá su contraseña de Elasticsearch.

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

Obtendrá el siguiente resultado.

Enter host password for user 'elastic':
*   Trying 10.133.0.2:9200...
* Connected to 10.133.0.2 (10.133.0.2) port 9200 (#0)
* ALPN: offers h2,http/1.1
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
*  CAfile: /etc/filebeat/http_ca.crt
*  CApath: /etc/ssl/certs
* TLSv1.3 (IN), TLS handshake, Server hello (2):
* 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.3 (OUT), TLS change cipher, Change cipher spec (1):
* TLSv1.3 (OUT), TLS handshake, Finished (20):
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384
* ALPN: server did not agree on a protocol. Uses default.
* Server certificate:
*  subject: CN=kibana
*  start date: Oct  4 14:28:33 2023 GMT
*  expire date: Oct  3 14:28:33 2025 GMT
*  subjectAltName: host "10.133.0.2" matched cert's IP address!
*  issuer: CN=Elasticsearch security auto-configuration HTTP CA
*  SSL certificate verify ok.
* using HTTP/1.x
* Server auth using Basic with user 'elastic'
> GET / HTTP/1.1
> Host: 10.133.0.2:9200
> Authorization: Basic ZWxhc3RpYzpsaWZlc3Vja3M2NjIwMDI=
> User-Agent: curl/7.88.1
> Accept: */*
>
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
< HTTP/1.1 200 OK
< X-elastic-product: Elasticsearch
< content-type: application/json
< content-length: 530
<
{
  "name" : "kibana",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "KGYx4poLSxKhPyOlYrMq1g",
  "version" : {
    "number" : "8.10.2",
    "build_flavor" : "default",
    "build_type" : "deb",
    "build_hash" : "6d20dd8ce62365be9b1aca96427de4622e970e9e",
    "build_date" : "2023-09-19T08:16:24.564900370Z",
    "build_snapshot" : false,
    "lucene_version" : "9.7.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.133.0.2 left intact

A continuación, habilite el módulo Suricata integrado de Filebeat.

$ sudo filebeat modules enable suricata

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

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

Edite el archivo como se muestra a continuación. Debe cambiar el valor de la variable enabled a true. Además, descomente la variable var.paths y establezca 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"]

Una vez que haya terminado, guarde el archivo presionando Ctrl + X e ingresando Y cuando se le solicite.

El último paso en la configuración de Filebeat es cargar los paneles y canalizaciones de SIEM en Elasticsearch usando el comando filebeat setup.

$ sudo filebeat setup

Es posible que el comando tarde unos minutos en finalizar. Una vez terminado, debería recibir el siguiente resultado.

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
Loaded Ingest pipelines

Inicie el servicio Filebeat.

$ sudo systemctl start filebeat

Consultar el estado del servicio.

$ sudo systemctl status filebeat

Paso 11: acceder al panel 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 utilizar un túnel SSH al servidor de búsqueda Elastic desde su PC. Esto reenviará el puerto 5601 desde su PC a la dirección IP privada del servidor y podrá acceder a Kibana desde su 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 su servidor Suricata y usarlo como proxy inverso para acceder al servidor de Elasticsearch a través de su dirección IP privada. Discutiremos ambas formas. Puede elegir cualquier método según sus requisitos.

Usando el túnel local SSH

Si está utilizando Windows 10 o Windows 11, puede ejecutar SSH LocalTunnel desde su Windows Powershell. En Linux o macOS, puedes usar 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 computadora para crear el túnel SSH.

$ ssh -L 5601:your_private_IP:5601 navjot@your_public_IP -N
  • El indicador -L se refiere al túnel SSH local, que reenvía el tráfico desde el puerto de su PC al servidor.
  • private_IP:5601 es la dirección IP a la que se reenvía su tráfico en el servidor. En este caso, reemplácela con la dirección IP privada de su servidor Elasticsearch.
  • your_public_IP es la dirección IP pública del servidor Elasticsearch, que se utiliza para abrir una conexión SSH.
  • El indicador -N le dice a OpenSSH que no ejecute ningún comando pero que mantenga viva la conexión 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 ejecutándose mientras necesite acceder a Kibana. Pulsa Ctrl + C en tu terminal para cerrar el túnel.

Usando el proxy inverso de Nginx

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

Configurar cortafuegos

Antes de continuar, debe abrir los puertos HTTP y HTTPS en el firewall.

$ sudo ufw allow http
$ sudo ufw allow https

Instalar Nginx

Debian 12 viene con una versión anterior de Nginx. Para instalar la última versión, debe descargar el repositorio oficial de Nginx.

Importe 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

Agregue el repositorio para la versión estable de Nginx.

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

Actualizar los repositorios del sistema.

$ sudo apt update

Instale Nginx.

$ sudo apt install nginx

Verifique la instalación. Como estamos en Debian, el sudo en el comando es esencial.

$ sudo nginx -v
nginx version: nginx/1.24.0

Inicie 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. Puede instalar Certbot usando el repositorio de Debian o obtener la última versión usando la herramienta Snapd. Usaremos la versión Snapd.

Debian 12 viene sin Snapd instalado. Instale el paquete Snapd.

$ sudo apt install snapd

Ejecute los siguientes comandos para asegurarse de que su versión de Snapd esté actualizada.

$ sudo snap install core && sudo snap refresh core

Instale Certbot.

$ sudo snap install --classic certbot

Utilice el siguiente comando para asegurarse de que el comando Certbot se pueda ejecutar creando un enlace simbólico al directorio /usr/bin.

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

Confirme la instalación de Certbot.

$ certbot --version
certbot 2.7.0

Genere 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  -d kibana.example.com

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

Genere 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 bien, realice un ensayo del proceso.

$ sudo certbot renew --dry-run

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

Configurar 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. Reemplace la dirección IP con la dirección IP privada de su 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 presionando Ctrl + X e ingresando Y cuando se le solicite.

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

$ sudo nano /etc/nginx/nginx.conf

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

server_names_hash_bucket_size  64;

Guarde el archivo presionando Ctrl + X e ingresando 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

Reinicie el servicio Nginx.

$ sudo systemctl restart nginx

Se debe poder acceder a su panel de Kibana a través de la URL https://kibana.example.com desde cualquier lugar que desee.

Paso 12: Administrar los paneles de Kibana

Antes de continuar con la administración de los paneles, debe agregar el campo URL base en la configuración de Kibana.

Abra el archivo de configuración de Kibana.

$ sudo nano /etc/kibana/kibana.yml

Busque 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 presionando Ctrl + X e ingresando Y cuando se le solicite.

Reinicie el servicio Kibana.

$ sudo systemctl restart kibana

Espere unos minutos y cargue la URL https://kibana.example.com en su navegador. Obtendrá el campo del token de inscripción. Complete el token de inscripción que generó en el paso 9.

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

Vuelva a la terminal Elasticsearch y ejecute el siguiente comando para generar el código. Ingrese este código en la página y haga clic en el botón Verificar para continuar.

$ sudo /usr/local/share/kibana/bin/kibana-verification-code

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

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

Inicie sesión con el nombre de usuario elastic y la contraseña que generó antes y aparecerá la siguiente pantalla.

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

Haga clic en el primer resultado ([Filebeat Suricata] Descripción general de alertas) y aparecerá una pantalla similar a la siguiente. De forma predeterminada, muestra las entradas solo de los últimos 15 minutos, pero las mostramos en un período de tiempo mayor para mostrar más datos para el tutorial.

Haga clic en el botón 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 del origen. También puede ver los países desde donde se originó el tráfico.

Puede utilizar Kibana y Filebeat para acceder y generar otros tipos de paneles. Uno de los paneles integrados útiles que puede utilizar de inmediato es el panel de Seguridad. Haga clic en el menú Seguridad >> Explorar en el menú de hamburguesas de la izquierda.

En la página siguiente, seleccione la opción Red para abrir el panel asociado.

Al hacer clic en la opción Red aparecerá la siguiente pantalla.

Puede agregar más paneles como Nginx habilitando y configurando los módulos integrados de Filebeat.

Conclusión

Con esto concluye el tutorial para instalar y configurar Suricata IDS con Elastic Stack en un servidor Debian 12. También configuró Nginx como proxy inverso para acceder a los paneles de Kibana externamente. Si tiene alguna pregunta, publíquela en los comentarios a continuación.

Artículos relacionados: