Instalación y uso básico de detectores de intrusiones (Suricata) y herramientas de análisis de vulnerabilidades (OpenVAS)

SSI 2018/19


Í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-ids.org/ Web SNORT (otro IDS Open Source): https://www.snort.org/

2.2 Pasos a seguir

  1. Habilitar el repositiorio backports de Debian 9, para instalar la última versión disponible de Suricata (v 4.0)
    ids:~/# echo "deb http://ftp.debian.org/debian stretch-backports main" >> /etc/apt/sources.list
    

  2. Actualizar la lista de paquetes e instalar suricata y
    ids:~/# apt-get update
    ids:~/#	apt-get install suricata suricata-oinkmaster -t stretch-backports
    

  3. Forzar la descarga de las reglas libres de https://rules.emergingthreats.net/
    ids:~# suricata-oinkmaster-updater
    

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

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

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
ids:~# apt-get install jq

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  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: 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. Añadir a la configuración de Suricata la carga de un fichero local.rules con reglas propias
      ids:/etc/suricatas# nano /etc/suricata/suricata.yaml
      
      ...
      ##
      ## Step 2: select the rules to enable or disable
      ##
      
      default-rule-path: /etc/suricata/rules
      rule-files:
        - local.rules                  <----- AÑADIR  AQUI
        - botcc.rules
        # - botcc.portgrouped.rules
        - ciarmy.rules
        - compromised.rules
      ...
      

    2. Crear 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:

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

    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

      Nota: 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.service

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

3.3 Generación de tráfico para reglas EemergingThreats

Descarga de reglas: https://rules.emergingthreats.net/

3.3.1 Reglas emerging-user_agents.rules

Capturan peticiones HTTP con valores UserAgent sospechosos.

  1. Revisar fichero de reglas /etc/suricata/rules/emerging-user_agents.rules
    ids:~# leafpad /etc/suricata/rules/emerging-user_agents.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;)
    ...
    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;)
    ...
    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; ...;)
    ...
    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 -A "Google page"   openvas.ssi.net
    victima:~# curl -A "Windows 8"     openvas.ssi.net
    victima:~# curl -A "Gemini/2.0"    openvas.ssi.net
    victima:~# curl -A "RLMultySocket" openvas.ssi.net
    

    Nota 1: Asegurar que en la máquina openvas está en ejecución el servidor web Apache (y reniciarlo si es necesario)

    openvas:~# systemctl status apache2.service
    
    openvas:~# systemctl restart apache2.service   (si Apache estaba parado)
    

    Nota 2: También es posible detener el servidor web Apache poner el comando nc en modo escucha en el puerto 80

    openvas:~# systemctl stop apache2.service
    	
    openvas:~# nc -l -p 80
    

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

3.3.2 Reglas con contenido binario

  1. Reglas para detectar el envío de código de exploits
    ids:~# leafpad /etc/suricata/rules/emerging-exploit.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
    
    openvas:~# echo -e "'\x00     -\x00-\x00" | nc victima.ssi.net 1433
    

  2. Reglas para servidores de BD
    ids:~# leafpad /etc/suricata/rules/emerging-sql.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.service
    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 Habilitar ficheros de reglas

  1. Habilitar (descomentar) reglas emerging-shellcode.rules en suricata.yaml y reiniciar IDS.
    ids:~# leafpad /etc/suricata/suricata.yaml
    
    ...
    ##
    ## Step 2: select the rules to enable or disable
    ##
    
    default-rule-path: /etc/suricata/rules
    rule-files:
     - local.rules
     - botcc.rules
     ...
     - emerging-scan.rules
     - emerging-shellcode.rules       <--- descomentar aqui
     - emerging-smtp.rules
     - emerging-snmp.rules
     - emerging-sql.rules
     ...
    ...
    

    ids:/etc/suricata# systemctl restart suricata.service
    

  2. Verificar regla a activar y generar tráfico
    ids:~# leafpad /etc/suricata/rules/emerging-shellcode.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
    
  3. 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. Seleccionar tres reglas (ver /etc/suricata/rules/) y generar una serie de paquetes que fuercen su activación (con Scapy, con nc o directamente con los servidores y clientes adecuados)

  2. Comprobar la detección de ese tipo de tráfico por parte de Suricata en sus ficheros de log
  3. Importante: al menos una de las reglas seleccionadas debe requerir tráfico en binario

4.2 Documentación a entregar

5 Ejemplo EXTRA: Instalación y uso del escaner de vulnerabilidades OpenVAS (no entregable)

Web OpenVAS: http://www.openvas.org/

<pendiente>