Suricata: diferència entre les revisions

De Training B Wiki
Salta a la navegació Salta a la cerca
Cap resum de modificació
Línia 12: Línia 12:
* Una Kali para realizar los ataques.
* Una Kali para realizar los ataques.


== El servidor Docker amb l'aplicació web ==
== El servidor Docker de la aplicación web ==
El primer que prepararem és el servidor Docker. Aquest servidor ja el teniu preparat com a plantilla:
Lo primero que vamos a preparar del servidor Ubuntu es Docker para poder instalar nuestra aplicación web.


Escriptori isard: M2 EAC3 Docker
Para ello, se recomienda crear una máquina virtual Ubuntu Server con:


Plantilla feta amb:M2 EAC3 Docker Web
2 CPU
 
4 CPU


8 <abbr>GB</abbr> de RAM
8 <abbr>GB</abbr> de RAM


Xarxes: Default [DHCPv4], Personal2 [172.20.120.200/24], personal2 [172.20.121.100/24], WireguardVPN [DHCPv4]
Configuración de redes: red NAT y red interna 172.20.120.254/24
 
  ubuntu@ubuntu:~$ sudo apt update
User - Password: isard - studentIOC
  ubuntu@ubuntu:~$ sudo apt upgrade
 
  ubuntu@ubuntu:~$ sudo nano /etc/netplat/00-installer-config.yaml
Una vegada hagueu creat la màquina, la podeu arrencar, i de moment no caldrà fer res més.
 
No arranqueu docker-compose
 
Tot i així, si voleu veure com s’ha fet la plantilla, aquí teniu les instruccions que s’han seguit:
 
En el nostre cas, instal·larem un Ubuntu Server 22.04, instal·larem també un servei Docker i aixecarem una aplicació web vulnerable que es va utilitzar en el Hacketon del 2016 a NY.
 
Creem el '''M2 EAC3 Vuln Server''':
 
# Anem a Escriptori nou
# NOM: M2 EAC3 Vuln Server
# Plantilla: IOC - Ubuntu Server
# Opcions avançades:
# CPU: 2
# <abbr>GB</abbr>: 5
# Xarxes en aquest ordre: Default, PersonalIOC2, Personal2, Wireguard VPN
# Crear la màquina
 
Configuració bàsica de la màquina:
  isard@ubuntu:~$ sudo passwd isard
> studentIOC
isard@ubuntu:~$ sudo apt update
  isard@ubuntu:~$ sudo apt upgrade
  isard@ubuntu:~$ sudo nano /etc/netplat/00-installer-config.yaml
  ------ /etc/netplan/00-installer-config.yaml-------
  ------ /etc/netplan/00-installer-config.yaml-------
  # This is the network config written by 'subiquity'
  # This is the network config written by 'subiquity'
Línia 59: Línia 32:
       dhcp4: true
       dhcp4: true
     enp2s0:
     enp2s0:
       addreses: [172.20.120.200/24]
       addreses: [172.20.120.254/24]
    enp3s0:
      addreses: [172.20.121.100/24]
    enp4s0:
      dhcp4: true
   version: 2
   version: 2
  -----------------------------------------------------
  -----------------------------------------------------
  isard@ubuntu:~$ sudo netplan apply
  isard@ubuntu:~$ sudo netplan apply
Ubuntu Server instal·lem el Docker Engine (<nowiki>https://docs.docker.com/engine/install/ubuntu/</nowiki>):
Ubuntu Server instalamos el Docker Engine (<nowiki>https://docs.docker.com/engine/install/ubuntu/</nowiki>):
  # Add Docker's official GPG key:
  # Add Docker's official GPG key:
  isard@ubuntu:~$ sudo apt-get update
  ubuntu@ubuntu:~$ sudo apt-get update
  isard@ubuntu:~$ sudo apt-get install ca-certificates curl
  ubuntu@ubuntu:~$ sudo apt-get install ca-certificates curl
  isard@ubuntu:~$ sudo install -m 0755 -d /etc/apt/keyrings
  ubuntu@ubuntu:~$ sudo install -m 0755 -d /etc/apt/keyrings
  isard@ubuntu:~$ sudo curl -fsSL <nowiki>https://download.docker.com/linux/ubuntu/gpg</nowiki> -o /etc/apt/keyrings/docker.asc
  ubuntu@ubuntu:~$ sudo curl -fsSL <nowiki>https://download.docker.com/linux/ubuntu/gpg</nowiki> -o /etc/apt/keyrings/docker.asc
  isard@ubuntu:~$ sudo chmod a+r /etc/apt/keyrings/docker.asc
  ubuntu@ubuntu:~$ sudo chmod a+r /etc/apt/keyrings/docker.asc
   
   
  # Add the repository to Apt sources:
  # Add the repository to Apt sources:
  isard@ubuntu:~$ echo \
  ubuntu@ubuntu:~$ echo \
   "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] <nowiki>https://download.docker.com/linux/ubuntu</nowiki> \
   "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] <nowiki>https://download.docker.com/linux/ubuntu</nowiki> \
   $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
   $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
   sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
   sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
  isard@ubuntu:~$ sudo apt-get update
  ubuntu@ubuntu:~$ sudo apt-get update
  isard@ubuntu:~$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
  ubuntu@ubuntu:~$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Ara ja tenim instal·lat Docker i podem començar a instal·lar l’aplicació vulnerable.
Ara podemos instalar la aplicación web vulnerable:


Podeu trobar més informació de l’aplicació que instal·larem en el repositori: <nowiki>https://github.com/bocajspear1/acme-web-app</nowiki>.
Podéis encontrar más información en el repositorio: https://github.com/bocajspear1/acme-web-app
  isard@ubuntu:~$ git clone <nowiki>https://github.com/bocajspear1/acme-web-app.git</nowiki>
  ubuntu@ubuntu:~$ git clone <nowiki>https://github.com/bocajspear1/acme-web-app.git</nowiki>
  isard@ubuntu:~$ cd acme-web-app
  ubuntu@ubuntu:~$ cd acme-web-app
  isard@ubuntu:~$ sudo docker build -t acme-webapp .
  ubuntu@ubuntu:~$ sudo docker build -t acme-webapp .
  isard@ubuntu:~$ sudo docker run -p 1337:80 --rm -it --name acme-webapp-test -d -v`pwd`/app:/var/www/html acme-webapp
  ubuntu@ubuntu:~$ sudo docker run -p 1337:80 --rm -it --name acme-webapp-test -d -v`pwd`/app:/var/www/html acme-webapp
Si en algun moment se’ns atura el contenidor, o reinciem la màquina, per tornar-la a aixecar ja només caldrà fer el següent:
Si en algun momento se para el servidor, podemos volver a arrancar el sistema con:
  isard@ubuntu:~$ cd ~/acme-web-app
  ubuntu@ubuntu:~$ cd ~/acme-web-app
  isard@ubuntu:~$ sudo docker run -p 1337:80 --rm -it --name acme-webapp-test -v`pwd`/app:/var/www/html acme-webapp
  ubuntu@ubuntu:~$ sudo docker run -p 1337:80 --rm -it --name acme-webapp-test -v`pwd`/app:/var/www/html acme-webapp
I ara instal·lem Suricata, però a diferència dels anteriors exercicis, aquesta vegada utilitzarem les alertes automàtiques que tenim preconfigurades.
Y ahora instalaremos Suricata. Tenéis más información en su guía oficial https://docs.suricata.io/en/latest/quickstart.html
 
  ubuntu@suricata:~$ sudo apt-get install software-properties-common
Prepararem una instal·lació estàndard de Suricata, per fer-ho, seguirem la guia ‘quickstart’ <nowiki>https://docs.suricata.io/en/latest/quickstart.html</nowiki>
  ubuntu@suricata:~$ sudo add-apt-repository ppa:oisf/suricata-stable
  isard@suricata:~$ sudo apt-get install software-properties-common
  ubuntu@suricata:~$ sudo apt update
  isard@suricata:~$ sudo add-apt-repository ppa:oisf/suricata-stable
  ubuntu@suricata:~$ sudo apt install suricata jq
  isard@suricata:~$ sudo apt update
Comprovamos que todo esté correcto:
  isard@suricata:~$ sudo apt install suricata jq
  ubuntu@suricata:~$ sudo suricata --build-info
Ja tenim instal·lat Suricata, podem comprovar que s’ha instal·lat correctament:
  ubuntu@suricata:~$ sudo systemctl status suricata
  isard@suricata:~$ sudo suricata --build-info
  isard@suricata:~$ sudo systemctl status suricata
Ara farem les configuracions bàsiques de Suricata amb l’idea que escolti per la interfície enp3s0 (default):
Ara farem les configuracions bàsiques de Suricata amb l’idea que escolti per la interfície enp3s0 (default):
  isard@suricata:~$ ip a
  ubuntu@suricata:~$ ip a
  #Segurament, sigui enp3s0
  #Seguramente, sea enp0s8
  isard@suricata:~$ sudo nano /etc/suricata/suricata.yaml
  ubuntu@suricata:~$ sudo nano /etc/suricata/suricata.yaml
  ------/etc/suricata/suricata.yaml-----------
  ------/etc/suricata/suricata.yaml-----------
  HOME_NET: ["172.20.120.0/24]"
  HOME_NET: ["172.20.120.0/32]" #172.20.120.0/24
  ports-groups:
  ports-groups:
     HTTP_DOCKER: "1337"
     HTTP_DOCKER: "1337"
  af-packet:
  af-packet:
     - interface: enp3s0
     - interface: enp0s8
       cluster-id: 99
       cluster-id: 99
       cluster-type: cluster_flow
       cluster-type: cluster_flow
Línia 118: Línia 85:
       tpacket-v3: yes
       tpacket-v3: yes
  --------------------------------------------
  --------------------------------------------
Utilitzarem directament les configuracions per defecte del repositori que manté Emerging Threats <nowiki>https://community.emergingthreats.net/</nowiki>, només cal fer ‘sudo suricata-update’ i totes les regles s’activaran.
isard@suricata:~$ sudo suricata-update
isard@suricata:~$ sudo systemctl restart suricata
isard@suricata:~$ sudo systemctl status suricata
Per acabar, s’ha deixat preparat un docker compose:
isard@web:~$cd acme-web-app
isard@web:~/acme-web-app$ nano docker-compose.yaml
-------docker-compose.yaml--------------
version: '3.8'
 
services:
  app:
    image: acme-webapp
    container_name: acme-webapp-test
    restart: always
    stdin_open: true
    tty: true
    ports:
      - '1337:80'
    volumes:
      - "./app:/var/www/html"
    healthcheck:
      test: ["CMD-SHELL", "wget --no-verbose --tries=1 --spider <nowiki>http://localhost:80/</nowiki> || exit 1"]
      interval: 30s
      timeout: 5s
      retries: 1
---------------------------------------
# En cas de voler arrencar la màquina faríem (Ara no s'ha de fer): isard@web:~/acme-web-app$ sudo docker compose up
Ja tenim el servidor Docker preparat.


== Configuració Wazuh Server ==
D’entrada, crearem un Ubuntu Server 22.04, amb tres interfícies de xarxa i la preparem per poder treballar amb ella a través de VPN. Inicieu sessió a l’Isard i genereu la següent màquina:


M2 EAC3 Ubuntu Wazuh
Buscar arxiu /etc/suricata/rules/emerging-threats.rules i comentar.


Ubuntu Server 22.04
touch /etc/suricata/empty.rules


Template: IOC - Ubuntu Server
suricata-update add-source empty file:///etc/suricata/empty.rules


Xarxes: Default [DHCPv4], PersonalIOC2 [172.20.120.210/24], Wireguard VPN [DHCPv4]


vCPUS: 4
En esta práctica no utilizaremos las alertas de ET Emerging Threats <nowiki>https://community.emergingthreats.net/</nowiki>, pero si quisieramos...
ubuntu@suricata:~$ sudo suricata-update
ubuntu@suricata:~$ sudo systemctl restart suricata
ubuntu@suricata:~$ sudo systemctl status suricata


Memoria: 8Gb


Usuari - Contrasenya: isard - studentIOC


En entorns de producció, Wazuh separa les seves funcions en tres nodes: Index, Nodes i Dashboard, i es recomana, que cadascun estiguin aïllats. Tot i així, en entorns de proves, podem fer la instal·lació senzilla i crear-ho tot a través d’un sol node. Teniu més informació a <nowiki>https://documentation.wazuh.com/current/quickstart.html</nowiki>.


A més a més, l’indexer fa funcions molt similars a l’elasticsearch, i hi ha tutorials explicant la manera d’integrar elastic com indexer. <nowiki>https://documentation.wazuh.com/current/integrations-guide/elastic-stack/index.html</nowiki> Però nosaltres, seguirem la instal·lació estàndard:
Escaneos y defensas:
isard@wazuh:~$ curl -sO <nowiki>https://packages.wazuh.com/4.7/wazuh-install.sh</nowiki> && sudo bash ./wazuh-install.sh -a
I obtindrem el password d’administrador una vegada estigui tot instal·lat. Es recomana guardar-lo en algun arxiu per poder treballar durant la pràctica:
INFO: --- Summary ---
INFO: You can access the web interface https://<wazuh-dashboard-ip>
    User: admin
    Password: <ADMIN_PASSWORD>
INFO: Installation finished.
Però si voleu obtenir el password més endavant, es pot accedir a través de:
isard@wazuh:~$ sudo tar -O -xvf wazuh-install-files.tar wazuh-install-files/wazuh-passwords.txt
I ara ja podem veure la seva interfície gràfica a través del navegador: <nowiki>https://wazuh-dashboard-ip</nowiki>


=== Configuració alertes Suricata ===
Després, el que farem serà preparar la configuració del servidor per tal que el nostre client Suricata pugui fer arribar la informació a Wazuh.


Per fer-ho, comencem creant un grup anomenat Suricata:
Primer escaneo básico:
ubuntu@hack-ubuntu:~$ mkdir arxius
ubuntu@hack-ubuntu:~$ cd arxius
ubuntu@hack-ubuntu:~$ sudo nmap -sS -p1-10000 172.20.120.1 > first_scan.txt
#La ruta del arxiu hauria de ser: /home/isard/arxius/first_scan.txt
#Tingueu present que els escanejos poden trigar una mica.


El nom del vostre grup, és el vostre nom d’usuari, en el meu cas, jobellaga
isard@wazuh:~$ sudo /var/ossec/bin/agent_groups -a -g jobellaga -q
Afegim la següent configuració pels agents del grup ‘jobellaga’ ('''cadascú el seu nom d’usuari'''), on s’exposa que l’arxiu eve.json serà per on es llegiran les alertes:
isard@wazuh:~$ sudo nano /var/ossec/etc/shared/jobellaga/agent.conf
---------/var/ossec/etc/shared/jobellaga/agent.conf-----------
<agent_config>
  <localfile>
    <log_format>json</log_format>
    <location>/var/log/suricata/eve.json</location>
  </localfile>
</agent_config>
-------------------------------------------------------------
Però no només hem de configurar la sortida dels agents, sinó que també caldrà configurar la descodificació del json, ja que cal fer algunes modificacions:
isard@wazuh:~$ sudo nano /var/ossec/etc/decoders/local_decoder.xml
---------/var/ossec/etc/decoders/local_decoder.xml-----------
<decoder name="json">
  <prematch>^{\s*"</prematch>
</decoder>
<decoder name="json_child">
  <parent>json</parent>
  <regex type="pcre2">"src_ip":"([^"]+)"</regex>
  <order>srcip</order>
</decoder>
<decoder name="json_child">
  <parent>json</parent>
  <plugin_decoder>JSON_Decoder</plugin_decoder>
</decoder>
-------------------------------------------------------------
isard@wazuh:~$ sudo systemctl restart wazuh-manager.service
Una vegada tenim configurat el servidor, ens toca instal·lar el client de wazuh a l’ubuntu del servidor amb Docker.


== Configuracions alertes Docker ==
Primeras Rules:
Quan parlem de monitoritzar docker, ens referim tant a la monitorització del propi servei docker, com el funcionament dels microserveis que hi tenim instal·lats.
alert tcp any any -> any 1337 (msg:"Un paquest vol entrar al port 8080"; sid:2000001; rev:2)
Para descartar un paquete
drop tcp any any -> any 1337 (msg:"Un paquest vol entrar al port 8080"; sid:2000001; rev:2)


Aquesta vegada, nosaltres treballarem amb la monitorització del servei Docker com a tal, es tracta de recollir els principals esdeveniments com start, stop, pull… Però a l’hora, també generarem alertes en relació al monitoratge dels contenidaors, com l’ús de la CPU, la memòria o el tràfic de xarxa. A més, utilitzarem el mecanisme de healthcheck, que podem configurar per tal que el propi docker es monitoritzi a ell mateix <nowiki>https://docs.docker.com/reference/dockerfile/</nowiki>.
ubuntu@suricata:~$ sudo sid2rulename -r /etc/suricata/rules/suricata.rules


=== Instal·lació agent Wazuh al servidor Web ===
El primer que farem serà instal·lar l’agent wazuh del nostre servidor. Seguirem les mateixes passes que havíem fet en altres EACS de M1:


La instal·lació d’agents (clients) de wazuh és molt fàcil. Anem a l’apartat d’agents (Potser cal clicar sobre el número dels agents, o us sortirà un missatge dient que no n’hi han). Després es prem ‘Deplow new agent’.
Segundo escaneo básico:
ubuntu@hack-ubuntu:~$ mkdir arxius
ubuntu@hack-ubuntu:~$ cd arxius
ubuntu@hack-ubuntu:~$ sudo nmap -sS -p1-10000 172.20.120.1 > first_scan.txt
#La ruta del arxiu hauria de ser: /home/isard/arxius/first_scan.txt
#Tingueu present que els escanejos poden trigar una mica.


En el nostre cas, les opcions seran:


# DEB amd64
# 172.20.120.210 (Servidor Wazuh)
# Agent name: WebServer
# groups: jobellaga


I us apareixerà una comanda similar a (Atenció que potser no és igual!):
wget <nowiki>https://packages.wazuh.com/4.x/apt/pool/main/w/wazuh-agent/wazuh-agent_4.7.3-1_amd64.deb</nowiki> && sudo WAZUH_MANAGER='172.20.120.210' WAZUH_AGENT_GROUP='jobellaga' WAZUH_AGENT_NAME='WebServer' dpkg -i ./wazuh-agent_4.7.3-1_amd64.deb
La copiem al nostre servidor Suricata i la fem córrer. Després habilitem i iniciem el servei:
isard@web:~$ <- La comanda copiada de la GUI de Wazuh.
isard@web:~$ sudo systemctl daemon-reload
isard@web:~$ sudo systemctl enable wazuh-agent
isard@web:~$ sudo systemctl start wazuh-agent
Al cap d’un o dos minuts, ja hauríem de tenir el nostre agent operatiu.


=== Configurem Docker Listener ===
https://github.com/aleksibovellan/opnsense-suricata-nmaps/blob/main/local.rules
En el servidor web fem les següents configuracions:
isard@web:~$ sudo apt update
isard@web:~$ sudo apt install python3 python3-pip
isard@web:~$ sudo pip3 install docker==4.2.0 urllib3==1.26.18
isard@web:~$ sudo nano /var/ossec/etc/local_internal_options.conf
------------/var/ossec/etc/local_internal_options.conf --------
logcollector.remote_commands=1
---------------
isard@web:~$ sudo systemctl restart wazuh-agent
En el servidor wazuh:
isard@wazuh:~$ sudo nano /var/ossec/etc/shared/jobellaga/agent.conf
<nowiki>#</nowiki>Afegim a continuació de la configuració de Suricata
<nowiki>------</nowiki>/var/ossec/etc/shared/jobellaga/agent.conf--------
<agent_config>
 
  <wodle name="docker-listener">
<nowiki> </nowiki>  <interval>10m</interval>
<nowiki> </nowiki>  <attempts>5</attempts>
<nowiki> </nowiki>  <run_on_start>yes</run_on_start>
<nowiki> </nowiki>  <disabled>no</disabled>
<nowiki> </nowiki> </wodle> 
 
  <localfile>
<nowiki> </nowiki>  <log_format>command</log_format>
<nowiki> </nowiki>  <command>docker stats --format "<nowiki>{{.Container}}</nowiki> <nowiki>{{.Name}}</nowiki> <nowiki>{{.CPUPerc}}</nowiki> <nowiki>{{.MemUsage}}</nowiki> <nowiki>{{.MemPerc}}</nowiki> <nowiki>{{.NetIO}}</nowiki>" --no-stream</command>
<nowiki> </nowiki>  <alias>docker container stats</alias>
<nowiki> </nowiki>  <frequency>120</frequency>
<nowiki> </nowiki>  <out_format>$(timestamp) $(hostname) docker-container-resource: $(log)</out_format>
<nowiki> </nowiki> </localfile>
 
  <localfile>
<nowiki> </nowiki>  <log_format>command</log_format>
<nowiki> </nowiki>  <command>docker ps --format "<nowiki>{{.Image}}</nowiki> <nowiki>{{.Names}}</nowiki> <nowiki>{{.Status}}</nowiki>"</command>
<nowiki> </nowiki>  <alias>docker container ps</alias>
<nowiki> </nowiki>  <frequency>120</frequency>
<nowiki> </nowiki>  <out_format>$(timestamp) $(hostname) docker-container-health: $(log)</out_format>
<nowiki> </nowiki> </localfile>
</agent_config>
<nowiki>-------------------------------------------------------</nowiki>
Ara ens toca preparar els decoders:
isard@wazuh:~$ sudo nano /var/ossec/etc/decoders/docker_decoders.xml
<nowiki>---------</nowiki>/var/ossec/etc/decoders/docker_decoders.xml---------------
<decoder name="docker-container-resource">
<nowiki> </nowiki> <program_name>^docker-container-resource</program_name>
</decoder>
 
<decoder name="docker-container-resource-child">
<nowiki> </nowiki> <parent>docker-container-resource</parent>
<nowiki> </nowiki> <prematch>ossec: output: 'docker container stats':</prematch>
<nowiki> </nowiki> <regex>(\S+) (\S+) (\S+) (\S+) / (\S+) (\S+) (\S+) / (\S+)</regex>
<nowiki> </nowiki> <order>container_id, container_name, container_cpu_usage, container_memory_usage, container_memory_limit, container_memory_perc, container_network_rx, container_network_tx</order>
</decoder>
 
<decoder name="docker-container-health">
<nowiki> </nowiki> <program_name>^docker-container-health</program_name>
</decoder>
 
<decoder name="docker-container-health-child">
<nowiki> </nowiki> <parent>docker-container-health</parent>
<nowiki> </nowiki> <prematch>ossec: output: 'docker container ps':</prematch>
<nowiki> </nowiki> <regex offset="after_prematch" type="pcre2">(\S+) (\S+) (.*?) \((.*?)\)</regex>
<nowiki> </nowiki> <order>container_image, container_name, container_uptime, container_health_status</order>
</decoder>
<nowiki>---------------------------------------------------------</nowiki>
I creem les nostres regles:
isard@wazuh:~$ sudo nano /var/ossec/etc/rules/docker_rules.xml
<nowiki>----------</nowiki>/var/ossec/etc/rules/docker_rules.xml----------
<group name="container,">
  <rule id="100100" level="5">
<nowiki> </nowiki>  <decoded_as>docker-container-resource</decoded_as>
<nowiki> </nowiki>  <description>Docker: Container $(container_name) Resources</description>
<nowiki> </nowiki>  <group>container_resource,</group>
<nowiki> </nowiki> </rule>
 
  <rule id="100101" level="12">
<nowiki> </nowiki>  <if_sid>100100</if_sid>
<nowiki> </nowiki>  <field name="container_cpu_usage" type="pcre2">^(0*[8-9]\d|0*[1-9]\d{2,})</field>
<nowiki> </nowiki>  <field name="container_memory_perc" type="pcre2">^(0*[8-9]\d|0*[1-9]\d{2,})</field>
<nowiki> </nowiki>  <description>Docker: Container $(container_name) CPU usage ($(container_cpu_usage)) and memory usage ($(container_memory_perc)) is over 80%</description>
<nowiki> </nowiki>  <group>container_resource,</group>
<nowiki> </nowiki> </rule>
 
  <rule id="100102" level="12">
<nowiki> </nowiki>  <if_sid>100100</if_sid>
<nowiki> </nowiki>  <field name="container_cpu_usage" type="pcre2">^(0*[8-9]\d|0*[1-9]\d{2,})</field>
<nowiki> </nowiki>  <description>Docker: Container $(container_name) CPU usage ($(container_cpu_usage)) is over 80%</description>
<nowiki> </nowiki>  <group>container_resource,</group>
<nowiki> </nowiki> </rule> 
 
  <rule id="100103" level="12">
<nowiki> </nowiki>  <if_sid>100100</if_sid>
<nowiki> </nowiki>  <field name="container_memory_perc" type="pcre2">^(0*[8-9]\d|0*[1-9]\d{2,})</field>
<nowiki> </nowiki>  <description>Docker: Container $(container_name) memory usage ($(container_memory_perc)) is over 80%</description>
<nowiki> </nowiki>  <group>container_resource,</group>
<nowiki> </nowiki> </rule>
 
  <rule id="100105" level="5">
<nowiki> </nowiki>  <decoded_as>docker-container-health</decoded_as>
<nowiki> </nowiki>  <description>Docker: Container $(container_name) is $(container_health_status)</description>
<nowiki> </nowiki>  <group>container_health,</group>
<nowiki> </nowiki> </rule>
 
  <rule id="100106" level="12">
<nowiki> </nowiki>  <if_sid>100105</if_sid>
<nowiki> </nowiki>  <field name="container_health_status">^unhealthy$</field>
<nowiki> </nowiki>  <description>Docker: Container $(container_name) is $(container_health_status)</description>
<nowiki> </nowiki>  <group>container_health,</group>
<nowiki> </nowiki> </rule>
</group>
<nowiki>---------------------------------------</nowiki>
isard@wazuh:~$ sudo systemctl restart wazuh-manager
Per acabar, ja només ens falta habilitar l’escolta del Docker Listener al servidor Wazuh. Per això anem a la interfície gràfica web de Wazuh:


# Fixeu-vos en la part superior, al costat d’on posa ‘WAZUH’ veureu un desplegable, aneu a Settings>Modules
# Habiliteu ‘Docker Listener’


=== Comprovem el funcionament de Docker Listener ===
Ara comprovem que el nostre servidor web és capaç de llençar el ‘Docker Listener’:
#Podem comprovar si el DockerListener funciona
isard@web:~$  sudo /var/ossec/wodles/docker/DockerListener
<nowiki>#</nowiki>Hauria de sortir alguna cosa similar a:
{"integration": "docker", "docker": {"Wodle event": "Started"}}
Docker service was started.
Ara mateix ja tenim operatiu tot el nostre sistema d’alertes, anem a comprovar-ho. Anem a la interfície del nostre agent a ‘Security Events > Dashboard’.


Per acabar, reiniciem el wazuh-agent per si cal reiniciar alguna configuració i aixequem el servidor web i comprovem que es generen les alertes a Wazuh:
  ubuntu@suricata:~# nano /usr/local/etc/suricata/suricata.yaml
  isard@web:~/sudo systemctl restart wazuh-agent
  Cerqueu les línies: (En el meu servidor, línia 430/1813)
  isard@web:~/ cd acme-web-app
  - drop:
  isard@web:~/acme-web-app$ sudo docker compose up -d
    enabled: no
Si tot us ha anat correctament, us començaran a aparèixer les alertes que genera Docker.
  I poseu 'yes': us quedarà així:
  - drop:
    enabled: yes


== Qüestionari final i arxius finals al Parrot ==
Per poder realitzar el qüestionari final necessitareu fer servir la màquina de desplegament de Parrot. És una màquina amb les següents característiques:


Plantilla: M2 EAC3 Parrot T
Reglas encadenadas
alert http any any -> 172.20.120.1 9337 (msg: "RST is activated"; flags:R; flowbits:set, areR; sid:500; flowbits:noalert;)
 
alert http any any -> 172.20.120.1 8443 (msg: "SYN with RST is activated"; flags:R; flowbits:isset, areR; sid:501;)


Desplegament: M2 EAC3 Parrot st


CPU: 4


RAM: 8
putation.list.
root@opnsense:~/nano /usr/local/bin/badips.sh
---------/usr/local/bin/badips.sh-----------
#!/usr/bin/env bash
#agafa la ultima ip
BAD_IP=$(tail -1 /var/log/suricata/latest.log | grep -o '[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}' | tail -n2 | head -1)
#Compte quantes vegades trobem una ip
if grep $BAD_IP /usr/local/etc/suricata/iprep/reputation.list
then
echo "a"
else
  COUNT=$(cat /var/log/suricata/latest.log | grep $BAD_IP | wc -l)
  if [ $COUNT -gt 100 ]
    then
    echo "$BAD_IP,1,100" >>/usr/local/etc/suricata/iprep/reputation.list
    sleep 1
    service suricata restart
  fi
fi
--------------------------------------------
root@opnsense:~/chmod +x /usr/local/bin/badips.sh


Xarxes: Default [DHCPv4], Personal2 [172.20.121.10/24], Wireguard VPN [DHCPv4], ioc-grup4 [DHCPv4]
* Instal·lem ‘bash’ i editem l’arxiu del crontab perquè s’ho miri cada minut:


Una vegada la tingueu oberta, '''és important que canvieu el nom del hostname''' i que feu un reinici de la màquina per tal que el servidor DHCP pugui recullir el vostre nom:
root@opnsense:/pkg install bash
  #Cadascú el seu nom d'usuari
root@opnsense:~/nano /etc/crontab
  isard@parrot: sudo hostnamectl hostname jobellaga
---------/etc/crontab-----------
  isard@parrot: sudo reboot now
#minute hour    mday    month  wday    who    command
En aquest punt, ja esteu preparats per respondre el qüestionari. El qüestionari us demanarà que aneu fent certes accions amb les màquines.
#
  #Comprova si hi ha un BAD_IP
*      *      *      *      *      root    badips.sh
--------------------------------------------
 
  # I reiniciem el crontab
  root@opnsense:/etc/rc.d/cron restart


'''Una vegada ja heu acabat tot el qüestionari, cal que envieu al Parrot els següents logs'''. Sense els arxius, no es podrà acceptar les respostes del qüestionari:
* Creem una nova regla a local rules:


Del servidor Wazuh:
root@opnsense:~/nano /usr/local/etc/suricata/rules/local.rules
-----/usr/local/etc/suricata/rules/local.rules-----
drop tcp any any -> any any (msg:"Fora per IPREPUTATION"; flow:stateless; classtype:attempted-recon; iprep:src,BadHosts,>,50; sid:900001; priority:2; rev:2;)
---------------------------------------------------


/var/ossec/logs/alerts/alerts.log → Guardeu a Parrot com /home/isard/alerts.log
# Anem a l’arxiu suricata.yaml i editem tot lo del IPS i ara haurem d’habilitar les IPreputation:


Del servidor Docker web:
root@opnsense:~/nano /usr/local/etc/suricata/suricata.yaml
#Fixeu-vos, que només cal desmarcar
-----/usr/local/etc/suricata/suricata.yaml-----
# IP Reputation
reputation-categories-file: /usr/local/etc/suricata/iprep/categories.txt
default-reputation-path: /usr/local/etc/suricata/iprep
reputation-files:
  - reputation.list
# deprecated a line based information for dropped packets in IPS mode
  - drop:
  enabled: yes
---------------------------------------------------


/var/log/suricata/eve.json → Guardeu a Parrot com /home/isard/eve.json
* I preparem el directori i els arxius per l’IPREP:


/var/ossec/logs/ossec.log → Guardeu a Parrot com /home/isard/ossec.log
root@opnsense:~/mkdir /usr/local/etc/suricata/iprep
root@opnsense:~/nano /usr/local/etc/suricata/iprep/categories.txt
-----/usr/local/etc/suricata/categories.txt-----
1,BadHosts,Known bad hosts
---------------------------------------------------
root@opnsense:~/touch /usr/local/etc/suricata/iprep/reputation.list

Revisió del 17:09, 16 abr 2024

Actividad Suricata

Introducción

En esta actividad vamos a comprovar el funcionamiento de Suricata a través de su instalación y luego comprovaremos i es capaz de evitar ataques de nmap.

El sistema

Esta práctica consiste en dos máquinas

  • Un servidor Ubuntu con Docker y Suricata.
  • Una Kali para realizar los ataques.

El servidor Docker de la aplicación web

Lo primero que vamos a preparar del servidor Ubuntu es Docker para poder instalar nuestra aplicación web.

Para ello, se recomienda crear una máquina virtual Ubuntu Server con:

2 CPU

8 GB de RAM

Configuración de redes: red NAT y red interna 172.20.120.254/24

ubuntu@ubuntu:~$ sudo apt update
ubuntu@ubuntu:~$ sudo apt upgrade
ubuntu@ubuntu:~$ sudo nano /etc/netplat/00-installer-config.yaml
------ /etc/netplan/00-installer-config.yaml-------
# This is the network config written by 'subiquity'
network:
  ethernets:
    enp1s0:
      dhcp4: true
    enp2s0:
      addreses: [172.20.120.254/24]
  version: 2
-----------------------------------------------------
isard@ubuntu:~$ sudo netplan apply

Ubuntu Server instalamos el Docker Engine (https://docs.docker.com/engine/install/ubuntu/):

# Add Docker's official GPG key:
ubuntu@ubuntu:~$ sudo apt-get update
ubuntu@ubuntu:~$ sudo apt-get install ca-certificates curl
ubuntu@ubuntu:~$ sudo install -m 0755 -d /etc/apt/keyrings
ubuntu@ubuntu:~$ sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
ubuntu@ubuntu:~$ sudo chmod a+r /etc/apt/keyrings/docker.asc
 
# Add the repository to Apt sources:
ubuntu@ubuntu:~$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
ubuntu@ubuntu:~$ sudo apt-get update
ubuntu@ubuntu:~$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Ara podemos instalar la aplicación web vulnerable:

Podéis encontrar más información en el repositorio: https://github.com/bocajspear1/acme-web-app

ubuntu@ubuntu:~$ git clone https://github.com/bocajspear1/acme-web-app.git
ubuntu@ubuntu:~$ cd acme-web-app
ubuntu@ubuntu:~$ sudo docker build -t acme-webapp .
ubuntu@ubuntu:~$ sudo docker run -p 1337:80 --rm -it --name acme-webapp-test -d -v`pwd`/app:/var/www/html acme-webapp

Si en algun momento se para el servidor, podemos volver a arrancar el sistema con:

ubuntu@ubuntu:~$ cd ~/acme-web-app
ubuntu@ubuntu:~$ sudo docker run -p 1337:80 --rm -it --name acme-webapp-test -v`pwd`/app:/var/www/html acme-webapp

Y ahora instalaremos Suricata. Tenéis más información en su guía oficial https://docs.suricata.io/en/latest/quickstart.html

ubuntu@suricata:~$ sudo apt-get install software-properties-common
ubuntu@suricata:~$ sudo add-apt-repository ppa:oisf/suricata-stable
ubuntu@suricata:~$ sudo apt update
ubuntu@suricata:~$ sudo apt install suricata jq

Comprovamos que todo esté correcto:

ubuntu@suricata:~$ sudo suricata --build-info
ubuntu@suricata:~$ sudo systemctl status suricata

Ara farem les configuracions bàsiques de Suricata amb l’idea que escolti per la interfície enp3s0 (default):

ubuntu@suricata:~$ ip a
#Seguramente, sea enp0s8
ubuntu@suricata:~$ sudo nano /etc/suricata/suricata.yaml
------/etc/suricata/suricata.yaml-----------
HOME_NET: ["172.20.120.0/32]"  #172.20.120.0/24
ports-groups:
    HTTP_DOCKER: "1337"
af-packet:
    - interface: enp0s8
      cluster-id: 99
      cluster-type: cluster_flow
      defrag: yes
      use-mmap: yes
      tpacket-v3: yes
--------------------------------------------


Buscar arxiu /etc/suricata/rules/emerging-threats.rules i comentar.

touch /etc/suricata/empty.rules

suricata-update add-source empty file:///etc/suricata/empty.rules


En esta práctica no utilizaremos las alertas de ET Emerging Threats https://community.emergingthreats.net/, pero si quisieramos...

ubuntu@suricata:~$ sudo suricata-update
ubuntu@suricata:~$ sudo systemctl restart suricata
ubuntu@suricata:~$ sudo systemctl status suricata



Escaneos y defensas:


Primer escaneo básico:

ubuntu@hack-ubuntu:~$ mkdir arxius
ubuntu@hack-ubuntu:~$ cd arxius
ubuntu@hack-ubuntu:~$ sudo nmap -sS -p1-10000 172.20.120.1 > first_scan.txt
#La ruta del arxiu hauria de ser: /home/isard/arxius/first_scan.txt
#Tingueu present que els escanejos poden trigar una mica.


Primeras Rules:

alert tcp any any -> any 1337 (msg:"Un paquest vol entrar al port 8080"; sid:2000001; rev:2)

Para descartar un paquete

drop tcp any any -> any 1337 (msg:"Un paquest vol entrar al port 8080"; sid:2000001; rev:2)
ubuntu@suricata:~$ sudo sid2rulename -r /etc/suricata/rules/suricata.rules


Segundo escaneo básico:

ubuntu@hack-ubuntu:~$ mkdir arxius
ubuntu@hack-ubuntu:~$ cd arxius
ubuntu@hack-ubuntu:~$ sudo nmap -sS -p1-10000 172.20.120.1 > first_scan.txt
#La ruta del arxiu hauria de ser: /home/isard/arxius/first_scan.txt
#Tingueu present que els escanejos poden trigar una mica.



https://github.com/aleksibovellan/opnsense-suricata-nmaps/blob/main/local.rules


ubuntu@suricata:~# nano /usr/local/etc/suricata/suricata.yaml
Cerqueu les línies: (En el meu servidor, línia 430/1813)
 - drop:
    enabled: no
I poseu 'yes': us quedarà així:
 - drop:
    enabled: yes


Reglas encadenadas

alert http any any -> 172.20.120.1 9337 (msg: "RST is activated"; flags:R; flowbits:set, areR; sid:500; flowbits:noalert;)
 
alert http any any -> 172.20.120.1 8443 (msg: "SYN with RST is activated"; flags:R; flowbits:isset, areR; sid:501;)


putation.list.

root@opnsense:~/nano /usr/local/bin/badips.sh
---------/usr/local/bin/badips.sh-----------
#!/usr/bin/env bash
#agafa la ultima ip
BAD_IP=$(tail -1 /var/log/suricata/latest.log | grep -o '[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}' | tail -n2 | head -1)
#Compte quantes vegades trobem una ip
if grep $BAD_IP /usr/local/etc/suricata/iprep/reputation.list
then
echo "a"
else
  COUNT=$(cat /var/log/suricata/latest.log | grep $BAD_IP | wc -l)
  if [ $COUNT -gt 100 ]
    then
    echo "$BAD_IP,1,100" >>/usr/local/etc/suricata/iprep/reputation.list
    sleep 1
    service suricata restart
  fi
fi
--------------------------------------------
root@opnsense:~/chmod +x /usr/local/bin/badips.sh
  • Instal·lem ‘bash’ i editem l’arxiu del crontab perquè s’ho miri cada minut:
root@opnsense:/pkg install bash
root@opnsense:~/nano /etc/crontab
---------/etc/crontab-----------
#minute hour    mday    month   wday    who     command
#
#Comprova si hi ha un BAD_IP
*       *       *       *       *       root    badips.sh
--------------------------------------------
 
# I reiniciem el crontab
root@opnsense:/etc/rc.d/cron restart
  • Creem una nova regla a local rules:
root@opnsense:~/nano /usr/local/etc/suricata/rules/local.rules
-----/usr/local/etc/suricata/rules/local.rules-----
drop tcp any any -> any any (msg:"Fora per IPREPUTATION"; flow:stateless; classtype:attempted-recon; iprep:src,BadHosts,>,50; sid:900001; priority:2; rev:2;)
---------------------------------------------------
  1. Anem a l’arxiu suricata.yaml i editem tot lo del IPS i ara haurem d’habilitar les IPreputation:
root@opnsense:~/nano /usr/local/etc/suricata/suricata.yaml
#Fixeu-vos, que només cal desmarcar
-----/usr/local/etc/suricata/suricata.yaml-----
# IP Reputation
reputation-categories-file: /usr/local/etc/suricata/iprep/categories.txt
default-reputation-path: /usr/local/etc/suricata/iprep
reputation-files:
 - reputation.list
# deprecated a line based information for dropped packets in IPS mode
 - drop:
  enabled: yes
---------------------------------------------------
  • I preparem el directori i els arxius per l’IPREP:
root@opnsense:~/mkdir /usr/local/etc/suricata/iprep
root@opnsense:~/nano /usr/local/etc/suricata/iprep/categories.txt
-----/usr/local/etc/suricata/categories.txt-----
1,BadHosts,Known bad hosts
---------------------------------------------------
root@opnsense:~/touch /usr/local/etc/suricata/iprep/reputation.list