Instalación y uso básico de detectores de intrusiones (Suricata)

SSI 2022/23


Índice General

1 Entorno de prácticas

1.1 Software de virtualización VIRTUALBOX

En estas prácticas se empleará el software de virtualización VIRTUALBOX para simular los equipos GNU/Linux sobre los que se realizarán las pruebas.

1.2 Imágenes a utilizar

  1. Scripts de instalación

    Notas:

  2. Imágenes descargadas

  3. Usuarios configurados e inicio en el sistema

1.3 Máquinas virtuales y redes creadas

Redes donde se realizarán los ejercicios:

1.4 Pasos previos

2 Instalación y configuración del IDS Suricata

2.1 Suricata IDS

Web Suricata: https://suricata.io/ Web SNORT (otro IDS Open Source): https://www.snort.org/

2.2 Pasos a seguir

  1. Actualizar la lista de paquetes e instalar suricata (ya hecho en la MV de prácticas) 
    ids:~/# apt-get update
ids:~/#	apt-get install suricata suricata-update     # (ya hecho)

  2. Habilitar arranque suricata e iniciar el servicio 
    ids:~/# systemctl enable suricata
ids:~/# systemctl start suricata

  3. Forzar la descarga de última versión de las reglas libres de https://rules.emergingthreats.net/Se usará suricata-update (manual en https://suricata.readthedocs.io/en/suricata-6.0.9/rule-management/suricata-update.html y https://suricata-update.readthedocs.io/en/latest/index.html) 

    ids:~# suricata-update list-sources
ids:~# suricata-update -v

  4. Ajustar la configuración de Suricata al escenario planteado. 
    ids:~# cd /etc/suricata
ids:/etc/suricata# nano suricata.yaml

  5. Indicar el directorio con las reglas descargadas por suricata-update 
    ...
##
## Configure Suricata to load Suricata-Update managed rules.
##

default-rule-path: /var/lib/suricata/rules  <----- CAMBIAR  AQUI

rule-files:
  - suricata.rules

##
## Auxiliary configuration files.
##
classification-file: /etc/suricata/classification.config
reference-config-file: /etc/suricata/reference.config
# threshold-file: /etc/suricata/threshold.config
...

  6. Reiniciar el demonio Suricata 
    ids:/etc/suricata# systemctl restart suricata

    Se puede verificar la carga del IDS revisando /var/log/suricata/suricata.log 

    ids:/etc/suricata# tail /var/log/suricata/suricata.log
24/11/2022 -- 15:16:43 - <Notice> - This is Suricata version 6.0.1 RELEASE running in SYSTEM mode
24/11/2022 -- 15:16:43 - <Info> - CPUs/cores online: 2
24/11/2022 -- 15:16:43 - <Info> - Found an MTU of 1500 for 'enp0s8'
24/11/2022 -- 15:16:43 - <Info> - Found an MTU of 1500 for 'enp0s8'
24/11/2022 -- 15:16:43 - <Info> - fast output device (regular) initialized: fast.log
24/11/2022 -- 15:16:43 - <Info> - eve-log output device (regular) initialized: eve.json
24/11/2022 -- 15:16:43 - <Info> - stats output device (regular) initialized: stats.log
24/11/2022 -- 15:16:51 - <Info> - 1 rule files processed. 28866 rules successfully loaded, 0 rules failed
24/11/2022 -- 15:16:51 - <Info> - Threshold config parsed: 0 rule(s) found
24/11/2022 -- 15:16:52 - <Info> - 28869 signatures processed. 1140 are IP-only rules, 5143 are inspecting packet payload, 22388 inspect application layer, 104 are decoder event only

3 Comprobación del funcionamiento del IDS

Previo: Para visualizar las alertas del fichero eve.json se usará la herramienta jq, un pretty printer para datos en formato JSON (ya hecho en MV de prácticas) 
ids:~# apt-get install jq     # (ya hecho)

En un terminal propio dejar en ejecución el comando jq sobre la salida del fichero de log /var/log/suricata/eve.log para ver la evolución de las alertas detectadas 

ids:~# tail -f /var/log/suricata/eve.json  | jq  'select(.event_type=="alert")'

3.1 Detección de PING y escaneo de puertos

  1. Lanzar el comando Ping desde la máquina openvas hacia la máquina victima 
    openvas~# ping victima.ssi.net

  2. Lanzar un escaneo de puertos completo con NMAP desde la máquina openvas hacia la máquina victima 
    openvas~# nmap -sV -O  -T4 victima.ssi.net
  3. Comprobar las alertas en los ficheros de log de Suricata en la máquina ids 
    ids~# tail -f /var/log/suricata/fast.log

ids~# tail -f /var/log/suricata/eve.json

(MEJORA: alertas filtradas/visualizadas con jq)
ids~# tail -f /var/log/suricata/eve.json | jq  'select(.event_type=="alert")'

3.2 Ejemplo de creación de reglas propias

  1. Ejemplo con tráfico UDP (sin conexión)

    Se usará la librería Pyhton Scapy para generar paquetes que fuercen la activación de las alertas definidas.

    1. Crear en un fichero /etc/suricata/rules/local.rules una regla Snort para capturar un paquete UDP con un Payload concreto. 
      ids:/etc/suricatas# nano /etc/suricata/rules/local.rules
			
alert udp $HOME_NET any -> $EXTERNAL_NET 3333 (
			msg: "Prueba SSI con UDP"; 
			content: "ho ho ho"; 
			flow:to_server; 
			nocase; 
			sid:9000001;)

      Importante: todos los elementos de la regla deben de ir en una única línea

      Más detalles sobre formato de reglas SNORT/Suricata:

    2. Ajustar la configuración de reglas de Suricata para que carge ese fichero /etc/suricata/rules/local.rules con reglas propias 
      ids:/etc/suricatas# nano /etc/suricata/suricata.yaml

...
##
## Configure Suricata to load Suricata-Update managed rules.
##

default-rule-path: /var/lib/suricata/rules

rule-files:
  - suricata.rules
  - /etc/suricata/rules/local.rules    <----- AÑADIR  AQUI

...

    3. Reiniciar Suricata 
      ids:/etc/suricata# systemctl restart suricata

    4. Desde la máquina victima usar Scapy para generar un paquete UDP que encaje con la regla creada 
      victima:~# scapy

>>> ip=IP()
>>> ip.src="192.168.100.111"
>>> ip.dst="193.147.87.47"

>>> udp=UDP()
>>> udp.dport=3333
>>> udp.sport=11111

>>> payload="ho ho ho los reyes magos son los padres"

>>> paquete = ip/udp/payload
>>> paquete.show()

>>> send(paquete)

>>> exit()
    5. Verificar en fast.log y eve.json de la máquina ids la captura del tráfico generado

      Puede buscarse directamente en eve.json los registros para el "signature_id":9000001 

      ids:# grep "9000001" /var/log/suricata/eve.json| jq

      Nota: En ocasiones la actualización de ambos ficheros no es inmediata.

      • Puede forzarse la escritura de los ficheros reiniciando el demonio de Suricata con systemctl restart suricata

  2. Ejemplo con tráfico TCP (con conexión)

    Uso de nc (netcat) para simular servidores y clientes.

    1. Añadir una nueva regla en local.rules (todo en la misma línea) 
      ids:/etc/suricatas# nano /etc/suricata/rules/local.rules
	
...
alert tcp $EXTERNAL_NET any -> $HOME_NET 4444 (
                                   msg:"prueba SSI tcp"; 
                                   content: "feliz navidad"; 
                                   flow:to_server,established; 
                                   nocase; 
                                   sid:9000002;)
    2. Reniciar Suricata 
      ids:/etc/suricata# systemctl restart suricata
      Importante: todos los elementos de la regla deben de ir en una única línea
    3. Simular un servidor en victima y un cliente en openvas que genere tráfico para activar la regla anterior. 
      victima:~# nc -l -p 4444


openvas:~# nc victima.ssi.net 4444
               (escribir en el terminal feliz navidad)

    4. Verificar en fast.log y eve.json de la máquina ids la captura del tráfico generado 
      ids:# grep "9000002" /var/log/suricata/eve.json| jq

3.3 Generación de tráfico para reglas EemergingThreats

Comprobación de las reglas opensource https://rules.emergingthreats.net/

3.3.1 Reglas emerging-user_agents.rules

Capturan peticiones HTTP con valores UserAgent sospechosos.

  1. Revisar fichero de reglas /var/lib/suricata/rules/suricata.rules 
    ids:# grep "sid:2017067" /var/lib/suricata/rules/suricata.rules

alert http $HOME_NET any -> $EXTERNAL_NET any (msg:"ET USER_AGENTS Suspicious user agent (Google page)"; 
                          flow:to_server,established; content:"Google page"; depth:11; http_user_agent; 
                          classtype:trojan-activity; sid:2017067; rev:5; 
                          metadata:created_at 2011_05_31, updated_at 2011_05_31;)

ids:# grep "sid:2026520" /var/lib/suricata/rules/suricata.rules

alert http $HOME_NET any -> $EXTERNAL_NET any (msg:"ET USER_AGENTS Suspicious User-Agent (Windows 8)"; 
                          flow:to_server,established; content:"Windows 8"; depth:9; http_user_agent; 
                          metadata: former_category USER_AGENTS; classtype:bad-unknown; sid:2026520; rev:1; 
                          ...
                          updated_at 2018_10_18;)

ids:# grep "sid:2025889" /var/lib/suricata/rules/suricata.rules

alert http $HOME_NET any -> $EXTERNAL_NET any (msg:"ET USER_AGENTS VPNFilter Related UA (Gemini/2.0)"; 
                          flow:established,to_server; content:"Gemini/2.0"; http_user_agent; depth:10; 
                          fast_pattern; isdataat:!1,relative; metadata: former_category USER_AGENTS; 
                          reference:url,twitter.com/m0rb/status/1021626709307805696; 
                          classtype:trojan-activity; sid:2025889; rev:1; ...;)

ids:# grep "sid:2008603" /var/lib/suricata/rules/suricata.rules

alert http $HOME_NET any -> $EXTERNAL_NET any (msg:"ET USER_AGENTS Suspicious User-Agent Detected (RLMultySocket)"; 
                          flow:established,to_server; content:"RLMultySocket"; http_user_agent; depth:13; 
                          isdataat:!1,relative; threshold:type limit,count 2,track by_src,seconds 300; 
                          metadata: former_category TROJAN; reference:url,doc.emergingthreats.net/bin/view/Main/2008603; 
                          classtype:trojan-activity; sid:2008603; rev:9; ...;)...
  2. Generar peticiones HTTP usando CURL desde la máquina vicitima hacia openvas con los valores UserAgent sospechosos (parámetro -A). 

    victima:~# curl --user-agent "Google page"   openvas.ssi.net
victima:~# curl --user-agent "Windows 8"     openvas.ssi.net
victima:~# curl --user-agent "Gemini/2.0"    openvas.ssi.net
victima:~# curl --user-agent "RLMultySocket" openvas.ssi.net

  3. Verificar en fast.log y eve.json de la máquina ids la captura del tráfico generado 
    ids:# grep "2017067" /var/log/suricata/eve.json| jq 
ids:# grep "2026520" /var/log/suricata/eve.json| jq 
ids:# grep "2025889" /var/log/suricata/eve.json| jq 
ids:# grep "2008603" /var/log/suricata/eve.json| jq

3.3.2 Reglas con contenido binario

  1. Reglas para detectar el envío de código de exploits 
    ids:# grep "sid:2000488" /var/lib/suricata/rules/suricata.rules

alert tcp $EXTERNAL_NET any -> $SQL_SERVERS 1433 (msg:"ET EXPLOIT MS-SQL SQL Injection closing string plus line comment"; 
                              flow: to_server,established; 
                              content:"'|00|"; content:"-|00|-|00|"; 
                              reference:url,owasp.org/index.php/SQL_Injection; reference:url,doc.emergingthreats.net/bin/view/Main/2000488; 
                              classtype:attempted-user; sid:2000488; rev:7;...;)


victima:~# nc -l -p 1433       (simula un servidor MS-SQL en el puerto 1433)

openvas:~# echo -e "'\x00     -\x00-\x00" | nc victima.ssi.net 1433   [control+C]

  2. Reglas para servidores de BD 
    ids:# grep "sid:2101775" /var/lib/suricata/rules/suricata.rules

alert tcp $EXTERNAL_NET any -> $SQL_SERVERS 3306 (msg:"GPL SQL MYSQL root login attempt"; 
                              flow:to_server,established; 
                              content:"|0A 00 00 01 85 04 00 00 80|root|00|"; 
                              classtype:protocol-command-decode; 
                              sid:2101775; rev:4; metadata:created_at 2010_09_23, updated_at 2010_09_23;)


victima:~# systemctl stop mysqld
victima:~# nc -l -p  3306

openvas:~# echo -e "\x0A\x00\x00\x01\x85\x04\x00\x00\x80root\x00" | nc victima.ssi.net 3306
  3. Verificar en fast.log y eve.json de la máquina ids la captura del tráfico generado

3.3.3 Reglas con shellcode

  1. Localizar la regla a utilizar (con sid=2012090) y generar tráfico 
    ids:# grep "sid:2012090" /var/lib/suricata/rules/suricata.rules

alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SHELLCODE Possible Call with No Offset TCP Shellcode"; 
                           flow:established; 
                           content:"|E8 00 00 00 00 0F 1A|";
                           reference:url,www.networkforensics.com/2010/05/16/network-detection-of-x86-buffer-overflow-shellcode/; 
                           classtype:shellcode-detect; sid:2012090; ...;)

victima:~# nc -l -p 9999

openvas:~# echo -e "\xE8\x00\x00\x00\x00\x0F\x1A" | nc victima.ssi.net 9999
    Nota: En caso de que la regla con sid=2012090 no estuviera activada, descometarla y reiniciar Suricata.

  2. Verificar en fast.log y eve.json de la máquina ids la captura del tráfico generado

4 TAREA ENTREGABLE


4.1 Tareas a realizar

  1. Documentar las pruebas realizas con Suricata en el ejemplo. Para cada una de las reglas empleadas:

    Documentación adicional:

Entrega (individual o en parejas):