Suricata

De Training B Wiki
La revisió el 16:37, 16 abr 2024 per Josepmariabella (discussió | contribucions) (Es crea la pàgina amb « = Actividad Suricata = == Introducció == En l’últim EAC vam estar treballant amb Suricata, com una de les eines que tenim al nostre abast per la implantació de mesures de protecció a nivell de capa 3 i 4 en la xarxa perimetral. Tanmateix, ja hem vist a M1 com podem capturar aquestes alertes de Suricata i enviar-les a un SIEM tipus Wazuh pel seu tractament com incidència. En aquest EAC, l’objectiu és poder fortificar a través de la monitorització la...».)
(dif.) ← Versió més antiga | Versió actual (dif.) | Versió més nova → (dif.)
Salta a la navegació Salta a la cerca

Actividad Suricata

Introducció

En l’últim EAC vam estar treballant amb Suricata, com una de les eines que tenim al nostre abast per la implantació de mesures de protecció a nivell de capa 3 i 4 en la xarxa perimetral. Tanmateix, ja hem vist a M1 com podem capturar aquestes alertes de Suricata i enviar-les a un SIEM tipus Wazuh pel seu tractament com incidència.

En aquest EAC, l’objectiu és poder fortificar a través de la monitorització la plataforma Docker. Wazuh, a través dels seus agents, és capaç de recollir els estats de Dockers, els seus esdeveniments, i generar l’alerta per tal que l’equip de Blue Team hi pugui treballar.

Avaluació

L’avaluació d’aquesta pràctica es realitza a través del qüestionari que teniu a l’aula, i només una pregunta, us demana recollir una evidència informàtica a través de .pcap o captures de pantalla.

Tot i així, durant el qüestionari i durant la pràctica, es requereix deixar evidències de la vostra realització en la màquina Parrot. Sense les evidències a la vostra màquina Parrot, no podrem fer efectiva la vostra avaluació.

El sistema de l'EAC 3

L’EAC 3 consta de tres màquines:

  • Un servidor Ubuntu amb docker on instal·larem l’agent de Wazuh.
  • El servidor Ubuntu amb on instal·larem Wazuh.
  • Un client Parrot, que serà la única màquina desplegada pel professorat. (Comproveu que teniu visible M2 EAC3 Parrot st)

El servidor Docker amb l'aplicació web

El primer que prepararem és el servidor Docker. Aquest servidor ja el teniu preparat com a plantilla:

Escriptori isard: M2 EAC3 Docker

Plantilla feta amb:M2 EAC3 Docker Web

4 CPU

8 GB de RAM

Xarxes: Default [DHCPv4], Personal2 [172.20.120.200/24], personal2 [172.20.121.100/24], WireguardVPN [DHCPv4]

User - Password: isard - studentIOC

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:

  1. Anem a Escriptori nou
  2. NOM: M2 EAC3 Vuln Server
  3. Plantilla: IOC - Ubuntu Server
  4. Opcions avançades:
  5. CPU: 2
  6. GB: 5
  7. Xarxes en aquest ordre: Default, PersonalIOC2, Personal2, Wireguard VPN
  8. 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-------
# This is the network config written by 'subiquity'
network:
  ethernets:
    enp1s0:
      dhcp4: true
    enp2s0:
      addreses: [172.20.120.200/24]
    enp3s0:
      addreses: [172.20.121.100/24]
    enp4s0:
      dhcp4: true
  version: 2
-----------------------------------------------------
isard@ubuntu:~$ sudo netplan apply

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

# Add Docker's official GPG key:
isard@ubuntu:~$ sudo apt-get update
isard@ubuntu:~$ sudo apt-get install ca-certificates curl
isard@ubuntu:~$ sudo install -m 0755 -d /etc/apt/keyrings
isard@ubuntu:~$ sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
isard@ubuntu:~$ sudo chmod a+r /etc/apt/keyrings/docker.asc
 
# Add the repository to Apt sources:
isard@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
isard@ubuntu:~$ sudo apt-get update
isard@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.

Podeu trobar més informació de l’aplicació que instal·larem en el repositori: https://github.com/bocajspear1/acme-web-app. 

isard@ubuntu:~$ git clone https://github.com/bocajspear1/acme-web-app.git
isard@ubuntu:~$ cd acme-web-app
isard@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

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: 

isard@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

I ara instal·lem Suricata, però a diferència dels anteriors exercicis, aquesta vegada utilitzarem les alertes automàtiques que tenim preconfigurades.

Prepararem una instal·lació estàndard de Suricata, per fer-ho, seguirem la guia ‘quickstart’ https://docs.suricata.io/en/latest/quickstart.html 

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

Ja tenim instal·lat Suricata, podem comprovar que s’ha instal·lat correctament: 

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): 

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

Utilitzarem directament les configuracions per defecte del repositori que manté Emerging Threats https://community.emergingthreats.net/, 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 http://localhost:80/ || 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

Ubuntu Server 22.04

Template: IOC - Ubuntu Server

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

vCPUS: 4

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 https://documentation.wazuh.com/current/quickstart.html.

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. https://documentation.wazuh.com/current/integrations-guide/elastic-stack/index.html Però nosaltres, seguirem la instal·lació estàndard: 

isard@wazuh:~$ curl -sO https://packages.wazuh.com/4.7/wazuh-install.sh && 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: https://wazuh-dashboard-ip

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:

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

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.

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 https://docs.docker.com/reference/dockerfile/.

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

En el nostre cas, les opcions seran:

  1. DEB amd64
  2. 172.20.120.210 (Servidor Wazuh)
  3. Agent name: WebServer
  4. groups: jobellaga

I us apareixerà una comanda similar a (Atenció que potser no és igual!): 

wget https://packages.wazuh.com/4.x/apt/pool/main/w/wazuh-agent/wazuh-agent_4.7.3-1_amd64.deb && 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

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
#Afegim a continuació de la configuració de Suricata
------/var/ossec/etc/shared/jobellaga/agent.conf--------
<agent_config>
 
  <wodle name="docker-listener">
    <interval>10m</interval>
    <attempts>5</attempts>
    <run_on_start>yes</run_on_start>
    <disabled>no</disabled>
  </wodle>  
 
  <localfile>
    <log_format>command</log_format>
    <command>docker stats --format "{{.Container}} {{.Name}} {{.CPUPerc}} {{.MemUsage}} {{.MemPerc}} {{.NetIO}}" --no-stream</command>
    <alias>docker container stats</alias>
    <frequency>120</frequency>
    <out_format>$(timestamp) $(hostname) docker-container-resource: $(log)</out_format>
  </localfile>
 
  <localfile>
    <log_format>command</log_format>
    <command>docker ps --format "{{.Image}} {{.Names}} {{.Status}}"</command>
    <alias>docker container ps</alias>
    <frequency>120</frequency>
    <out_format>$(timestamp) $(hostname) docker-container-health: $(log)</out_format>
  </localfile>
</agent_config>
-------------------------------------------------------

Ara ens toca preparar els decoders: 

isard@wazuh:~$ sudo nano /var/ossec/etc/decoders/docker_decoders.xml
---------/var/ossec/etc/decoders/docker_decoders.xml---------------
<decoder name="docker-container-resource">
  <program_name>^docker-container-resource</program_name>
</decoder>
 
<decoder name="docker-container-resource-child">
  <parent>docker-container-resource</parent>
  <prematch>ossec: output: 'docker container stats':</prematch>
  <regex>(\S+) (\S+) (\S+) (\S+) / (\S+) (\S+) (\S+) / (\S+)</regex>
  <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">
  <program_name>^docker-container-health</program_name>
</decoder>
 
<decoder name="docker-container-health-child">
  <parent>docker-container-health</parent>
  <prematch>ossec: output: 'docker container ps':</prematch>
  <regex offset="after_prematch" type="pcre2">(\S+) (\S+) (.*?) \((.*?)\)</regex>
  <order>container_image, container_name, container_uptime, container_health_status</order>
</decoder>
---------------------------------------------------------

I creem les nostres regles: 

isard@wazuh:~$ sudo nano /var/ossec/etc/rules/docker_rules.xml
----------/var/ossec/etc/rules/docker_rules.xml----------
<group name="container,">
  <rule id="100100" level="5">
    <decoded_as>docker-container-resource</decoded_as>
    <description>Docker: Container $(container_name) Resources</description>
    <group>container_resource,</group>
  </rule>
 
  <rule id="100101" level="12">
    <if_sid>100100</if_sid>
    <field name="container_cpu_usage" type="pcre2">^(0*[8-9]\d|0*[1-9]\d{2,})</field>
    <field name="container_memory_perc" type="pcre2">^(0*[8-9]\d|0*[1-9]\d{2,})</field>
    <description>Docker: Container $(container_name) CPU usage ($(container_cpu_usage)) and memory usage ($(container_memory_perc)) is over 80%</description>
    <group>container_resource,</group>
  </rule>
 
  <rule id="100102" level="12">
    <if_sid>100100</if_sid>
    <field name="container_cpu_usage" type="pcre2">^(0*[8-9]\d|0*[1-9]\d{2,})</field>
    <description>Docker: Container $(container_name) CPU usage ($(container_cpu_usage)) is over 80%</description>
    <group>container_resource,</group>
  </rule>  
 
  <rule id="100103" level="12">
    <if_sid>100100</if_sid>
    <field name="container_memory_perc" type="pcre2">^(0*[8-9]\d|0*[1-9]\d{2,})</field>
    <description>Docker: Container $(container_name) memory usage ($(container_memory_perc)) is over 80%</description>
    <group>container_resource,</group>
  </rule>
 
  <rule id="100105" level="5">
    <decoded_as>docker-container-health</decoded_as>
    <description>Docker: Container $(container_name) is $(container_health_status)</description>
    <group>container_health,</group>
  </rule>
 
  <rule id="100106" level="12">
    <if_sid>100105</if_sid>
    <field name="container_health_status">^unhealthy$</field>
    <description>Docker: Container $(container_name) is $(container_health_status)</description>
    <group>container_health,</group>
  </rule>
</group>
---------------------------------------
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:

  1. Fixeu-vos en la part superior, al costat d’on posa ‘WAZUH’ veureu un desplegable, aneu a Settings>Modules
  2. 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
#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: 

isard@web:~/sudo systemctl restart wazuh-agent
isard@web:~/ cd acme-web-app
isard@web:~/acme-web-app$ sudo docker compose up -d

Si tot us ha anat correctament, us començaran a aparèixer les alertes que genera Docker.

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

Desplegament: M2 EAC3 Parrot st

CPU: 4

RAM: 8

Xarxes: Default [DHCPv4], Personal2 [172.20.121.10/24], Wireguard VPN [DHCPv4], ioc-grup4 [DHCPv4]

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: 

#Cadascú el seu nom d'usuari
isard@parrot: sudo hostnamectl hostname jobellaga
isard@parrot: sudo reboot now

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.

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:

Del servidor Wazuh:

/var/ossec/logs/alerts/alerts.log → Guardeu a Parrot com /home/isard/alerts.log

Del servidor Docker web:

/var/log/suricata/eve.json → Guardeu a Parrot com /home/isard/eve.json

/var/ossec/logs/ossec.log → Guardeu a Parrot com /home/isard/ossec.log

Obtingut de «https://wiki.training-b.com/index.php?title=Suricata&oldid=984»