Implementar SOC: Decoders, Playbooks y Workflows

Raul Unzue Pulido 16 mayo, 2024 Automatización, Ciberseguridad, Linux Deja un comentario 958 Vistas

Implementar SOC: Decoders, Playbooks y Workflows

Seguimos con la implementación del SOC Opensource, os dejo al final del artículo los enlaces a otras entradas…

Hoy voy a daros una pequeña pincelada de cómo podemos automatizar procesos dentro del SOC mediante decoders en Wazuh y playbooks de Ansible. Os pongo dos ejemplos, para que entendáis el objetivo de esta entrada, conseguir mediante automatización, “aislar un sistema infectado con malware para prevenir la propagación” o “bloquear intentos de acceso SSH”.

Desarrollar playbooks y workflows para la automatización de la respuesta a ciberincidentes es crucial para mejorar la eficiencia y efectividad de un SOC (Security Operations Center).

Los playbooks son guías detalladas que describen los pasos que deben seguirse para mitigar un incidente de seguridad específico. La automatización de estos procesos reduce el tiempo de respuesta y el error humano, permitiendo a los equipos de seguridad concentrarse en tareas más estratégicas.

Los decoders en Wazuh son componentes clave que analizan y extraen campos de datos de los mensajes de log recibidos. Funcionan como primer paso en el proceso de análisis de logs, interpretando la información cruda antes de que las reglas de Wazuh sean aplicadas para generar alertas basadas en patrones específicos de comportamiento o actividad sospechosa.

Función de los Decoders en Wazuh

Un decoder en Wazuh descompone los logs en partes más manejables, extrayendo y estructurando datos como direcciones IP, nombres de usuario, rutas de archivos, códigos de error, y más. Esta estructuración es esencial para que las reglas de Wazuh puedan evaluar eficazmente los logs y determinar si representan una amenaza.

Ejemplos de Decoders en Wazuh

Aquí te muestro algunos ejemplos de decoders incluidos en Wazuh que podemos agregar en el directorio /var/ossec/etc/decoders/ :

Decoder para logs de SSH:
- Este decoder analiza los logs generados por el servicio SSH (sshd) para identificar eventos de autenticación exitosos, extrayendo detalles como el método de autenticación, el usuario y la dirección IP.

<decoder name="sshd">
  <prematch>^sshd[\s|:]+</prematch>
  <regex offset="after_prematch">^(\S+ \S+ \d+ \d+:\d+:\d+ \S+ )?Accepted (\S+) for (\S+) from (\S+)( port \d+ \S+)?( ssh\d*)?( \S+)?</regex>
  <order>timestamp, authentication_method, srcuser, srcip</order>
</decoder>

<regex offset="after_prematch">^(\S+ \S+ \d+ \d+:\d+:\d+ \S+ )?Accepted (\S+) for (\S+) from (\S+)( port \d+ \S+)?( ssh\d*)?( \S+)?</regex>

<order>timestamp, authentication_method, srcuser, srcip</order>

</decoder>

Decoder para logs de Apache:
- Este decoder es específico para logs de acceso de Apache y puede identificar detalles críticos de cada petición HTTP, como la dirección IP del solicitante, el método HTTP utilizado, la URL solicitada, y el código de estado de la respuesta.

<decoder name="web-accesslog">
  <parent>apache</parent>
  <regex>^(\S+ \S+ \S+) \[([^\]]+)\] "(GET|POST|HEAD|PUT|DELETE|OPTIONS) ([^ ]+)( HTTP/\d+\.\d+)?" (\d+) (\d+)</regex>
  <order>srcip, timestamp, http_method, url, http_version, http_status_code, bytes</order>
</decoder>

<parent>apache</parent>

<order>srcip, timestamp, http_method, url, http_version, http_status_code, bytes</order>

</decoder>

Decoder para logs de Windows:
- Este decoder ayuda a analizar los eventos de Windows extraídos del Visor de Eventos, permitiendo estructurar información importante como el ID del evento, el nivel de severidad, el nombre de la computadora, entre otros.

<decoder name="windows">
  <parent>windows</parent>
  <regex>^(\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+)</regex>
  <order>EventChannel, EventSystem, EventProviderName, EventId, Level, Task, Opcode, Keywords, EventTimeCreated, EventRecordID, Channel, Computer</order>
</decoder>

<parent>windows</parent>

<order>EventChannel, EventSystem, EventProviderName, EventId, Level, Task, Opcode, Keywords, EventTimeCreated, EventRecordID, Channel, Computer</order>

</decoder>

En resumen, buscamos estar informados de los problemas de nuestra infraestructura, pero necesitamos ser proactivos ante problemas, mediante automatización (para evitar lo máximo posible el error humano).

Os recuerdo las herramientas que estamos manejando, Wazuh, TheHive, Suricata, Cortex, Patrowl, OpenSearch, OPNSense o MISP.

En los ejemplos que os voy a generar, usaré Wazuh (en otro momento lo haré con Suricata) y los datos que recogen, y usaremos el firewall de la red OPNSense para las acciones que nos interesan. Vamos con los ejemplos (como entenderéis sólo es una pincelada del poder de estas herramientas):

SOC OpenSource: Automatización bloqueo de una IP con Ansible, Wazuh y OPNSense

Ansible puede utilizarse para ejecutar comandos directamente en tu firewall OPNsense para modificar las reglas de firewall y bloquear una IP específica.

Instalamos las dependencias como “jq” en la máquina de WAZUH:

root@WAZUH01:~# apt install jq

1	root@WAZUH01:~# apt install jq

Testear Decoder Wazuh

https://documentation.wazuh.com/current/user-manual/ruleset/testing.html

Script Bash en Wazuh de revisión IP sospechosa

Genero un script bash que colocaré en cron con una programación, que lance el playbook periódicamente para detectar IPs sospechosas:

#!/bin/bash
# Path al archivo de log donde Wazuh escribe alertas
LOG_FILE="/var/ossec/logs/alerts/alerts.json"

# Lee el log y busca una IP sospechosa
tail -Fn0 $LOG_FILE | while read line ; do
    echo "$line" | grep "Actividad sospechosa" &> /dev/null
    if [ $? = 0 ]
    then
        IP_SUSPICIOUS=$(echo $line | jq '.srcip')
        ansible-playbook /path/to/ansible/playbook.yml --extra-vars "ip_to_block=$IP_SUSPICIOUS"
    fi
done

#!/bin/bash

# Path al archivo de log donde Wazuh escribe alertas

LOG_FILE="/var/ossec/logs/alerts/alerts.json"

# Lee el log y busca una IP sospechosa

tail -Fn0 $LOG_FILE | while read line ; do

echo "$line" | grep "Actividad sospechosa" &> /dev/null

if [ $? = 0 ]

then

IP_SUSPICIOUS=$(echo $line | jq '.srcip')

ansible-playbook /path/to/ansible/playbook.yml --extra-vars "ip_to_block=$IP_SUSPICIOUS"

done

Playbook bloqueo IP de Ansible para OPNSense

Es importante indicar, que es necesario habilitar la API en OPNSense (System -> Access -> Users -> En el usuario, apartado API Keys generamos una). Con esto preparamos un Playbook, con los datos de nuestro firewall OPNsense, el acceso vía API. Mandará un correo a los sysadmin que gestionen el sistema cada vez que se genere una regla para una IP a bloquear:

---
- name: Bloquear IP en OPNsense
  hosts: opnsense
  become: true
  tasks:
    - name: Bloquear acceso a IP específica
      uri:
        url: "https://{{ inventory_hostname }}/api/firewall/filter/addRule"
        method: POST
        user: "{{ opnsense_user }}"
        password: "{{ opnsense_password }}"
        body_format: json
        validate_certs: no
        body: 
          rule: 
            action: block
            interface: wan
            direction: in
            ipprotocol: inet
            protocol: tcp
            src: "any"
            dst: "{{ ip_to_block }}"
            dst_port: "any"
            description: "Bloqueo automático de IP sospechosa"
      register: response

    - name: Aplicar cambios de configuración
      uri:
        url: "https://{{ inventory_hostname }}/api/firewall/filter/apply"
        method: POST
        user: "{{ opnsense_user }}"
        password: "{{ opnsense_password }}"
        validate_certs: no
      when: response.status == 200

    - name: Enviar notificación a administradores
      mail:
        host: smtp.example.com
        port: 587
        username: "{{ smtp_user }}"
        password: "{{ smtp_password }}"
        to: Admin <admin@example.com>
        subject: 'IP bloqueada automáticamente en OPNsense'
        body: 'La IP {{ ip_to_block }} ha sido bloqueada automáticamente debido a actividad sospechosa.'

---

- name: Bloquear IP en OPNsense

hosts: opnsense

become: true

tasks:

- name: Bloquear acceso a IP específica

uri:

url: "https://{{ inventory_hostname }}/api/firewall/filter/addRule"

method: POST

user: "{{ opnsense_user }}"

password: "{{ opnsense_password }}"

body_format: json

validate_certs: no

body:

rule:

action: block

interface: wan

direction: in

ipprotocol: inet

protocol: tcp

src: "any"

dst: "{{ ip_to_block }}"

dst_port: "any"

description: "Bloqueo automático de IP sospechosa"

- name: Aplicar cambios de configuración

uri:

url: "https://{{ inventory_hostname }}/api/firewall/filter/apply"

method: POST

user: "{{ opnsense_user }}"

password: "{{ opnsense_password }}"

validate_certs: no

when: response.status == 200

- name: Enviar notificación a administradores

mail:

host: smtp.example.com

port: 587

username: "{{ smtp_user }}"

password: "{{ smtp_password }}"

to: Admin <admin@example.com>

subject: 'IP bloqueada automáticamente en OPNsense'

body: 'La IP {{ ip_to_block }} ha sido bloqueada automáticamente debido a actividad sospechosa.'

SOC OpenSource: Automatización bloqueo accesos SSH con Ansible, Wazuh y OPNSense

Os dejo otro ejemplo. Para bloquear IPs que intenten acceder vía SSH a máquinas con más de 5 intentos fallidos y que también manden una alerta a los administradores. Esto lo veo interesante cuando una máquina se infecta dentro de la red, tenemos usuarios “traviesos” e intentan hacer “cosas” raras. Os dejo los pasos:

Crear un Decoder en Wazuh

Identificamos los intentos fallidos vía logs de Wazuh. Edita o crea un archivo en /var/ossec/etc/decoders/local_decoder.xml:

<decoder name="sshd-failed-login">
  <prematch>sshd</prematch>
  <regex>^.*sshd\[[0-9]+\]: Failed password for (invalid user |)<?user> from <?srcip> port [0-9]+ ssh2</regex>
  <order>user, srcip</order>
</decoder>

<regex>^.*sshd\[[0-9]+\]: Failed password for (invalid user |)<?user> from <?srcip> port [0-9]+ ssh2</regex>

<order>user, srcip</order>

</decoder>

Crear una Regla en Wazuh

Detectamos con esta regla los múltiples accesos fallidos. Edita o crea un archivo en /var/ossec/etc/rules/local_rules.xml:

<group name="sshd,">
  <rule id="100100" level="5">
    <decoded_as>sshd-failed-login</decoded_as>
    <description>Failed SSH login attempt</description>
    <group>authentication_failed,</group>
  </rule>

  <rule id="100101" level="10" frequency="5" timeframe="60">
    <group>authentication_failed,</group>
    <description>Multiple failed SSH login attempts</description>
    <same_source_ip />
    <same_destination_ip />
    <same_user />
    <frequency>5</frequency>
    <timeframe>60</timeframe>
    <firedtimes>5</firedtimes>
    <command>block_ip.sh</command>
  </rule>
</group>

<decoded_as>sshd-failed-login</decoded_as>

<description>Failed SSH login attempt</description>

<group>authentication_failed,</group>

</rule>

<group>authentication_failed,</group>

<description>Multiple failed SSH login attempts</description>

<same_source_ip />

<same_destination_ip />

<same_user />

<command>block_ip.sh</command>

</rule>

</group>

Configurar el Script de Bloqueo intentos SSH en Wazuh

Crea un archivo de script en /var/ossec/active-response/bin/block_ip.sh:

#!/bin/bash

# IP address to block
IP_TO_BLOCK=$1

# Execute Ansible playbook
ansible-playbook /path/to/your/playbook.yml --extra-vars "ip_to_block=$IP_TO_BLOCK"

# Send email notification
echo "La IP $IP_TO_BLOCK ha sido bloqueada por múltiples intentos fallidos de SSH." | mail -s "Alerta de Seguridad: IP Bloqueada" admin@example.com

#!/bin/bash

# IP address to block

IP_TO_BLOCK=$1

# Execute Ansible playbook

ansible-playbook /path/to/your/playbook.yml --extra-vars "ip_to_block=$IP_TO_BLOCK"

# Send email notification

echo "La IP $IP_TO_BLOCK ha sido bloqueada por múltiples intentos fallidos de SSH." | mail -s "Alerta de Seguridad: IP Bloqueada" admin@example.com

Asegúrate de que el script sea ejecutable:

chmod +x /var/ossec/active-response/bin/block_ip.sh

1	chmod +x /var/ossec/active-response/bin/block_ip.sh

Playbook de Ansible para Bloquear la IP

Volveremos a usar la API de OPNSense. Guarda el contenido en un path accesible /path/to/your/playbook.yml:

---
- name: Bloquear IP en OPNsense
  hosts: localhost
  gather_facts: false
  vars:
    opnsense_host: "https://<opnsense_ip>"
    opnsense_api_key: "your_api_key"
    opnsense_api_secret: "your_api_secret"
    ip_to_block: "{{ ip_to_block }}"

  tasks:
    - name: Crear regla para bloquear IP
      uri:
        url: "{{ opnsense_host }}/api/firewall/rule/addRule"
        method: POST
        user: "{{ opnsense_api_key }}"
        password: "{{ opnsense_api_secret }}"
        body_format: json
        validate_certs: no
        body:
          rule:
            action: block
            interface: wan
            ipprotocol: inet
            protocol: tcp
            source: any
            destination: "{{ ip_to_block }}"
            description: "Bloquear IP por múltiples intentos fallidos de SSH"
      register: response

    - name: Aplicar cambios de configuración
      uri:
        url: "{{ opnsense_host }}/api/firewall/apply"
        method: POST
        user: "{{ opnsense_api_key }}"
        password: "{{ opnsense_api_secret }}"
        validate_certs: no
      when: response.status == 200

---

- name: Bloquear IP en OPNsense

hosts: localhost

gather_facts: false

vars:

opnsense_host: "https://<opnsense_ip>"

opnsense_api_key: "your_api_key"

opnsense_api_secret: "your_api_secret"

ip_to_block: "{{ ip_to_block }}"

tasks:

- name: Crear regla para bloquear IP

uri:

url: "{{ opnsense_host }}/api/firewall/rule/addRule"

method: POST

user: "{{ opnsense_api_key }}"

password: "{{ opnsense_api_secret }}"

body_format: json

validate_certs: no

body:

rule:

action: block

interface: wan

ipprotocol: inet

protocol: tcp

source: any

destination: "{{ ip_to_block }}"

description: "Bloquear IP por múltiples intentos fallidos de SSH"

- name: Aplicar cambios de configuración

uri:

url: "{{ opnsense_host }}/api/firewall/apply"

method: POST

user: "{{ opnsense_api_key }}"

password: "{{ opnsense_api_secret }}"

validate_certs: no

when: response.status == 200

Configurar Wazuh para Ejecutar el Script

Edita /var/ossec/etc/ossec.conf para asegurarte de que la configuración de active response incluye el comando block_ip.sh:

<ossec_config>
  ...
  <active-response>
    <command>
      <name>block_ip</name>
      <executable>block_ip.sh</executable>
      <expect>srcip</expect>
      <timeout_allowed>yes</timeout_allowed>
    </command>
  </active-response>
  ...
</ossec_config>