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