Todos hemos vivido ese momento: alguien abre un pod en producción, ejecuta un printenv y revisa una variable sensible. A veces es por curiosidad, otras por necesidad técnica… pero ¿y si no fue un desarrollador? ¿y si fue una cuenta comprometida?

Aquí es donde Falco 🦅 entra en escena.

Vamos a crear un escenario simple pero poderoso:
Un desarrollador curioso inspecciona una variable de entorno en un contenedor de producción. Falco detecta el evento en tiempo real y lo envía a Wazuh, donde lo enriquecemos, clasificamos y correlacionamos. Desde ahí, disparamos acciones automáticas con N8N.

¿Qué acciones? Las que queramos:

🔄 Rotar credenciales en Vault
📦 Regenerar Pods afectados
📑 Extraer registros para análisis forense
🔔 Notificar por Slack o Teams

Lo interesante es que no perseguimos al developer: aprovechamos la señal para fortalecer la seguridad.

Falco supervisa el comportamiento en tiempo real dentro de Kubernetes. Wazuh examina el contexto y clasifica el evento. N8N coordina la respuesta automática. De una simple curiosidad, surge un flujo de seguridad inteligente.

Falco

Vamos a crear el archivo de configuración de falco falco-values-complete.yaml, para luego instalar con Helm.

falco:
  json_output: true
  json_include_output_property: true
  json_include_tags_property: true

  grpc:
    enabled: true
    bind_address: "0.0.0.0:5060"

  grpc_output:
    enabled: true

driver:
  kind: modern_ebpf

falcosidekick:
  enabled: true
  replicaCount: 2
  hostNetwork: true
  dnsPolicy: ClusterFirstWithHostNet

  config:
    syslog:
      host: "192.168.0.67"  # ← IP CORRECTA
      port: "514"
      protocol: "udp"
      format: "json"
      minimumpriority: "notice"

customRules:
  secrets-detection.yaml: |-
    - rule: Read Sensitive File Untrusted
      desc: Detect attempts to read sensitive system files
      condition: >
        open_read and
        container and
        fd.name in (/etc/shadow, /etc/sudoers, /etc/pam.conf)
      output: >
        Sensitive file opened for reading
        (file=%fd.name command=%proc.cmdline user=%user.name
        container=%container.name k8s_pod=%k8s.pod.name k8s_ns=%k8s.ns.name)
      priority: WARNING
      tags: [filesystem, mitre_credential_access, T1555]

    - rule: Read Kubernetes Secret File
      desc: Detect read operations on Kubernetes secret files
      condition: >
        open_read and
        container and
        fd.name startswith "/etc/secrets/"
      output: >
        Kubernetes secret file accessed
        (file=%fd.name command=%proc.cmdline user=%user.name
        container=%container.name k8s_pod=%k8s.pod.name k8s_ns=%k8s.ns.name)
      priority: WARNING
      tags: [kubernetes, secrets, T1552.007, mitre_credential_access]

    - rule: Read Application Secret Files
      desc: Detect unauthorized access to application secret files
      condition: >
        open_read and
        container and
        fd.name startswith "/tmp/app-config/"
      output: >
        Application secret file accessed
        (file=%fd.name command=%proc.cmdline user=%user.name
        container=%container.name k8s_pod=%k8s.pod.name k8s_ns=%k8s.ns.name)
      priority: WARNING
      tags: [filesystem, application, mitre_credential_access, T1552, secrets]

    - rule: Environment Variables Dumped
      desc: Detect attempts to dump environment variables
      condition: >
        spawned_process and
        container and
        proc.name in (printenv, env)
      output: >
        Environment variables dumped
        (command=%proc.cmdline user=%user.name
        container=%container.name k8s_pod=%k8s.pod.name k8s_ns=%k8s.ns.name)
      priority: NOTICE
      tags: [process, mitre_credential_access, T1552.007]

    - rule: Environment Variables Dumped in Production
      desc: Detect env dumps in production namespace
      condition: >
        spawned_process and
        container and
        k8s.ns.name = "production" and
        proc.name in (env, printenv)
      output: >
        Environment variables accessed in production
        (command=%proc.cmdline user=%user.name
        container=%container.name k8s_pod=%k8s.pod.name k8s_ns=%k8s.ns.name)
      priority: WARNING
      tags: [kubernetes, secrets, production, T1552.007, mitre_credential_access]

    - rule: Read ServiceAccount Token
      desc: Detect reading of Kubernetes ServiceAccount token
      condition: >
        open_read and
        container and
        fd.name startswith "/var/run/secrets/kubernetes.io/serviceaccount/token"
      output: >
        ServiceAccount token accessed
        (file=%fd.name command=%proc.cmdline user=%user.name
        container=%container.name k8s_pod=%k8s.pod.name k8s_ns=%k8s.ns.name)
      priority: WARNING
      tags: [kubernetes, credentials, mitre_credential_access, T1552.007]

resources:
  requests:
    cpu: 100m
    memory: 512Mi
  limits:
    cpu: 1000m
    memory: 1024Mi

No te olvides de poner la dirección de tu Wazuh.

Ahora instalamos el Helm.

helm install falco falcosecurity/falco \
  --namespace falco \
  -f falco-values-complete.yaml

Wazuh

No me voy a poner a explicar el uso de Wazuh, ya lo he tocado en otros post’s. Pero si les voy a pegar lo mas importante de esta configuración.

Primero el decoder en /var/ossec/etc/decoders/falco-decoder.xml.

# /var/ossec/etc/decoders/falco-decoder.xml
<decoder name="falco">
  <prematch>Falco</prematch>
</decoder>

Segundo las reglas en /var/ossec/etc/rules/falco-rules.xml.

<group name="falco,">

  <!-- Regla base - IMPORTANTE: decoded_as debe ser "falco-json" -->
  <rule id="100600" level="0">
    <decoded_as>falco-json</decoded_as>
    <description>Falco: Runtime security event</description>
  </rule>

  <!-- Por prioridad -->
  <rule id="100603" level="8">
    <if_sid>100600</if_sid>
    <match>"priority":"Warning"</match>
    <description>Falco Warning Alert</description>
    <group>falco,warning,</group>
  </rule>

  <rule id="100605" level="12">
    <if_sid>100600</if_sid>
    <match>"priority":"Critical"</match>
    <description>Falco Critical Alert</description>
    <group>falco,critical,</group>
  </rule>

  <!-- PRODUCCIÓN - Máxima prioridad -->
  <rule id="100610" level="15">
    <if_sid>100603,100605</if_sid>
    <match>"k8s.ns.name":"production"</match>
    <description>Falco CRITICAL: Alerta en namespace PRODUCTION</description>
    <group>falco,production,high_priority,</group>
  </rule>

  <!-- Detección de lectura de secretos montados (patrón en full_log) -->
  <rule id="100620" level="12">
    <if_sid>100600</if_sid>
    <match>"fd.name":"/etc/secrets/</match>
    <description>Falco: Acceso a secreto K8s montado</description>
    <group>falco,credential_access,secrets,</group>
    <mitre>
      <id>T1552.007</id>
    </mitre>
  </rule>

  <!-- Lectura de /etc/shadow -->
  <rule id="100621" level="12">
    <if_sid>100600</if_sid>
    <match>"fd.name":"/etc/shadow"</match>
    <description>Falco: Lectura de /etc/shadow</description>
    <group>falco,credential_access,</group>
    <mitre>
      <id>T1552.001</id>
    </mitre>
  </rule>

  <!-- Acceso a secretos en PRODUCCIÓN - CRÍTICO -->
  <rule id="100625" level="15">
    <if_sid>100620</if_sid>
    <match>"k8s.ns.name":"production"</match>
    <description>Falco CRITICAL: Developer accediendo a secretos en PRODUCCIÓN</description>
    <group>falco,production,credential_access,unauthorized_access,</group>
    <mitre>
      <id>T1552.007</id>
    </mitre>
  </rule>

  <!-- Detección por nombre de regla de Falco - Read Kubernetes Secret File -->
  <rule id="100640" level="14">
    <if_sid>100600</if_sid>
    <match>Kubernetes secret file accessed</match>
    <description>Falco: Lectura de archivo de secreto K8s detectada</description>
    <group>falco,kubernetes,secrets,credential_access,</group>
    <mitre>
      <id>T1552.007</id>
    </mitre>
  </rule>

  <!-- Variables de entorno dumpeadas en producción -->
  <rule id="100641" level="12">
    <if_sid>100600</if_sid>
    <match>Environment variables accessed in production</match>
    <description>Falco: Variables de entorno accedidas en producción</description>
    <group>falco,kubernetes,production,credential_access,</group>
    <mitre>
      <id>T1552.007</id>
    </mitre>
  </rule>

  <!-- Combinada: Secret file en producción con regla custom de Falco -->
  <rule id="100650" level="16">
    <if_sid>100640</if_sid>
    <match>"k8s.ns.name":"production"</match>
    <description>Falco CRITICAL: Archivo de secreto K8s accedido en PRODUCCIÓN - Pod: webapp</description>
    <group>falco,production,kubernetes,credential_access,critical,</group>
    <mitre>
      <id>T1552.007</id>
    </mitre>
  </rule>

</group>

Aquí está la integración.

No olvides incluir el puerto UDP 514 en ossec.conf y esta porción:

  <active-response>
    <command>n8n-webhook</command>
    <location>server</location>
    <rules_group>falco</rules_group>
    <level>12</level>
  </active-response>

Incident and Response

Aquí dejo el script que realiza la magia detrás de escena, para el análisis y la llamada a cada webhook junto con su wrapper. Este Python /var/ossec/active-response/bin/parse-and-send.py.

#!/usr/bin/env python3
import sys
import json
import re
import subprocess
import os
import time
from datetime import datetime

# URLs de N8N
N8N_TRIAGE = "http://192.168.0.12:5678/webhook/falco-triage"
N8N_FORENSICS = "http://192.168.0.12:5678/webhook/falco-forensics"
N8N_CONTAINMENT = "http://192.168.0.12:5678/webhook/falco-containment"

# Directorio de evidencia
FORENSICS_DIR = "/var/ossec/logs/forensics"

# Ruta completa de kubectl (para forensics)
KUBECTL = "/usr/local/bin/kubectl"

try:
    input_data = sys.stdin.read().strip()

    # Extraer campos con regex
    alert_id_match = re.search(r'"id":"([^"]+)"', input_data)
    rule_id_match = re.search(r'"rule":\{[^}]*"id":"([^"]+)"', input_data)
    rule_level_match = re.search(r'"level":(\d+)', input_data)
    rule_desc_match = re.search(r'"description":"([^"]+)"', input_data)
    timestamp_match = re.search(r'"timestamp":"([^"]+)"', input_data)

    full_log_match = re.search(r'"full_log":"(.+?)","decoder"', input_data)
    full_log = full_log_match.group(1) if full_log_match else ""

    # Parsear Falco JSON
    falco_data = {}
    falco_match = re.search(r'Falco\[\d+\]:\s*(\{.+\})', full_log)
    if falco_match:
        falco_json_str = falco_match.group(1).replace('\\', '')
        try:
            falco_data = json.loads(falco_json_str)
        except:
            pass

    # Extraer MITRE
    mitre_ids = re.findall(r'"mitre":\{[^}]*"id":\[([^\]]+)\]', input_data)
    mitre_id = mitre_ids[0].replace('"', '').strip() if mitre_ids else 'N/A'

    rule_id = rule_id_match.group(1) if rule_id_match else 'N/A'
    rule_level = int(rule_level_match.group(1)) if rule_level_match else 0

    namespace = falco_data.get('output_fields', {}).get('k8s.ns.name', 'unknown')
    pod = falco_data.get('output_fields', {}).get('k8s.pod.name', 'unknown')

    # Payload común
    payload = {
        'alert_id': alert_id_match.group(1) if alert_id_match else 'N/A',
        'rule_id': rule_id,
        'rule_level': str(rule_level),
        'rule_description': rule_desc_match.group(1) if rule_desc_match else 'N/A',
        'timestamp': timestamp_match.group(1) if timestamp_match else '',
        'k8s_namespace': namespace,
        'k8s_pod': pod,
        'container_id': falco_data.get('output_fields', {}).get('container.id', 'unknown'),
        'command': falco_data.get('output_fields', {}).get('proc.cmdline', 'unknown'),
        'file_accessed': falco_data.get('output_fields', {}).get('fd.name', 'unknown'),
        'user': falco_data.get('output_fields', {}).get('user.name', 'root'),
        'falco_rule': falco_data.get('rule', 'N/A'),
        'falco_priority': falco_data.get('priority', 'N/A'),
        'mitre_id': mitre_id
    }

    print(f"Processing alert - Rule: {rule_id}, Level: {rule_level}, NS: {namespace}, Pod: {pod}")

    # ============================================================================
    # 1. TRIAGE - Siempre enviar
    # ============================================================================
    result = subprocess.run(
        ['curl', '-X', 'POST', N8N_TRIAGE,
         '-H', 'Content-Type: application/json',
         '-d', json.dumps(payload),
         '--max-time', '10'],
        capture_output=True, text=True
    )
    print(f"TRIAGE - Sent to Slack")
    time.sleep(2)

    # ============================================================================
    # 2. FORENSICS - Para alertas level >= 12
    # ============================================================================
    if rule_level >= 12 and namespace != 'unknown' and pod != 'unknown':
        print(f"FORENSICS - Collecting evidence for {namespace}/{pod}")

        os.makedirs(FORENSICS_DIR, exist_ok=True)
        timestamp_str = datetime.now().strftime('%Y%m%d_%H%M%S')
        evidence_file = f"{FORENSICS_DIR}/{namespace}_{pod}_{timestamp_str}.txt"

        with open(evidence_file, 'w') as f:
            f.write("=" * 80 + "\n")
            f.write("FORENSICS REPORT - FALCO SECURITY INCIDENT\n")
            f.write("=" * 80 + "\n\n")

            f.write(f"Alert ID: {payload['alert_id']}\n")
            f.write(f"Timestamp: {payload['timestamp']}\n")
            f.write(f"Rule: {rule_id} (Level {rule_level})\n")
            f.write(f"Description: {payload['rule_description']}\n")
            f.write(f"MITRE ATT&CK: {mitre_id}\n\n")

            f.write(f"Namespace: {namespace}\n")
            f.write(f"Pod: {pod}\n")
            f.write(f"Container ID: {payload['container_id']}\n")
            f.write(f"User: {payload['user']}\n\n")

            f.write(f"Suspicious Command: {payload['command']}\n")
            f.write(f"File Accessed: {payload['file_accessed']}\n")
            f.write(f"Falco Rule: {payload['falco_rule']}\n\n")

            f.write("=" * 80 + "\n")
            f.write("POD LOGS (last 100 lines)\n")
            f.write("=" * 80 + "\n\n")

            try:
                logs = subprocess.run(
                    [KUBECTL, 'logs', pod, '-n', namespace, '--tail=100'],
                    capture_output=True, text=True, timeout=15
                )
                f.write(logs.stdout if logs.returncode == 0 else f"Error: {logs.stderr}\n")
            except Exception as e:
                f.write(f"Error capturing logs: {e}\n")

            f.write("\n" + "=" * 80 + "\n")
            f.write("POD DESCRIPTION\n")
            f.write("=" * 80 + "\n\n")

            try:
                describe = subprocess.run(
                    [KUBECTL, 'describe', 'pod', pod, '-n', namespace],
                    capture_output=True, text=True, timeout=15
                )
                f.write(describe.stdout if describe.returncode == 0 else f"Error: {describe.stderr}\n")
            except Exception as e:
                f.write(f"Error describing pod: {e}\n")

            f.write("\n" + "=" * 80 + "\n")
            f.write("POD YAML MANIFEST\n")
            f.write("=" * 80 + "\n\n")

            try:
                yaml_out = subprocess.run(
                    [KUBECTL, 'get', 'pod', pod, '-n', namespace, '-o', 'yaml'],
                    capture_output=True, text=True, timeout=15
                )
                f.write(yaml_out.stdout if yaml_out.returncode == 0 else f"Error: {yaml_out.stderr}\n")
            except Exception as e:
                f.write(f"Error getting YAML: {e}\n")

            f.write("\n" + "=" * 80 + "\n")
            f.write("END OF REPORT\n")
            f.write("=" * 80 + "\n")

        subprocess.run(['gzip', '-f', evidence_file])
        evidence_file_gz = f"{evidence_file}.gz"

        print(f"FORENSICS - Evidence saved: {evidence_file_gz}")

        forensics_payload = payload.copy()
        forensics_payload['evidence_file'] = evidence_file_gz
        forensics_payload['evidence_collected'] = True

        result = subprocess.run(
            ['curl', '-X', 'POST', N8N_FORENSICS,
             '-H', 'Content-Type: application/json',
             '-d', json.dumps(forensics_payload),
             '--max-time', '10'],
            capture_output=True, text=True
        )
        print(f"FORENSICS - Notification sent to Slack")
        time.sleep(2)

    # ============================================================================
    # 3. CONTAINMENT - Delegado a N8N
    # ============================================================================
    CONTAINMENT_RULES = ['100625', '100650']
    is_production = namespace == 'production'
    is_vault_enabled = 'vault' in pod.lower()
    is_secret_access = (
        '/tmp/app-config/' in payload['file_accessed'] or
        '/etc/secrets/' in payload['file_accessed']
    )

    should_contain = (
        rule_id in CONTAINMENT_RULES or
        (is_production and is_vault_enabled and is_secret_access and rule_level >= 12)
    )

    if should_contain:
        print(f"CONTAINMENT - Delegating to N8N for {namespace}/{pod}")
        print(f"  - Production: {is_production}")
        print(f"  - Vault-enabled: {is_vault_enabled}")
        print(f"  - Secret access: {is_secret_access}")
        print(f"  - Rule: {rule_id}, Level: {rule_level}")

        # Enviar a N8N - él se encarga de todo
        containment_payload = payload.copy()
        containment_payload['action_required'] = 'ROTATE_AND_KILL'
        containment_payload['trigger_reason'] = f"Rule {rule_id} - Level {rule_level}"

        result = subprocess.run(
            ['curl', '-X', 'POST', N8N_CONTAINMENT,
             '-H', 'Content-Type: application/json',
             '-d', json.dumps(containment_payload),
             '--max-time', '10'],
            capture_output=True, text=True
        )
        print(f"CONTAINMENT - Delegated to N8N workflow")
        print(f"  N8N will: 1) Rotate secret in Vault, 2) Delete pod via K8s API")

    sys.exit(0)

except Exception as e:
    print(f"ERROR: {str(e)}")
    import traceback
    traceback.print_exc()
    sys.exit(1)

Y el Wrapper en /var/ossec/active-response/bin/n8n-webhook.sh.

#!/bin/bash

LOCAL=`dirname $0`
cd $LOCAL
PWD=`pwd`

read INPUT_JSON

mkdir -p /var/ossec/logs/active-response

echo "$(date '+%Y-%m-%d %H:%M:%S') - Processing alert" >> /var/ossec/logs/active-response/n8n-webhook.log

# Llamar al script Python que hace todo
RESULT=$(echo "$INPUT_JSON" | /var/ossec/active-response/bin/parse-and-send.py 2>&1)

echo "$RESULT" >> /var/ossec/logs/active-response/n8n-webhook.log
echo "---" >> /var/ossec/logs/active-response/n8n-webhook.log

exit 0

N8N

Voy a usar Kubectl para acceder.

kubectl port-forward -n automation svc/n8n 5678:5678 --address=0.0.0.0

Vamos a importar el flujo de trabajo para obtener estos 3 caminos. El Triage nos avisa del compromiso, Forensic obtiene los registros para la investigación y Containment se encarga de rotar el secreto en Vault, eliminar el Pod y darnos el estado. Te dejo el workflow para que importes.

Para que N8N pueda comunicarse con Kubernetes, crearemos una cuenta de servicio que solo tenga permisos para eliminar Pods, de esta manera obtendremos el Bearer necesario para usar.

apiVersion: v1
kind: ServiceAccount
metadata:
  name: n8n-incident-response
  namespace: automation
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: n8n-incident-response
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "list", "delete"]
- apiGroups: [""]
  resources: ["pods/log"]
  verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: n8n-incident-response
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: n8n-incident-response
subjects:
- kind: ServiceAccount
  name: n8n-incident-response
  namespace: automation
---
apiVersion: v1
kind: Secret
metadata:
  name: n8n-incident-response-token
  namespace: automation
  annotations:
    kubernetes.io/service-account.name: n8n-incident-response
type: kubernetes.io/service-account-token

Te dejo los comandos para poder listar el token.

TOKEN=$(kubectl -n automation get secret n8n-incident-response-token -o jsonpath='{.data.token}' | base64 --decode)
kubectl -n automation get secret n8n-incident-response-token -o jsonpath='{.data.ca\.crt}' | base64 --decode > ca.crt
APISERVER=$(kubectl config view --minify -o jsonpath='{.clusters[0].cluster.server}')

echo Bearer $TOKEN
Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjFiaG1pd19KOHJJYnZkbWlhSkptdWl3dHNXZEFmMW9WeWZIRWp1NS0xVW8ifQ.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJhdXRvbWF0aW9uIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZWNyZXQubmFtZSI6Im44bi1pbmNpZGVudC1yZXNwb25zZS10b2tlbiIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VydmljZS1hY2NvdW50Lm5hbWUiOiJuOG4taW5jaWRlbnQtcmVzcG9uc2UiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC51aWQiOiI0MzJlYTQ2NC0yMmIwLTQ3ZjktYTE2NS01ZGY3YTgxYzM2OTEiLCJzdWIiOiJzeXN0ZW06c2VydmljZWFjY291bnQ6YXV0b21hdGlvbjpuOG4taW5jaWRlbnQtcmVzcG9uc2UifQ.gMa6wGi0SpTrfRYLD5DoOUhH3I19U2v0_brgQaWGtYoOBJyQaavBQOijV4yad6My2theSQVoRVHDseO_pYKBLuc3MhggOxaN2dOLGe3oB3kKQ3TGeTxFlIWYV9tBH7_5SBLoASfuet4frimfkL03sgb5lYx93IdSgMDewQGA_RVVH0McVOwignR43KHARYqwgraqwAjPaD9hdEf5Y3i7v0hPhgln-gBc42B7q3lYCjXyjFCtvictPJ2813AhMNoKy2aLVACjsc9UDfZy1e4yV9ZQQ3QCQyfjPTLq2XXW_ob1sJGl2jmmcu73i23ZXuaVCgi-5zm5gKGlh0bdchWP3A

Creamos la credencial para el Kubernetes HTTP Request Delete Pod.

Tienes que añadir el token para el bot de Slack también.

Vault

Vamos a instalar Vault en el namespace automation.

# Agregar repo de Vault (si no lo tenés)
helm repo add hashicorp https://helm.releases.hashicorp.com
helm repo update

# Instalar Vault en modo DEV (para POC)
cat > vault-values.yaml << 'EOF'
server:
  dev:
    enabled: true
    devRootToken: "root"

  standalone:
    enabled: true

  service:
    type: NodePort
    nodePort: 30200

  dataStorage:
    enabled: false

ui:
  enabled: true
  serviceType: NodePort

injector:
  enabled: false
EOF

helm install vault hashicorp/vault \
  -f vault-values.yaml \
  -n automation --create-namespace

# Esperar
kubectl wait --for=condition=ready pod -l app.kubernetes.io/name=vault -n automation --timeout=300s

# Verificar
kubectl get pod -n automation -l app.kubernetes.io/name=vault

Ahora generamos el secreto, para que sea consumido.

# Port forward para acceder a Vault UI
kubectl port-forward -n automation svc/vault 8200:8200 &

# Acceder a Vault
export VAULT_ADDR='http://127.0.0.1:8200'
export VAULT_TOKEN='root'

# O desde el pod
kubectl exec -it vault-0 -n automation -- vault login root

# Habilitar KV v2 secrets engine
kubectl exec -it vault-0 -n automation -- vault secrets enable -path=secret kv-v2

# Crear secreto inicial para producción
kubectl exec -it vault-0 -n automation -- vault kv put secret/production/db-credentials \
  username=admin \
  password=InitialSecretP@ssw0rd123 \
  api_key=sk-prod-initial-key \
  version=1

Aplicación

Now it's time for the application to read the password from Vault. The webapp-vault pod will be created in the production namespace. Remember that many of our rules use the namespace as a condition.

apiVersion: v1
kind: ConfigMap
metadata:
  name: vault-reader-script
  namespace: production
data:
  read-secrets.sh: |
    #!/bin/sh

    VAULT_ADDR="http://vault.automation.svc.cluster.local:8200"
    VAULT_TOKEN="root"
    SECRET_PATH="secret/data/production/db-credentials"

    echo "============================================"
    echo "🔐 VAULT-ENABLED APPLICATION"
    echo "============================================"
    echo "Vault: $VAULT_ADDR"
    echo "Pod: $(hostname)"
    echo "Timestamp: $(date)"
    echo ""

    echo "📡 Connecting to Vault..."
    SECRET_JSON=$(wget -q -O - \
      --header "X-Vault-Token: $VAULT_TOKEN" \
      "$VAULT_ADDR/v1/$SECRET_PATH")

    if [ $? -ne 0 ]; then
      echo "❌ Failed to connect to Vault"
      sleep 30
      exit 1
    fi

    DB_USERNAME=$(echo "$SECRET_JSON" | sed -n 's/.*"username":"\([^"]*\)".*/\1/p')
    DB_PASSWORD=$(echo "$SECRET_JSON" | sed -n 's/.*"password":"\([^"]*\)".*/\1/p')
    API_KEY=$(echo "$SECRET_JSON" | sed -n 's/.*"api_key":"\([^"]*\)".*/\1/p')
    SECRET_VERSION=$(echo "$SECRET_JSON" | sed -n 's/.*"version":\([0-9]*\).*/\1/p')

    if [ -z "$DB_PASSWORD" ]; then
      echo "❌ Failed to parse secrets"
      exit 1
    fi

    echo "✅ Secrets loaded successfully!"
    echo ""
    echo "📊 Configuration:"
    echo "  Username: $DB_USERNAME"
    echo "  Password: ${DB_PASSWORD:0:4}***${DB_PASSWORD: -3}"
    echo "  API Key: ${API_KEY:0:12}***"
    echo "  Vault Version: ${SECRET_VERSION}"
    echo ""

    mkdir -p /tmp/app-config
    echo "$DB_USERNAME" > /tmp/app-config/username
    echo "$DB_PASSWORD" > /tmp/app-config/password
    echo "$API_KEY" > /tmp/app-config/api-key
    echo "${SECRET_VERSION}" > /tmp/app-config/secret-version
    chmod 600 /tmp/app-config/*

    echo "✅ Config files created at /tmp/app-config/"
    ls -la /tmp/app-config/
    echo ""
    echo "============================================"
    echo "🚀 APPLICATION RUNNING"
    echo "============================================"
    echo "Using Vault secret version: ${SECRET_VERSION}"
    echo ""

    COUNTER=0
    while true; do
      COUNTER=$((COUNTER + 1))
      echo "[$(date '+%H:%M:%S')] Heartbeat #$COUNTER - Vault version ${SECRET_VERSION}"
      sleep 30
    done
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp-vault
  namespace: production
  labels:
    app: webapp-vault
spec:
  replicas: 1
  selector:
    matchLabels:
      app: webapp-vault
  template:
    metadata:
      labels:
        app: webapp-vault
        env: production
        vault-enabled: "true"
    spec:
      containers:
      - name: webapp
        image: busybox
        command: ["/bin/sh", "/scripts/read-secrets.sh"]
        volumeMounts:
        - name: scripts
          mountPath: /scripts
      volumes:
      - name: scripts
        configMap:
          name: vault-reader-script
          defaultMode: 0755

Simulación de Compromiso

Ahora la parte que el atacante o el desarrollador curioso quiere leer una variable de entorno.

# 1. Obtener nombre del pod
POD=$(kubectl get pod -n production -l app=webapp-vault -o jsonpath='{.items[0].metadata.name}')

echo "Pod actual: $POD"

# 2. Simular compromiso
kubectl exec $POD -n production -- cat /tmp/app-config/password

Uala!

Mientas tanto en Wazuh.

Comandos Utiles

# Para ver los logs del Python
tail -f /var/ossec/logs/active-response/n8n-webhook.log
# Ver Alertas de Wazuh
tail -f /var/ossec/logs/alerts/alerts.log | grep -i "falco"

Referencias

https://blog.santiagoagustinfernandez.com/runtime-security-con-falco#heading-instalacion-de-falco-via-helm

El Desafío

Como profesional de ciberseguridad, me enfrenté a varios problemas comunes en equipos de desarrollo:

1. Secretos hardcodeados que terminan en producción

2. Vulnerabilidades en dependencias que pasan desapercibidas

3. Código inseguro que se detecta demasiado tarde

4. Falta de visibilidad sobre el estado de seguridad real

5. Errores de pipeline sin contexto ni soluciones claras

La pregunta era: ¿Cómo podemos hacer que la seguridad sea automática, informativa y no obstructiva La Solución: Un Pipeline DevSecOps con IA

Construí un pipeline completo que combina:

• GitLab CI/CD para orquestación

• 4 herramientas de seguridad (Bandit, Safety, GitLeaks, Trivy)

• DefectDojo para gestión de vulnerabilidades

• n8n para automatización inteligente

• Ollama (Mistral 7B) para análisis de errores con IA

• Slack para notificaciones contextuales

• Kubernetes (k3s) para deployment

• Cloudflare Tunnel para exposición segura

Vamos a descargar el repositorio que tengo los archivos ahi. Primero echamos a correr nuestro docker compose, para levantar el stack.

❯ sudo git clone https://github.com/safernandez666/devsecopsia.git
Clonando en 'devsecopsia'...
remote: Enumerating objects: 29, done.
remote: Counting objects: 100% (29/29), done.
remote: Compressing objects: 100% (23/23), done.
remote: Total 29 (delta 6), reused 27 (delta 4), pack-reused 0 (from 0)
Recibiendo objetos: 100% (29/29), 16.45 KiB | 1.10 MiB/s, listo.
Resolviendo deltas: 100% (6/6), listo.

Vamos a echarlo a correr.

docker compose up

Kubernetes

Como pueden ver, tenemos k3s como nodo de Kubernetes. Se generará una carpeta llamada k3s-kubeconfig. Lo primero que haremos es configurarla para poder gestionarla mediante kubectl.

export KUBECONFIG=/Users/santiago/Proyects/devsecopsia/k3s-kubeconfig/kubeconfig.yaml

Nuestro clúster está en funcionamiento. Vamos a desplegar manualmente nuestra aplicación usando kubectl apply -f k8s/.

¡Listo! Nuestra aplicación está funcionando.

Sigamos con los demás componentes.

Gitlab

Vamos a iniciar sesión en http://localhost:8000 con el usuario: root y la contraseña: changeme123.

Outbound

Una vez dentro, configuraremos algunos elementos específicos, como el Outbound para habilitar las integraciones.

Proyecto

Ahora vamos a crear el proyecto y subir el código.

# Eliminamos .git
sudo rm -R .git

git init --initial-branch=master
git remote add origin http://localhost:8000/root/python-application.git
git add .
git commit -m "Initial commit"
git push --set-upstream origin master

Listo! Tenemos nuestro proyecto en Gitlab.

Webook

Una vez generado el proyecto vamos a crear el Webhook que hablara con N8N cada vez que hay un evento en el pipeline. Tenemos que tildar Pipeline events para la PoC vamos a deshabilitar el SSL y la ruta sera del Webhook sera http://n8n:5678/webhook/gitlab-ai.

Registrar Runner

Vamos a registrar el runner que se encargará de ejecutar nuestro proyecto. Para ello nos vamos a meter dentro del docker gitlab-runner y ejecutar algunos comandos. Previo a eso necesitamos un token. Ingresamos al docker con:

docker exec -it gitlab-runner sh

Ahí aplicamos el comando que nos da Gitlab.

Vamos a editar el config.toml de runner.

docker exec -it gitlab-runner vi /etc/gitlab-runner/config.toml

Deberia quedar asi:

concurrent = 1
check_interval = 0
shutdown_timeout = 0

[session_server]
  session_timeout = 1800

[[runners]]
  name = "docker-desktop"
  url = "http://localhost:8000"
  id = 1
  token = "glrt-GWHqJu72JQo3xR1-1okEwW86MQp0OjEKdToxCw.01.1215lwx2d"
  token_obtained_at = 2025-11-14T21:15:44Z
  token_expires_at = 0001-01-01T00:00:00Z
  executor = "docker"
  [runners.cache]
    MaxUploadedArchiveSize = 0
    [runners.cache.s3]
    [runners.cache.gcs]
    [runners.cache.azure]
  [runners.docker]
    tls_verify = false
    image = "alpine-latest"
    privileged = false
    volumes = ["/var/run/docker.sock:/var/run/docker.sock", "/cache"]
    disable_entrypoint_overwrite = false
    oom_kill_disable = false
    disable_cache = false
    shm_size = 0
    network_mode = "host"
    network_mtu = 0

Listo, solo queda reiniciarlo con un docker restart gitlab-runner. Tenemos el runner en linea y listo para funcionar.

Más adelante, deberás agregar la variable de Defect Dojo y la configuración de Kubernetes. Aquí tienes una imagen de ejemplo.

Defect Dojo

Vamos a reunir todos nuestros hallazgos en esta plataforma. Una vez que esté en funcionamiento, la configuraremos para que esté operativa y podamos extraer la API Key que necesitamos para nuestro CI en Gitlab.

# Inicializar la base de datos de DefectDojo
docker exec -it defectdojo-uwsgi ./manage.py migrate

# Crear el superusuario (admin/admin123)
docker exec -it defectdojo-uwsgi ./manage.py createsuperuser --noinput --username admin --email admin@defectdojo.local

# Cambiar la password del admin
docker exec -it defectdojo-uwsgi python manage.py shell << EOF
from django.contrib.auth import get_user_model
User = get_user_model()
user = User.objects.get(username='admin')
user.set_password('admin123')
user.save()
EOF

# Reiniciar los servicios
docker restart defectdojo-uwsgi defectdojo-nginx

Generamos la API Key una vez que hicimos el Sign In.

La copiamos y luego la agregamos como variable en CI/CD bajo el nombre de DEFECTDOJO_API_KEY.

N8N

Importamos el proyecto y rellenamos lo que nos falta. Por un lado es el Token del Bot de Slack, en internet vas a encontrar como sacarlo, y por el otro un PRIVATE-TOKEN.

Pipeline

Vamos a correr el pipeline. Hacemos un cambio y hacemos el push.

Slack nos avisa, que tenemos que hacer. Le damos play al deploy-k3s. Listo, ya esta corriendo nuestro deployment.

Vemos como se despliega.

El mensaje de Slack donde se ejecuto el pipeline numero #96.

Ya estamos productivos.

Generación de Errores

Ahora que el pipeline está listo, es momento de probar qué sucede si encuentra algo. Para esto, voy a crear un archivo con contraseñas para que gitleaks lo detecte y lo pase a Ollama para el análisis.

# Crear un archivo con un secreto
cat > app/config.py << 'EOF'
# Configuración de la aplicación
import os

# NUNCA hagas esto en producción
AWS_ACCESS_KEY = "AKIAIOSFODNN7EXAMPLE"
AWS_SECRET_KEY = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
DATABASE_PASSWORD = "super_secret_password_123"

# Configuración de la base de datos
DB_CONFIG = {
    "host": "localhost",
    "port": 5432,
    "username": "admin",
    "password": "admin123456",  # Contraseña hardcodeada
    "database": "production_db"
} 
EOF

Hacemos el commit.

# Commit
git add app/config.py
git commit -m "Change with Leaks"
git push

Aquí vemos el error y el análisis de Ollama. Si todo funciona correctamente, el Job de Bandit y GitLeaks encontrará problemas, lo que hará que el Security Gate falle.

Esto activará el Webhook a N8N para que Ollama lo analice y nos notifique por Slack. Recibimos el mensaje con el análisis realizado por la LLM. Es genial para saber dónde están los errores.

Mientras tanto en Defect Dojo, tenemos una manera de visualizar los hallazgos.

Espero que hayan disfrutado del proceso y puedan implementar IA en sus entornos. Seguiremos explorando esto, añadiendo OWASP ZAP y algunas otras cosas para interactuar con Slack.

La clasificación de datos, esa práctica noble de etiquetar documentos, bases de datos y buckets según su sensibilidad, fue pensada para dar control. Pero en la era de la nube y el desarrollo ágil, la clasificación se volvió una ilusión. Los equipos crean recursos efímeros; los pipelines generan snapshots y backups; los scripts y lambdas almacenan datos temporales. El resultado: PII y PCI dispersas en lugares que nadie revisó.

En lugar de intentar imponer una clasificación perfecta (una batalla perdida), proponemos otro enfoque: encontrar lo que importa. Descubrir automáticamente las superficies que contienen datos sensibles, priorizar por riesgo y aplicar controles proporcionalmente. Esto no solo es pragmático: es la única estrategia viable para reducir la exposición real en ambientes dinámicos.

En la prueba de concepto que desarrollé, combiné LocalStack para emular AWS S3, un contenedor MySQL y un escáner como Hawk Eye. Una manera de evidenciar archivos y tablas con PII/PCI que no figuraban en ningún inventario. A grandes rasgos, Hawk Eye realiza el descubrimiento, luego los hallazgos son clasificados, se revisa si es algo ya evidenciado o no y eso se impacta en The Hive para un seguimiento.

Arquitectura

Aca esta nuestro docker compose, todo nuestro stack.

services:
  localstack:
    image: localstack/localstack:2.2
    container_name: localstack
    environment:
      - SERVICES=s3
      - DEFAULT_REGION=us-east-1
      - DEBUG=1
    ports:
      - "4566:4566"
    volumes:
      - "./localstack_data:/tmp/localstack"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:4566/_localstack/health"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - hawk-network

  hawk-mysql:
    image: mysql:8.0
    container_name: hawk-mysql 
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: pocdb
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-prootpassword"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - hawk-network

  cassandra:
    image: cassandra:4.1
    container_name: cassandra
    environment:
      - MAX_HEAP_SIZE=1G
      - HEAP_NEWSIZE=256M
      - CASSANDRA_CLUSTER_NAME=thehive
    volumes:
      - cassandra_data:/var/lib/cassandra
    networks:
      - hawk-network
    healthcheck:
      test: ["CMD-SHELL", "cqlsh -e 'describe cluster' || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 10
      start_period: 120s

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.17.9
    container_name: elasticsearch
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - cluster.name=thehive
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    volumes:
      - elasticsearch_data:/usr/share/elasticsearch/data
    networks:
      - hawk-network
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:9200/_cluster/health || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

  thehive:
    image: strangebee/thehive:5.0
    platform: linux/amd64   
    container_name: thehive
    depends_on:
      cassandra:
        condition: service_healthy
      elasticsearch:
        condition: service_healthy
    ports:
      - "9000:9000"
    environment:
      - JVM_OPTS=-Xms1G -Xmx1G
    volumes:
      - thehive_data:/opt/thehive/data
      - ./thehive-config/application.conf:/etc/thehive/application.conf:ro
    networks:
      - hawk-network
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/api/v1/status"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 180s

  hawk-scanner:
    build: .
    container_name: hawk-scanner
    platform: linux/amd64
    depends_on:
      hawk-mysql:
        condition: service_healthy
      localstack:
        condition: service_healthy
      thehive:
        condition: service_started
    environment:
      - AWS_ACCESS_KEY_ID=test
      - AWS_SECRET_ACCESS_KEY=test
      - AWS_ENDPOINT_URL=http://localstack:4566
      - AWS_DEFAULT_REGION=us-east-1
      - PYTHONIOENCODING=utf-8
      - LANG=C.UTF-8
      - LC_ALL=C.UTF-8
    volumes:
      - ./alerts:/app/alerts
      - ./hawk-scanner/connection.yml:/app/connection.yml
      - ./hawk-scanner/fingerprint.yml:/app/fingerprint.yml
      - ./hawk-scanner/data:/app/data
    command: tail -f /dev/null
    networks:
      - hawk-network

networks:
  hawk-network:
    driver: bridge

volumes:
  mysql_data:
  cassandra_data:
  elasticsearch_data:
  thehive_data:

Hawk Scanner

Primero el Dockerfile para la creación del contenedor que contendrá Hawk Eye.

# Dockerfile corregido
FROM python:3.11-slim

ENV DEBIAN_FRONTEND=noninteractive \
    PYTHONUNBUFFERED=1

WORKDIR /app

# Dependencias del sistema
RUN apt-get update \
 && apt-get install -y --no-install-recommends \
    curl \
    git \
    netcat-openbsd \
    build-essential \
    libgl1 \
    libglx-mesa0 \
    libglib2.0-0 \
 && rm -rf /var/lib/apt/lists/*

# Instalar dependencias Python
COPY requirements.txt /app/requirements.txt
RUN pip install --no-cache-dir -r /app/requirements.txt

# Copiar todo el directorio del scanner
COPY hawk-scanner /app/

# Crear carpetas necesarias
RUN mkdir -p /app/alerts /app/data \
 && chmod -R a+rX /app

# WORKDIR ya es /app (donde están los archivos yml)
CMD ["python", "run_hawk_scanner.py"]

Vamos a configurar las conexiones para que Hawk Eye pueda hacer la investigación. En mi caso me propuse investigar AWS S3 y una BBDD MySQL.

# connection.yml
# Configuración de conexiones para Hawk-eye Scanner
# Este archivo define las fuentes de datos a escanear

notify:
  redacted: true  # Redactar datos sensibles en las notificaciones
  suppress_duplicates: true  # Suprimir alertas duplicadas

  # Opcional: Configurar webhook de Slack para notificaciones
  # slack:
  #   webhook_url: https://hooks.slack.com/services/YOUR/WEBHOOK/URL
  #   mention: "<@USERID>"  # Opcional: mencionar usuario/bot en alertas

sources:
  # ==========================================
  # CONFIGURACIÓN MYSQL
  # ==========================================
  mysql:
    poc_mysql:
      host: hawk-mysql
      port: 3306
      user: pocuser
      password: pocpassword
      database: pocdb
      limit_start: 0
      limit_end: 10000
      # Opcional: especificar tablas específicas
      # tables:
      #   - payments
      #   - users
      # Opcional: excluir columnas
      # exclude_columns:
      #   - id
      #   - created_at

  # ==========================================
  # CONFIGURACIÓN S3 (LOCALSTACK)
  # ==========================================
  s3:
    poc_s3:
      access_key: test
      secret_key: test
      bucket_name: poc-bucket
      endpoint_url: http://localstack:4566  # LocalStack endpoint
      cache: false
      # Opcional: patrones a excluir
      # exclude_patterns:
      #   - .log
      #   - .tmp

  # ==========================================
  # CONFIGURACIÓN FILESYSTEM (Opcional)
  # ==========================================
  # fs:
  #   local_scan:
  #     path: /app/test-data
  #     exclude_patterns:
  #       - .git
  #       - node_modules
  #       - venv
  #       - __pycache__

  # ==========================================
  # CONFIGURACIÓN REDIS (Opcional)
  # ==========================================
  # redis:
  #   poc_redis:
  #     host: redis
  #     port: 6379
  #     password: your_redis_password

  # ==========================================
  # CONFIGURACIÓN POSTGRESQL (Opcional)
  # ==========================================
  # postgresql:
  #   poc_postgres:
  #     host: postgres
  #     port: 5432
  #     user: postgres
  #     password: postgres
  #     database: testdb
  #     limit_start: 0
  #     limit_end: 1000

Y ahora lo mas importante ¿Que estamos buscando? Para ello generamos fingerprint.yml.

"Credit Card - Visa": '\b4[0-9]{12}(?:[0-9]{3})?\b'
"Credit Card - Mastercard": '\b5[1-5][0-9]{14}\b'
"Credit Card - American Express": '\b3[47][0-9]{13}\b'
"Credit Card - Discover": '\b6(?:011|5[0-9]{2})[0-9]{12}\b'
"Social Security Number (SSN)": '\b\d{3}-\d{2}-\d{4}\b'
"Email Address": '\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
"Phone Number - US": '\b(?:\+?1[-.]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b'
"Phone Number - International": '\b\+\d{1,3}[-.\s]?\d{1,4}[-.\s]?\d{1,4}[-.\s]?\d{1,9}\b'
"AWS Access Key": '\b(AKIA|A3T|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA)[A-Z0-9]{16}\b'
"AWS Secret Key": '\b[A-Za-z0-9/+=]{40}\b'
"Private Key": '-----BEGIN (RSA|DSA|EC|OPENSSH|PGP) PRIVATE KEY-----'
"Generic Password": "(?i)(password|pwd|passwd)\\s*[=:]\\s*\\S{4,}"
"API Key": "(?i)(api[_-]?key|apikey)\\s*[=:]\\s*[A-Za-z0-9_\\-]{20,}"
"JWT Token": '\beyJ[A-Za-z0-9_-]*\.eyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*\b'
"IP Address - Private": '\b(?:10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(?:1[6-9]|2[0-9]|3[01])\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})\b'
"IBAN": '\b[A-Z]{2}\d{2}[A-Z0-9]{4}\d{7}([A-Z0-9]?){0,16}\b'
"Bitcoin Address": '\b[13][a-km-zA-HJ-NP-Z1-9]{25,34}\b'
"URL with Credentials": '(?i)https?://[^:]+:[^@]+@[^\s]+'

¿Qué hace?

• Define 15+ patrones regex para detectar datos sensibles

• Incluye: tarjetas (Visa, MC, Amex), SSN, emails, teléfonos, AWS keys, JWT, passwords, IPs, etc.Cada

Generación Datos Dummies

Vamos a crear un entorno virtual para ejecutar el generador de datos. Lo encontrarás en la carpeta data.

python3 -m venv env
source env/bin/activate
# Instalar dependencias
pip3 install -r requirements.txt
# Correr el generador
> python3 generar_datos.py
============================================================
Generando datos de prueba PCI/PII
============================================================

[1] Conectando a MySQL...
[2] Creando tabla de pagos...
[3] Insertando datos PCI (tarjetas de crédito)...
   ✓ 4 tarjetas insertadas

[4] Generando PDF con información PII...
   ✓ PDF generado

[5] Conectando a S3 (LocalStack)...
[6] Creando bucket...
   ✓ Bucket 'poc-bucket' creado
[7] Subiendo PDF con datos sensibles...
   ✓ PDF subido: s3://poc-bucket/hr/empleados_confidencial.pdf
[8] Subiendo archivo de texto con más PII...
   ✓ Archivo TXT subido: s3://poc-bucket/contacts/internal_directory.txt

============================================================
✅ DATOS DE PRUEBA GENERADOS EXITOSAMENTE
============================================================

Resumen:
  • MySQL tabla 'payments': 4 registros con tarjetas
  • S3 archivo PDF: 3 empleados con SSN y tarjetas
  • S3 archivo TXT: 3 contactos con datos sensibles

💡 Ahora ejecuta el scanner con: docker exec -it hawk-scanner python run_hawk_scanner.py

Vamos a revisar la data en MySQL

Perfecto, ahora listamos el S3 Bucket donde vemos las dos carpetas, con información, que habíamos generado.

Vamos a revisar nuestro run_hawk_scanner.py. Script orquestador que automatiza el proceso completo de escaneo de seguridad, consolidación de resultados y generación de reportes. Ahora vamos a correr nuestra Aguila. En mi caso desde el docker.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import subprocess
import json
import os
import sys
from datetime import datetime
from collections import Counter
from severity_classifier import reclassify_findings, get_critical_findings
from alert_manager import AlertManager
from thehive_integration import TheHiveIntegration

# Directorios
ALERTS_DIR = "/app/alerts"
RESULTS_DIR = "/app/alerts"

os.makedirs(ALERTS_DIR, exist_ok=True)
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")

def run_scan(source_type, output_file):
    print(f"🔍 Escaneando {source_type}...")
    cmd = [
        "hawk_scanner",
        source_type,
        "--connection", "connection.yml",
        "--fingerprint", "fingerprint.yml",
        "--json", output_file
    ]

    try:
        result = subprocess.run(cmd, capture_output=True, text=True)
        if result.returncode == 0:
            print(f"✅ {source_type} completado: {output_file}")
            return True
        else:
            print(f"❌ Error en {source_type}:")
            print(result.stderr)
            return False
    except Exception as e:
        print(f"❌ Excepción en {source_type}: {e}")
        return False

def consolidate_results(mysql_file, s3_file, output_file):
    all_results = []

    if os.path.exists(mysql_file):
        with open(mysql_file, 'r') as f:
            mysql_data = json.load(f)
            if isinstance(mysql_data, dict):
                for key, findings in mysql_data.items():
                    if isinstance(findings, list):
                        all_results.extend(findings)
            elif isinstance(mysql_data, list):
                all_results.extend(mysql_data)

    if os.path.exists(s3_file):
        with open(s3_file, 'r') as f:
            s3_data = json.load(f)
            if isinstance(s3_data, dict):
                for key, findings in s3_data.items():
                    if isinstance(findings, list):
                        all_results.extend(findings)
            elif isinstance(s3_data, list):
                all_results.extend(s3_data)

    all_results = reclassify_findings(all_results)

    with open(output_file, 'w') as f:
        json.dump(all_results, f, indent=2)

    print(f"📊 Resultados consolidados: {len(all_results)} hallazgos")
    return all_results

def display_findings(results):
    if not results:
        print("\n✅ No se detectaron hallazgos de seguridad")
        return

    print(f"\n{'='*70}")
    print(f"🔍 HALLAZGOS DETECTADOS")
    print(f"{'='*70}")

    by_severity = {}
    for r in results:
        severity = r.get('severity', 'Unknown')
        if severity not in by_severity:
            by_severity[severity] = []
        by_severity[severity].append(r)

    severity_order = ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'Unknown']
    severity_icons = {
        'CRITICAL': '🔴',
        'HIGH': '🟠', 
        'MEDIUM': '🟡',
        'LOW': '🟢',
        'Unknown': '⚪'
    }

    for severity in severity_order:
        if severity not in by_severity:
            continue

        findings = by_severity[severity]
        icon = severity_icons.get(severity, '⚪')

        print(f"\n{icon} {severity} - {len(findings)} hallazgos")
        print("-" * 70)

        max_display = len(findings) if severity == 'CRITICAL' else min(5, len(findings))

        for i, finding in enumerate(findings[:max_display], 1):
            print(f"\n  [{i}] {finding.get('pattern_name', 'Unknown Pattern')}")
            print(f"      Fuente: {finding.get('data_source', 'unknown')}")

            if finding.get('data_source') == 'mysql':
                print(f"      Base de datos: {finding.get('database', 'N/A')}")
                print(f"      Tabla: {finding.get('table', 'N/A')}")
                print(f"      Columna: {finding.get('column', 'N/A')}")
            elif finding.get('data_source') == 's3':
                print(f"      Bucket: {finding.get('bucket', 'N/A')}")
                print(f"      Archivo: {finding.get('file_path', 'N/A')}")

            matches = finding.get('matches', [])
            if matches:
                match_preview = matches[:3]
                print(f"      Matches: {', '.join(match_preview)}")
                if len(matches) > 3:
                    print(f"      ... y {len(matches) - 3} más")

        if len(findings) > max_display:
            print(f"\n  ... y {len(findings) - max_display} hallazgos más de severidad {severity}")

def generate_summary(results, output_file):
    valid_results = [r for r in results if isinstance(r, dict) and 'pattern_name' in r]

    summary = {
        "scan_date": datetime.now().isoformat(),
        "total_findings": len(valid_results),
        "by_severity": dict(Counter([r.get('severity', 'unknown') for r in valid_results])),
        "by_pattern": dict(Counter([r.get('pattern_name', 'unknown') for r in valid_results])),
        "by_source": dict(Counter([r.get('data_source', 'unknown') for r in valid_results])),
        "findings": valid_results
    }

    with open(output_file, 'w') as f:
        json.dump(summary, f, indent=2, default=str)

    print(f"\n{'='*70}")
    print(f"📈 RESUMEN ESTADÍSTICO")
    print(f"{'='*70}")
    print(f"   📊 Total de hallazgos: {summary['total_findings']}")

    print(f"\n   🚨 Por severidad:")
    severity_display_order = ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW']
    for severity in severity_display_order:
        count = summary['by_severity'].get(severity, 0)
        if count > 0:
            print(f"      {severity}: {count}")

    print(f"\n   📁 Por fuente:")
    for source, count in summary['by_source'].items():
        print(f"      {source}: {count}")

    print(f"\n   🔍 Top 5 patrones más detectados:")
    top_patterns = sorted(summary['by_pattern'].items(), 
                         key=lambda x: x[1], reverse=True)[:5]
    for pattern, count in top_patterns:
        print(f"      {pattern}: {count}")

    critical = get_critical_findings(valid_results)
    if critical:
        print(f"\n   ⚠️  ATENCIÓN: {len(critical)} hallazgos CRÍTICOS detectados")
        print(f"      Requieren acción inmediata")

    return summary

if __name__ == "__main__":
    print("=" * 70)
    print("🦅 HAWK-EYE SCANNER - Automated Security Scan")
    print("=" * 70)

    mysql_output = f"{RESULTS_DIR}/mysql_{timestamp}.json"
    s3_output = f"{RESULTS_DIR}/s3_{timestamp}.json"
    consolidated_output = f"{RESULTS_DIR}/consolidated_{timestamp}.json"
    summary_output = f"{RESULTS_DIR}/summary_{timestamp}.json"
    latest_output = f"{RESULTS_DIR}/latest.json"

    mysql_success = run_scan("mysql", mysql_output)
    s3_success = run_scan("s3", s3_output)

    if mysql_success or s3_success:
        results = consolidate_results(mysql_output, s3_output, consolidated_output)

        # SISTEMA DE TRACKING
        print(f"\n{'='*70}")
        print("🔄 Procesando con sistema de tracking...")
        print(f"{'='*70}")

        alert_mgr = AlertManager()

        new_alerts = []
        duplicate_count = 0

        for finding in results:
            processed = alert_mgr.process_finding(finding)
            if processed['is_new']:
                new_alerts.append(processed)
            else:
                duplicate_count += 1

        print(f"\n📊 Resultados del tracking:")
        print(f"   • Total de hallazgos: {len(results)}")
        print(f"   • Alertas NUEVAS: {len(new_alerts)}")
        print(f"   • Ya vistos: {duplicate_count}")

        stats = alert_mgr.get_stats()
        if stats['critical_pending'] > 0:
            print(f"\n   ⚠️  {stats['critical_pending']} alertas CRÍTICAS pendientes")

        # INTEGRACIÓN CON THEHIVE
        thehive = TheHiveIntegration()

        if thehive.test_connection():
            print(f"\n{'='*70}")
            print("🎯 Enviando alertas críticas a TheHive...")
            print(f"{'='*70}")

            cases_created = 0
            for alert in new_alerts:
                finding = alert['finding']
                if finding.get('severity') in ['CRITICAL', 'HIGH']:
                    case_id = thehive.create_case(finding, alert['alert_hash'])
                    if case_id:
                        cases_created += 1

            print(f"\n📋 Casos creados en TheHive: {cases_created}")
            print(f"🌐 Accede al dashboard: http://localhost:9000")
        else:
            print("\n⚠️  TheHive no está disponible (casos no enviados)")

        display_findings(results)
        generate_summary(results, summary_output)

        with open(latest_output, 'w') as f:
            json.dump(results, f, indent=2)

        print(f"\n{'='*70}")
        print(f"✅ Escaneo completado exitosamente")
        print(f"📁 Resultados guardados en: {ALERTS_DIR}/")
        print(f"{'='*70}\n")
    else:
        print("\n❌ Escaneo falló")
        exit(1)

docker exec -it hawk-scanner python run_hawk_scanner.py

¡Voilà, aquí están los registros marcados por severidad!

Ahora sabemos dónde están las joyas de la corona, para poder actuar en consecuencia. Vamos un poco mas adelante e integremos The Hive para poder hacer el seguimiento.

The Hive

Es la plataforma donde llevaremos adelante el seguimiento de los hallazgos. La misma esta en http://localhost:9000.

• Usuario: admin@thehive.local

• Password: secret

Es importante que obtengamos una API KEY para poder integrarla.

1. Crear organización (si no existe):

   • Haz clic en "Admin" (arriba a la derecha)

   • "Organizations" → "+ New Organization"

   • Nombre: hawk-security

   • Haz clic en "Create"

2. Crear usuario con permisos:

   • "Users" → "+ New User"

   • Nombre: hawk-scanner

   • Login: hawk-scanner@hawk-security

   • Perfil: org-admin (¡importante!)

   • Organización: hawk-security

   • Contraseña: HawkScanner2024!

   • Haz clic en "Create"

3. Crear API Key:

   • Haz clic en el usuario hawk-scanner que acabas de crear

   • Pestaña "API Keys"

   • Haz clic en "+ Create API Key"

   • Nombre: hawk-scanner-api

   • Haz clic en "Create"

   • ⚠️ COPIA LA KEY

Estos son datos dummies, yo lo cree asi.

La sumamos la API Key a thehive_integration.py, antes de ejecutar. Una vez que el Hawk Eye se ejecute, veremos en The Hive:

5 casos creados:

• 🔴 4 CRITICAL: Credit Cards (Visa, Mastercard, Amex, Discover)

• 🟠 1 HIGH: Social Security Number (SSN)

Listo, tenemos todo para darle seguimiento. Te dejo el repositorio para que puedas hacerlo en tu laboratorio.

Referencias

https://github.com/rohitcoder/hawk-eye

LDAP

A continuación, echemos un vistazo a la estructura LDAP que queremos construir. El árbol muestra la estructura jerárquica del directorio, comenzando por el DN base dc=ironbox,dc=local. Debajo de esta base hay tres departamentos (ou=IT, ou=DevOps y ou=SecOps) y varios usuarios. Esto se definirá en el siguiente paso utilizando un archivo LDIF.

Aca el .ldif

# admin user
dn: cn=admin,dc=ironbox,dc=local
changetype: add
objectClass: simpleSecurityObject
objectClass: organizationalRole
cn: admin
userPassword: adminpassword
description: LDAP Administrator

# organisational unit for IT department
dn: ou=IT,dc=ironbox,dc=local
changetype: add
objectClass: organizationalUnit
ou: IT

# user: Juan Perez for unit IT department
dn: uid=juanperez,ou=IT,dc=ironbox,dc=local
changetype: add
objectClass: inetOrgPerson
cn: Juan Perez
sn: Perez
uid: juanperez
mail: juanperez@ironbox.local
userPassword: password123

# user: Ana Rey for unit IT department
dn: uid=anna.meier,ou=IT,dc=ironbox,dc=local
changetype: add
objectClass: inetOrgPerson
cn: Ana Rey
sn: Rey
uid: ana.rey
mail: ana.rey@ironbox.local
userPassword: password456

# organisational unit for DevOps department
dn: ou=DevOps,dc=ironbox,dc=local
changetype: add
objectClass: organizationalUnit
ou: DevOps

# user: Pedro Sanchez for the  der marketing department
dn: uid=pedro.sanchez,ou=DevOps,dc=ironbox,dc=local
changetype: add
objectClass: inetOrgPerson
cn: Pedro Sanchez
sn: Sanchez
uid: pedro.sanchez
mail: pedro.sanchez@ironbox.local
userPassword: password789

# organisational unit for Information Security department
dn: ou=SecOps,dc=ironbox,dc=local
changetype: add
objectClass: organizationalUnit
ou: DevOps

# user: Santiago Fernandez for the  der marketing department
dn: uid=santiago.fernandez,ou=SecOps,dc=ironbox,dc=local
changetype: add
objectClass: inetOrgPerson
cn: Santiago Fernandez
sn: Ssantiago
uid: santiago.fernandez
mail: santiago.fernandez@ironbox.local
userPassword: Marte2000

Authentik

Authentik es una herramienta open source que sirve para gestionar usuarios, accesos y autenticaciones dentro de una organización. Podés pensarla como el “centro de control” donde definís quién puede entrar, a qué sistemas, y por cuánto tiempo.

Permite unificar el acceso a distintas aplicaciones (internas o externas) usando SSO (inicio de sesión único), autenticación multifactor (MFA) y reglas de seguridad personalizables.

A diferencia de otros sistemas cerrados como Okta o Azure AD, Authentik se puede instalar en tus propios servidores, lo que da más control y privacidad sobre los datos de tus usuarios.

Una vez que levantamos el compose vamos a obtener credeciales. Para luego ingresar a http://localhost:9000

docker exec -it authentik-server ak changepassword akadmin

Vamos a ingresar y crear la conexión con LDAP.

Los datos importantes son:

• URI del servidor: ldap://openldap:389

• CN de enlace: cn=admin,dc=ironbox,dc=local

• Contraseña de enlace: admin

• DN base: dc=ironbox,dc=local

• Habilitar StartTLS: NO

• Usar URI del servidor para verificación SNI: NO

• Certificado de verificación TLS: (vacío)

• Certificado de autenticación del cliente TLS: (vacío)

• DN de usuario adicional: (VACÍO - muy importante)

• DN de grupo de adición: (VACÍO - muy importante)

• Filtro de objetos de usuario: (objectClass=inetOrgPerson)

• Filtro de objetos de grupo: (objectClass=groupOfNames)

• Campo pertenencia a grupos: member

• Campo de unicidad de objetos: Uusar: entryUUID

• Agregar estos Mappings:

Dejamos correr la sincronización.

¡Voilà! Ya vemos los usuarios de nuestro iDP LDAP.

Aplicación

Generación de Proxy en Proveedores.

Vamos a crear la aplicación para que ejecute el el Workflow de Credenciales.

Transporte de Notificacion

Vault

Vamos agregar los roles, usando la Base de Datos que ya tenemos. Podríamos agregar las que desearemos.

Primero habilitamos los secretos.

docker exec -e VAULT_TOKEN='root' vault vault secrets enable database

Luego configuramos la conexión con MySQL.

# Configurar la conexión
docker exec -e VAULT_TOKEN='root' vault vault write database/config/mysql-test \
    plugin_name=mysql-database-plugin \
    allowed_roles="mysql-readonly,mysql-readwrite,mysql-admin" \
    connection_url="{{username}}:{{password}}@tcp(mysql-test:3306)/testdb" \
    username="root" \
    password="rootpass123"

Ahora los roles que necesitamos, para esta Prueba.

# Crear roles
docker exec -e VAULT_TOKEN='root' vault vault write database/roles/mysql-readonly \
    db_name=mysql-test \
    creation_statements="CREATE USER '{{name}}'@'%' IDENTIFIED BY '{{password}}'; GRANT SELECT ON testdb.* TO '{{name}}'@'%';" \
    default_ttl="1h" \
    max_ttl="24h"

docker exec -e VAULT_TOKEN='root' vault vault write database/roles/mysql-readwrite \
    db_name=mysql-test \
    creation_statements="CREATE USER '{{name}}'@'%' IDENTIFIED BY '{{password}}'; GRANT SELECT, INSERT, UPDATE, DELETE ON testdb.* TO '{{name}}'@'%';" \
    default_ttl="1h" \
    max_ttl="2h"

Agregamos la politica para N8N

vault policy write n8n-policy - <<EOF
path "database/creds/*" {
  capabilities = ["read"]
}
path "sys/leases/revoke" {
  capabilities = ["update"]
}
EOF

Creamos el Token, para que N8N pueda dialogar con Vault.

vault token create -policy=n8n-policy -ttl=8760h

Auditoria

Vamos a generar un base de datos, donde guardaremos todos los pedidos.

docker exec -it mysql-test mysql -u root -prootpass123

Ejecutamos

-- Usar la base de datos (o crear una nueva)
USE testdb;

-- O crear una base de datos específica para esto:
-- CREATE DATABASE db_access_manager;
-- USE db_access_manager;

-- Crear tabla de solicitudes
CREATE TABLE IF NOT EXISTS access_requests (
  id INT AUTO_INCREMENT PRIMARY KEY,
  request_id VARCHAR(100) UNIQUE NOT NULL,
  user_email VARCHAR(255) NOT NULL,
  user_username VARCHAR(255) NOT NULL,
  user_fullname VARCHAR(255) NOT NULL,
  database_name VARCHAR(100) NOT NULL,
  database_label VARCHAR(255) NOT NULL,
  access_type VARCHAR(50) NOT NULL,
  duration VARCHAR(10) NOT NULL,
  reason TEXT NOT NULL,
  status VARCHAR(20) DEFAULT 'pending',
  requested_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  approved_by VARCHAR(255) NULL,
  approved_at TIMESTAMP NULL,
  rejection_reason TEXT NULL,
  vault_role VARCHAR(100) NOT NULL,
  db_host VARCHAR(255) NOT NULL,
  db_port INT NOT NULL,
  db_name VARCHAR(255) NOT NULL,
  db_type VARCHAR(50) NOT NULL,
  credentials_username VARCHAR(255) NULL,
  credentials_sent BOOLEAN DEFAULT FALSE,
  INDEX idx_request_id (request_id),
  INDEX idx_status (status),
  INDEX idx_user_email (user_email),
  INDEX idx_requested_at (requested_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

-- Verificar que se creó correctamente
DESCRIBE access_requests;

-- Ver las tablas
SHOW TABLES;

Agregamos las credenciales de MySQL a N8N

Workflows

Aquí están los 4 que usaremos. Ahora los revisaremos uno por uno.

El primero que se dispara es el Init DB Request Form que es llamado por Authentik. En este caso el usuario solicita el acceso, pero antes de solicitarselo a Vault es necesario que los integrantes de SecOps aprueben esta solicitud. El formulario ejecuta Get Available Databases, para saber cuales tenemos cargadas en Vault para administrar.

Al solicitar el acceso, se ejecuta Database Access Processor para el envío de correo, de modo que le llegue al equipo de SecOps.

Mientras tanto, en la Base de Datos de Auditoría, ya tenemos el registro del pedido.

Una vez que se apruebe o rechace se ejecuta Process Email Approval. Que tiene estos pasos.

Donde se verifica si el token es válido, si existe una solicitud y, según la aprobación o no por parte de SecOps, se ejecuta la aplicación de permisos. En este caso de prueba, vamos a seleccionar aprobar.

Mientras que el usuario le llega este correo, con todos los datos necesarios.

Aquí les dejo un resumen de los tiempos de ejecución.

Lógicamente, el registro de auditoría cambió de estado, incluyendo todos los datos de aprobación.

Aca el Docker Compose.

version: '3'

networks:
  ldap_network:
    driver: bridge

services:
  # PostgreSQL para Authentik
  postgresql:
    image: docker.io/library/postgres:16-alpine
    container_name: authentik-db
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}"]
      start_period: 20s
      interval: 30s
      retries: 5
      timeout: 5s
    volumes:
      - postgres-data:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: ${PG_PASS:-admin123}
      POSTGRES_USER: ${PG_USER:-authentik}
      POSTGRES_DB: ${PG_DB:-authentik}
    networks:
      - ldap_network

  # Redis para Authentik
  redis:
    image: docker.io/library/redis:alpine
    container_name: authentik-redis
    command: --save 60 1 --loglevel warning
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "redis-cli ping | grep PONG"]
      start_period: 20s
      interval: 30s
      retries: 5
      timeout: 3s
    volumes:
      - redis-data:/data
    networks:
      - ldap_network

  # Authentik Server
  server:
    image: ghcr.io/goauthentik/server:2024.8.3
    container_name: authentik-server
    restart: unless-stopped
    command: server
    environment:
      AUTHENTIK_REDIS__HOST: redis
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS:-admin123}
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY:-changeme-please-generate-a-secret-key}
      AUTHENTIK_ERROR_REPORTING__ENABLED: "false"
      # Para integración con LDAP
      AUTHENTIK_LDAP__HOST: openldap
      AUTHENTIK_LDAP__PORT: 389
    volumes:
      - ./authentik/media:/media
      - ./authentik/custom-templates:/templates
    ports:
      - "9000:9000"
      - "9443:9443"
    depends_on:
      - postgresql
      - redis
      - openldap
    networks:
      - ldap_network

  # Authentik Worker
  worker:
    image: ghcr.io/goauthentik/server:2024.8.3
    container_name: authentik-worker
    restart: unless-stopped
    command: worker
    environment:
      AUTHENTIK_REDIS__HOST: redis
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS:-admin123}
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY:-changeme-please-generate-a-secret-key}
      AUTHENTIK_ERROR_REPORTING__ENABLED: "false"
    user: root
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./authentik/media:/media
      - ./authentik/certs:/certs
      - ./authentik/custom-templates:/templates
    depends_on:
      - postgresql
      - redis
      - openldap
    networks:
      - ldap_network

  # OpenLDAP
  openldap:
    image: osixia/openldap:latest
    container_name: openldap
    environment:
      LDAP_BASE_DN: "dc=ironbox,dc=local"
      LDAP_ORGANISATION: "Ironbox"
      LDAP_DOMAIN: "ironbox.local"
      LDAP_ADMIN_PASSWORD: "admin"
      LDAP_TLS: "false"
    volumes:
      - ./ldap/bootstrap.ldif:/container/service/slapd/assets/config/bootstrap/ldif/custom/50-bootstrap.ldif
      - ldap-data:/var/lib/ldap
      - ldap-config:/etc/ldap/slapd.d
    networks:
      - ldap_network
    ports:
      - "389:389"
    command: --copy-service
    restart: unless-stopped

# phpLDAPadmin
  phpldapadmin:
    image: osixia/phpldapadmin:latest
    container_name: phpldapadmin
    environment:
      PHPLDAPADMIN_LDAP_HOSTS: openldap
      PHPLDAPADMIN_HTTPS: "false"
    networks:
      - ldap_network
    ports:
      - "8081:80"
    restart: unless-stopped
    depends_on:
      - openldap

  # N8N - Workflow Automation
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=admin123
      - N8N_HOST=localhost
      - N8N_PORT=5678
      - N8N_PROTOCOL=http
      - WEBHOOK_URL=http://localhost:5678/
      - GENERIC_TIMEZONE=America/Argentina/Buenos_Aires
    volumes:
      - n8n-data:/home/node/.n8n
    networks:
      - ldap_network

  # HashiCorp Vault
  vault:
    image: hashicorp/vault:latest
    container_name: vault
    restart: unless-stopped
    ports:
      - "8200:8200"
    environment:
      VAULT_DEV_ROOT_TOKEN_ID: "root"
      VAULT_DEV_LISTEN_ADDRESS: "0.0.0.0:8200"
      VAULT_ADDR: "http://0.0.0.0:8200"
    cap_add:
      - IPC_LOCK
    networks:
      - ldap_network
    command: server -dev
  # MySQL de prueba
  mysql-test:
    image: mysql:8.0
    container_name: mysql-test
    environment:
      MYSQL_ROOT_PASSWORD: rootpass123
      MYSQL_DATABASE: testdb
      MYSQL_USER: testuser
      MYSQL_PASSWORD: testpass123
    ports:
      - "3306:3306"
    networks:
      - ldap_network
    volumes:
      - mysql_data:/var/lib/mysql
volumes:
  postgres-data:
    driver: local
  redis-data:
    driver: local
  ldap-data:
    driver: local
  ldap-config:
    driver: local
  n8n-data:
    driver: local
  mysql_data:
    driver: local

¡Espero que les sirva! Les dejo el repositorio y un pequeño video para que vean lo que hemos creado.

Saludos.

Referencias

https://helgeklein-com.translate.goog/blog/authentik-authentication-sso-user-management-password-reset-for-home-networks/?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=es&_x_tr_pto=tc

En el blog hemos implementado de todo, pero nunca un Monitoreo de Actividad de Base de Datos o un Firewall de Base de Datos, que utilizaremos para vigilar y registrar cada acción realizada en un sistema de bases de datos. Esto garantiza el acceso correcto a los datos, detecta actividades no autorizadas o sospechosas, y protege la información confidencial.

Imaginemos un escenario donde hemos sido vulnerados o, en su defecto, un empleado descontento que quiere ejecutar un DROP. Vamos a implementar ProxySQL para que esté en el medio entre el cliente y la base de datos y generar reglas para permitir o no comandos.

Arquitectura

ProxySQL

Es un proxy inteligente para bases de datos MySQL/MariaDB.

En pocas líneas 👇

• Se ubica entre la aplicación y el servidor MySQL.

• Permite filtrar, enrutar y balancear queries (por ejemplo, leer en réplicas y escribir en el master).

• Puede bloquear o reescribir consultas peligrosas (DROP, TRUNCATE, etc.).

• Mejora el rendimiento con cacheo de queries y pool de conexiones.

• Facilita la observabilidad y control de tráfico SQL sin modificar la app.

👉 ProxySQL no puede modificar los datos devueltos por MySQL (como hashearlos u ofuscarlos), porque trabaja a nivel de capa de conexión y enrutamiento, no de contenido.
Su función principal es decidir a dónde va una query, si se permite o no, o si se reescribe antes de ejecutarse — pero no procesa ni altera los resultados que vienen del servidor. Ahi tenemos que aplicar Hasheo u ofuscación en el propio MySQL o consumir a traves de API que realice ese trabajo.

Vamos a lo nuestro. Todo estará en el repositorio, pero echemos un vistazo a config/proxysql/proxysql.cnf.

# config/proxysql/proxysql.cnf
datadir="/var/lib/proxysql"

admin_variables=
{
    admin_credentials="admin:admin"
    mysql_ifaces="0.0.0.0:6032"
    refresh_interval=2000
}

mysql_variables=
{
    threads=4
    max_connections=2048
    default_query_delay=0
    default_query_timeout=36000000
    have_compress=true
    poll_timeout=2000
    interfaces="0.0.0.0:6033"
    default_schema="information_schema"
    stacksize=1048576
    server_version="8.0.0"
    connect_timeout_server=3000
    monitor_username="monitor"
    monitor_password="monitor"
    monitor_history=600000
    monitor_connect_interval=60000
    monitor_ping_interval=10000
    monitor_read_only_interval=1500
    monitor_read_only_timeout=500
    ping_interval_server_msec=120000
    ping_timeout_server=500
    commands_stats=true
    sessions_sort=true
    connect_retries_on_failure=10

    # LOGGING
    eventslog_filename="/var/log/proxysql/queries.log"
    eventslog_default_log=1
    eventslog_format=2
}

# Backend MySQL servers
mysql_servers =
(
    {
        address="mysql-db"
        port=3306
        hostgroup=0
        max_connections=200
    }
)

# Users
mysql_users =
(
    {
        username = "app_user"
        password = "app_password"
        default_hostgroup = 0
        max_connections = 200
        active = 1
    }
)

# Query Rules - AQU BLOQUEAMOS COMANDOS PELIGROSOS
mysql_query_rules =
(
    # BLOQUEAR DROP
    {
        rule_id=1
        active=1
        match_pattern="(?i)^\\s*DROP\\s+(TABLE|DATABASE|SCHEMA)"
        error_msg="ERROR: DROP statements estan bloqueados por politica de seguridad"
        log=1
        apply=1
    },
    # BLOQUEAR TRUNCATE
    {
        rule_id=2
        active=1
        match_pattern="(?i)^\\s*TRUNCATE\\s+TABLE"
        error_msg="ERROR: TRUNCATE TABLE esta bloqueado por politica de seguridad"
        log=1
        apply=1
    },
    # BLOQUEAR DELETE SIN WHERE
    {
        rule_id=3
        active=1
        match_pattern="(?i)^\\s*DELETE\\s+FROM\\s+[a-zA-Z0-9_]+\\s*;?\\s*$"
        error_msg="ERROR: DELETE sin WHERE no esta permitido"
        log=1
        apply=1
    },
    # BLOQUEAR UPDATE SIN WHERE
    {
        rule_id=4
        active=1
        match_pattern="(?i)^\\s*UPDATE\\s+[a-zA-Z0-9_]+\\s+SET\\s+(?!.*WHERE).*$"
        error_msg="ERROR: UPDATE sin WHERE no esta permitido"
        log=1
        apply=1
    },
    # BLOQUEAR ALTER TABLE
    {
        rule_id=5
        active=1
        match_pattern="(?i)^\\s*ALTER\\s+TABLE"
        error_msg="ERROR: ALTER TABLE esta bloqueado - contacte al DBA"
        log=1
        apply=1
    },
    # BLOQUEAR GRANT/REVOKE
    {
        rule_id=6
        active=1
        match_pattern="(?i)^\\s*(GRANT|REVOKE)"
        error_msg="ERROR: Cambios de permisos no permitidos"
        log=1
        apply=1
    },
    # PERMITIR TODO LO DEMAS
    {
        rule_id=100
        active=1
        match_pattern=".*"
        destination_hostgroup=0
        log=1
        apply=1
    }
)

Ahora las reglas de Wazuh en config/wazuh_cluster/proxysql-rules.xml

<!-- config/wazuh_cluster/proxysql-rules.xml -->
<group name="proxysql,database,firewall,">

  <!-- Regla base - Query event de ProxySQL -->
  <rule id="100500" level="0">
    <field name="event">COM_QUERY</field>
    <description>ProxySQL query event</description>
  </rule>

  <!-- Query BLOQUEADA (hostgroup_id = -1) -->
  <rule id="100501" level="8">
    <if_sid>100500</if_sid>
    <field name="hostgroup_id">-1</field>
    <description>ProxySQL: Query bloqueada por firewall</description>
    <group>database_security,firewall_block,</group>
  </rule>

  <!-- DROP bloqueado -->
  <rule id="100502" level="12">
    <if_sid>100501</if_sid>
    <match>DROP TABLE</match>
    <description>ProxySQL: DROP TABLE bloqueado</description>
    <group>database_attack,pci_dss_10.2.5,</group>
    <mitre>
      <id>T1485</id>
    </mitre>
  </rule>

  <!-- TRUNCATE bloqueado -->
  <rule id="100503" level="12">
    <if_sid>100501</if_sid>
    <match>TRUNCATE TABLE</match>
    <description>ProxySQL: TRUNCATE TABLE bloqueado</description>
    <group>database_attack,data_loss,</group>
  </rule>

  <!-- DELETE bloqueado -->
  <rule id="100504" level="10">
    <if_sid>100501</if_sid>
    <match>DELETE FROM</match>
    <description>ProxySQL: DELETE bloqueado</description>
    <group>database_security,</group>
  </rule>

  <!-- UPDATE bloqueado -->
  <rule id="100505" level="10">
    <if_sid>100501</if_sid>
    <match>UPDATE</match>
    <description>ProxySQL: UPDATE bloqueado</description>
    <group>database_security,</group>
  </rule>

  <!-- ALTER bloqueado -->
  <rule id="100506" level="10">
    <if_sid>100501</if_sid>
    <match>ALTER TABLE</match>
    <description>ProxySQL: ALTER TABLE bloqueado</description>
    <group>database_security,ddl,</group>
  </rule>

  <!-- Query PERMITIDA (hostgroup_id >= 0) -->
  <rule id="100510" level="2">
    <if_sid>100500</if_sid>
    <field name="hostgroup_id">0</field>
    <description>ProxySQL: Query ejecutada exitosamente</description>
    <group>database_access,</group>
  </rule>

  <!-- SELECT permitido -->
  <rule id="100511" level="2">
    <if_sid>100510</if_sid>
    <match>SELECT</match>
    <description>ProxySQL: SELECT ejecutado</description>
    <group>database_access,query,</group>
  </rule>

  <!-- INSERT permitido -->
  <rule id="100512" level="4">
    <if_sid>100510</if_sid>
    <match>INSERT</match>
    <description>ProxySQL: INSERT ejecutado</description>
    <group>database_access,data_modification,</group>
  </rule>

  <!-- Múltiples bloqueos -->
  <rule id="100520" level="14" frequency="5" timeframe="120">
    <if_matched_sid>100502</if_matched_sid>
    <description>ProxySQL: Múltiples comandos DROP bloqueados</description>
    <group>database_attack,attacks,</group>
  </rule>

</group>

Este es mi tree de directorio, con todo lo necesario.

Si tenes dudas de correr Wazuh en Docker, podes revisar post anterior o en referencias.

Dejo el proyecto completo en este repositorio.

He añadido N8N para gestionar esa alerta. Las opciones son infinitas; en mi caso, enviaré un correo, pero también podríamos bloquear, notificar por Slack y, por qué no, crear un caso en The Hive.

En ossec.conf añadí esto, justo debajo de donde le indico cómo leer los logs de ProxySQL:

  <!-- ============================================ -->
  <!-- LEER LOGS DE PROXYSQL DIRECTAMENTE             -->
  <!-- ============================================ -->
  <!-- Leer logs de ProxySQL -->
  <localfile>
    <log_format>json</log_format>
    <location>/var/log/proxysql/queries.log</location>
  </localfile>

  <!-- ============================================ -->
  <!-- INTEGRACIÓN CON N8N                          -->
  <!-- ============================================ -->
  <integration>
    <name>custom-n8n</name>
    <hook_url>http://n8n:5678/webhook/wazuh-proxysql</hook_url>
    <level>8</level>
    <rule_id>100502,100503,100504,100505,100506,100507,100508</rule_id>
    <alert_format>json</alert_format>
  </integration>

Prueba

Vamos a ejecutar un comando malicioso para ver cómo reacciona.

Aca la alarma, en Wazuh.

Vemos que corrió la integración.

Con esta evidencia, el Workflow comenzó a correr. Mientras tanto en Wazuh podemos ver la alarma.

Workflow N8N

Este es sencillo, pero hay miles de opciones! Te recuerdo que en el repositorio tenes la carpeta workflow donde esta el ndjson para importar a tu ambiente.

Aca el email, que genere.

Excelente señores ya podemos darle acceso al administrador, a través del proxy, para nuestra seguridad.

Espero que les sirva.

Comandos Utiles

# Ver archives
docker exec single-node-wazuh.manager-1 tail -50 /var/ossec/logs/archives/archives.log | tail -10

# Ver alerts (ahora deberían aparecer!)
docker exec single-node-wazuh.manager-1 tail -100 /var/ossec/logs/alerts/alerts.log | grep -i proxysql

# Ver en formato JSON
docker exec single-node-wazuh.manager-1 tail -50 /var/ossec/logs/alerts/alerts.json | grep -i proxysql

# Ver si hay errores de decoder
docker logs single-node-wazuh.manager-1 2>&1 | grep -i "mysql-decoder\|decoder.*mysql"

# Comando Truncate Bloqueado
docker run --rm --network single-node_poc-network mysql:8.0 \
  mysql -h proxysql -P 6033 -u app_user -papp_password produccion \
  -e "TRUNCATE TABLE auditoria;" 2>&1

# Comando Select Habilitado
docker run --rm --network single-node_poc-network mysql:8.0 \
  mysql -h proxysql -P 6033 -u app_user -papp_password produccion \
  -e "SELECT * FROM usuarios LIMIT 3;" 2>/dev/null

Generé una API Dummy de cuentas bancarias y para protegerla vamos a tener API Manager Kong al frente, reportando los log’s de las consultas que recibe a Wazuh. Si tenemos coincidencia con algunas de las reglas que cargaremos en Wazuh, se responderá al evento. Esa respuesta será dada por N8N, ejecutando un flujo de trabajo donde realizaremos diferentes pasos, como agregar la dirección del atacante en una lista negra de Kong o enviar un mensaje o, por qué no, levantar el caso en The Hive. Como si fuera poco agregamos Konga para la gestión grafica de Kong.

Arquitectura

Antes de eso deberían descargar la configuración de Wazuh Docker, para esta ocasión uso single-node-stack.

git clone https://github.com/wazuh/wazuh-docker.git -b v4.13.1

Generamos los certificados.

cd wazuh-docker/single-node/
docker compose -f generate-indexer-certs.yml run --rm generator

Una vez que lo corramos, podemos modificar le docker-compose original, con todo el stack necesario para esta prueba de concepto.

# Wazuh App Copyright (C) 2017, Wazuh Inc. (License GPLv2)
services:
  wazuh.manager:
    image: wazuh/wazuh-manager:4.13.1
    hostname: wazuh.manager
    restart: always
    ulimits:
      memlock:
        soft: -1
        hard: -1
      nofile:
        soft: 655360
        hard: 655360
    ports:
      - "1514:1514"
      - "1515:1515"
      - "514:514/udp"
      - "55000:55000"
    environment:
      - INDEXER_URL=https://wazuh.indexer:9200
      - INDEXER_USERNAME=admin
      - INDEXER_PASSWORD=SecretPassword
      - FILEBEAT_SSL_VERIFICATION_MODE=none
      - SSL_CERTIFICATE_AUTHORITIES=/etc/ssl/root-ca.pem
      - SSL_CERTIFICATE=/etc/ssl/filebeat.pem
      - SSL_KEY=/etc/ssl/filebeat.key
      - API_USERNAME=wazuh-wui
      - API_PASSWORD=MyS3cr37P450r.*-
    volumes:
      - wazuh_api_configuration:/var/ossec/api/configuration
      - wazuh_etc:/var/ossec/etc
      - wazuh_logs:/var/ossec/logs
      - wazuh_queue:/var/ossec/queue
      - wazuh_var_multigroups:/var/ossec/var/multigroups
      - wazuh_integrations:/var/ossec/integrations
      - wazuh_active_response:/var/ossec/active-response/bin
      - wazuh_agentless:/var/ossec/agentless
      - wazuh_wodles:/var/ossec/wodles
      - filebeat_etc:/etc/filebeat
      - filebeat_var:/var/lib/filebeat
      - ./config/wazuh_indexer_ssl_certs/root-ca-manager.pem:/etc/ssl/root-ca.pem
      - ./config/wazuh_indexer_ssl_certs/wazuh.manager.pem:/etc/ssl/filebeat.pem
      - ./config/wazuh_indexer_ssl_certs/wazuh.manager-key.pem:/etc/ssl/filebeat.key
      - ./config/wazuh_cluster/wazuh_manager.conf:/wazuh-config-mount/etc/ossec.conf
      - ./config/wazuh_cluster/kong-rules.xml:/var/ossec/etc/rules/kong-rules.xml:ro
      - ./config/wazuh_cluster/0374-kong-decoder.xml:/var/ossec/etc/decoders/0374-kong-decoder.xml:ro # Agrego el decoder para Kong.
      - ./config/wazuh_cluster/custom-n8n:/var/ossec/integrations/custom-n8n:ro

    networks:
      - poc-network
  wazuh.indexer:
    image: wazuh/wazuh-indexer:4.13.1
    hostname: wazuh.indexer
    restart: always
    ports:
      - "9200:9200"
    environment:
      - "OPENSEARCH_JAVA_OPTS=-Xms1g -Xmx1g"
    ulimits:
      memlock:
        soft: -1
        hard: -1
      nofile:
        soft: 65536
        hard: 65536
    volumes:
      - wazuh-indexer-data:/var/lib/wazuh-indexer
      - ./config/wazuh_indexer_ssl_certs/root-ca.pem:/usr/share/wazuh-indexer/certs/root-ca.pem
      - ./config/wazuh_indexer_ssl_certs/wazuh.indexer-key.pem:/usr/share/wazuh-indexer/certs/wazuh.indexer.key
      - ./config/wazuh_indexer_ssl_certs/wazuh.indexer.pem:/usr/share/wazuh-indexer/certs/wazuh.indexer.pem
      - ./config/wazuh_indexer_ssl_certs/admin.pem:/usr/share/wazuh-indexer/certs/admin.pem
      - ./config/wazuh_indexer_ssl_certs/admin-key.pem:/usr/share/wazuh-indexer/certs/admin-key.pem
      - ./config/wazuh_indexer/wazuh.indexer.yml:/usr/share/wazuh-indexer/opensearch.yml
      - ./config/wazuh_indexer/internal_users.yml:/usr/share/wazuh-indexer/opensearch-security/internal_users.yml
    networks:
      - poc-network
  wazuh.dashboard:
    image: wazuh/wazuh-dashboard:4.13.1
    hostname: wazuh.dashboard
    restart: always
    ports:
      - 443:5601
    environment:
      - INDEXER_USERNAME=admin
      - INDEXER_PASSWORD=SecretPassword
      - WAZUH_API_URL=https://wazuh.manager
      - DASHBOARD_USERNAME=kibanaserver
      - DASHBOARD_PASSWORD=kibanaserver
      - API_USERNAME=wazuh-wui
      - API_PASSWORD=MyS3cr37P450r.*-
    volumes:
      - ./config/wazuh_indexer_ssl_certs/wazuh.dashboard.pem:/usr/share/wazuh-dashboard/certs/wazuh-dashboard.pem
      - ./config/wazuh_indexer_ssl_certs/wazuh.dashboard-key.pem:/usr/share/wazuh-dashboard/certs/wazuh-dashboard-key.pem
      - ./config/wazuh_indexer_ssl_certs/root-ca.pem:/usr/share/wazuh-dashboard/certs/root-ca.pem
      - ./config/wazuh_dashboard/opensearch_dashboards.yml:/usr/share/wazuh-dashboard/config/opensearch_dashboards.yml
      - ./config/wazuh_dashboard/wazuh.yml:/usr/share/wazuh-dashboard/data/wazuh/config/wazuh.yml
      - wazuh-dashboard-config:/usr/share/wazuh-dashboard/data/wazuh/config
      - wazuh-dashboard-custom:/usr/share/wazuh-dashboard/plugins/wazuh/public/assets/custom
    depends_on:
      - wazuh.indexer
    links:
      - wazuh.indexer:wazuh.indexer
      - wazuh.manager:wazuh.manager
    networks:
      - poc-network

# ============================================
# KONG DATABASE
# ============================================
  kong-database:
    image: postgres:15-alpine
    container_name: kong-database
    restart: always
    networks:
      - poc-network
    environment:
      POSTGRES_USER: kong
      POSTGRES_DB: kong
      POSTGRES_PASSWORD: kongpass
    ports:
      - "5432:5432"
    volumes:
      - kong-database-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "kong"]
      interval: 10s
      timeout: 5s
      retries: 5

# ============================================
# KONG MIGRATIONS
# ============================================
  kong-migrations:
    image: kong:3.5
    container_name: kong-migrations
    command: kong migrations bootstrap
    networks:
      - poc-network
    environment:
      KONG_DATABASE: postgres
      KONG_PG_HOST: kong-database
      KONG_PG_USER: kong
      KONG_PG_PASSWORD: kongpass
      KONG_PG_DATABASE: kong
    depends_on:
      kong-database:
        condition: service_healthy
    restart: on-failure

# ============================================
# KONG API GATEWAY
# ============================================
  kong:
      image: kong:3.5
      container_name: kong
      restart: unless-stopped
      networks:
        - poc-network
      environment:
        KONG_DATABASE: postgres
        KONG_PG_HOST: kong-database
        KONG_PG_USER: kong
        KONG_PG_PASSWORD: kongpass
        KONG_PG_DATABASE: kong
        KONG_PROXY_ACCESS_LOG: /dev/stdout
        KONG_ADMIN_ACCESS_LOG: /dev/stdout
        KONG_PROXY_ERROR_LOG: /dev/stderr
        KONG_ADMIN_ERROR_LOG: /dev/stderr
        KONG_ADMIN_LISTEN: 0.0.0.0:8001
        KONG_ADMIN_GUI_LISTEN: 0.0.0.0:8002
        KONG_PROXY_LISTEN: 0.0.0.0:8000, 0.0.0.0:8443 ssl
      ports:
        - "8000:8000"
        - "8443:8443"
        - "8001:8001"
        - "8002:8002"
      depends_on:
        kong-database:
          condition: service_healthy
        kong-migrations:
          condition: service_completed_successfully
      healthcheck:
        test: ["CMD", "kong", "health"]
        interval: 10s
        timeout: 10s
        retries: 10

# ============================================
# KONGA DATABASE
# ============================================
  konga-database:
    image: postgres:9.6-alpine
    container_name: konga-database
    restart: always
    networks:
      - poc-network
    environment:
      POSTGRES_USER: konga
      POSTGRES_DB: konga
      POSTGRES_PASSWORD: kongapass
    ports:
      - "5433:5432"
    volumes:
      - konga-database-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "konga"]
      interval: 10s
      timeout: 5s
      retries: 5

# ============================================
# KONGA PREPARE
# ============================================
  konga-prepare:
    image: pantsel/konga:latest
    container_name: konga-prepare
    command: "-c prepare -a postgres -u postgresql://konga:kongapass@konga-database:5432/konga"
    networks:
      - poc-network
    environment:
      DB_ADAPTER: postgres
      DB_HOST: konga-database
      DB_USER: konga
      DB_PASSWORD: kongapass
      DB_DATABASE: konga
    depends_on:
      konga-database:
        condition: service_healthy
    restart: on-failure

# ============================================
# KONGA GUI
# ============================================
  konga:
    image: pantsel/konga:latest
    container_name: konga
    restart: always
    networks:
      - poc-network
    environment:
      DB_ADAPTER: postgres
      DB_HOST: konga-database
      DB_PORT: 5432
      DB_USER: konga
      DB_PASSWORD: kongapass
      DB_DATABASE: konga
      NODE_ENV: production
      KONGA_HOOK_TIMEOUT: 120000
      DB_PG_SCHEMA: public
      TOKEN_SECRET: change-this-secret-token
    ports:
      - "1337:1337"
    depends_on:
      konga-database:
        condition: service_healthy
      konga-prepare:
        condition: service_completed_successfully
      kong:
        condition: service_healthy

# ============================================
# BANKING API
# ============================================
  banking-api:
    image: safernandez666/banking-api
    container_name: banking-api
    restart: always
    networks:
      - poc-network
    ports:
      - "3000:3000"
    volumes:
      - banking-data:/app

# ============================================
# LOGSPOUT - LOG FORWARDER
# ============================================
  logspout:
    image: gliderlabs/logspout:latest
    container_name: logspout
    restart: always
    networks:
      - poc-network
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: syslog://wazuh.manager:514
    environment:
      - SYSLOG_FORMAT=rfc3164
      - LOGSPOUT=ignore
      - FILTER_NAME=kong|banking-api  # ← AGREGAR: Solo Kong y Banking API
    depends_on:
      - wazuh.manager
# ============================================
# N8N
# ============================================
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=n8n_password
      - N8N_HOST=0.0.0.0
      - N8N_PORT=5678
      - N8N_PROTOCOL=http
      - WEBHOOK_URL=http://n8n:5678/
      - GENERIC_TIMEZONE=America/Argentina/Buenos_Aires
    volumes:
      - n8n_data:/home/node/.n8n
    networks:
      - poc-network
# ============================================
# OLLAMA
# ============================================
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11435:11434" # Expose Ollama's API port
    volumes:
      - ollama_data:/root/.ollama # Persistent storage for models and data
    restart: unless-stopped
    networks:
      - poc-network
# ============================================
# NETWORKS
# ============================================
networks:
  poc-network:
    driver: bridge

# ============================================
# VOLUMES
# ============================================
volumes:
  wazuh_api_configuration:
  wazuh_etc: 
  wazuh_logs:
  wazuh_queue:
  wazuh_var_multigroups:
  wazuh_integrations:
  wazuh_active_response:
  wazuh_agentless:
  wazuh_wodles:
  filebeat_etc:
  filebeat_var:
  wazuh-indexer-data:
  wazuh-dashboard-config:
  wazuh-dashboard-custom:
  kong-database-data:
  konga-database-data:
  banking-data:
  n8n_data:
  ollama_data:

Importante edistar ./config/wazuh_cluster/wazuh_manager.conf, para que lo tome Wazuh Manager como su ossec.conf. Le agregamos esto:

  <!-- ============================================ -->
  <!-- Configuración de receptor remoto (Syslog) -->
  <!-- ============================================ -->
  <remote>
    <connection>syslog</connection>
    <port>514</port>
    <protocol>udp</protocol>
    <allowed-ips>any</allowed-ips>
  </remote>

  <!-- ============================================ -->
  <!-- INTEGRACIÓN CON N8N - WEBHOOKS PARA KONG -->
  <!-- ============================================ -->

  <!-- Webhook específico para ATAQUES (nivel 8+) -->
  <integration>
    <name>custom-n8n</name>
    <level>8</level>
    <group>kong,attack</group>
    <alert_format>json</alert_format>
  </integration>

También vamos agregar la integración custom-n8n en ./config/wazuh_cluster/.

#!/bin/bash
# Wazuh to n8n Integration

N8N_WEBHOOK_URL="http://n8n:5678/webhook/wazuh-kong-alerts"
LOG_FILE="/var/ossec/logs/integrations.log"

# Wazuh pasa el archivo de alerta como primer argumento
ALERT_FILE="$1"

# Timestamp
TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")

# Log
echo "[${TIMESTAMP}] Processing alert from file: ${ALERT_FILE}" >> ${LOG_FILE}

# Leer el contenido del archivo
if [ -f "${ALERT_FILE}" ]; then
    ALERT_JSON=$(cat "${ALERT_FILE}")

    # Enviar a n8n
    HTTP_CODE=$(curl -X POST "${N8N_WEBHOOK_URL}" \
      -H "Content-Type: application/json" \
      -d "${ALERT_JSON}" \
      -w "%{http_code}" \
      -s \
      -o /dev/null \
      --connect-timeout 10 \
      --max-time 30)

    if [ "${HTTP_CODE}" == "200" ] || [ "${HTTP_CODE}" == "201" ]; then
        echo "[${TIMESTAMP}] SUCCESS - HTTP ${HTTP_CODE}" >> ${LOG_FILE}
        exit 0
    else
        echo "[${TIMESTAMP}] FAILED - HTTP ${HTTP_CODE}" >> ${LOG_FILE}
        exit 1
    fi
else
    echo "[${TIMESTAMP}] ERROR - Alert file not found: ${ALERT_FILE}" >> ${LOG_FILE}
    exit 1
fi

Es muy importante que a custom-n8n le hagan un chmod 555, para que pueda ser ejecutado por cualquiera. Esto en local, antes de levantar el contenedor.

Agregamos el docoder y las regla, también en /config/wazuh_cluster. El decoder se llamara 0374-kong-decoder.xml y las regla kong-rules.xml.

<!--
  -  Kong API Manager custom decoder
  -  Created for extracting srcip from Kong logs
  -  Author: Santiago Fernandez
  -  Date: October 2025
  -
  -  This decoder extracts:
  -    - srcip: Source IP address
  -    - protocol: HTTP method (GET, POST, etc.)
  -    - url: Requested URL
  -    - id: HTTP status code
-->

<decoder name="kong-decoder">
    <prematch>^\S+ \S+ kong[\d+]:</prematch>
    <regex>^\S+ \S+ kong[\d+]: (\S+) \S+ \S+ [\S+ \S+] "(\w+) (\S+) HTTP\S+" (\d+) \d+ \S+ \S+</regex>
    <order>srcip, protocol, url, id</order>
</decoder>

<!--
  -  Kong API Gateway Rules
  -  Author: Santiago Fernandez
  -  Date: October 2025
  -  
  -  Rule ID Range: 100100 - 100199
-->

<group name="kong,">

  <!-- ============================================ -->
  <!-- REGLA BASE - Cualquier tráfico de Kong -->
  <!-- ============================================ -->
  <rule id="100100" level="3">
    <decoded_as>kong-decoder</decoded_as>
    <description>Kong: API Gateway traffic detected</description>
    <group>kong,access</group>
  </rule>

  <!-- ============================================ -->
  <!-- REGLAS PARA BANKING API -->
  <!-- ============================================ -->

  <!-- Accesos exitosos (2xx) a banking -->
  <rule id="100101" level="5">
    <if_sid>100100</if_sid>
    <url>/banking/</url>
    <id>^2\d\d$</id>
    <description>Kong: Successful access to banking API - $(protocol) $(url) - Status: $(id) from $(srcip)</description>
    <group>kong,banking,success</group>
  </rule>

  <!-- Errores del cliente (4xx) en banking -->
  <rule id="100102" level="7">
    <if_sid>100100</if_sid>
    <url>/banking/</url>
    <id>^4\d\d$</id>
    <description>Kong: Client error on banking API - $(protocol) $(url) - Status: $(id) from $(srcip)</description>
    <group>kong,banking,error,client_error</group>
  </rule>

  <!-- Errores del servidor (5xx) en banking -->
  <rule id="100103" level="10">
    <if_sid>100100</if_sid>
    <url>/banking/</url>
    <id>^5\d\d$</id>
    <description>Kong: Server error on banking API - $(protocol) $(url) - Status: $(id)</description>
    <group>kong,banking,critical,server_error</group>
  </rule>

  <!-- ============================================ -->
  <!-- REGLAS DE CORRELACIÓN - Detección de ataques -->
  <!-- ============================================ -->

  <!-- Múltiples errores 4xx desde la misma IP (posible escaneo) -->
  <rule id="100104" level="8" frequency="5" timeframe="60">
    <if_matched_sid>100102</if_matched_sid>
    <same_source_ip />
    <description>Kong: Multiple failed requests ($(id)) from $(srcip) to banking API - Possible scanning or brute force attempt</description>
    <group>kong,banking,attack,multiple_errors,scanning</group>
  </rule>

  <!-- Múltiples errores 5xx (problema en el servidor) -->
  <rule id="100105" level="9" frequency="3" timeframe="120">
    <if_matched_sid>100103</if_matched_sid>
    <description>Kong: Multiple server errors on banking API - Service may be down or experiencing issues</description>
    <group>kong,banking,critical,service_degradation</group>
  </rule>

  <!-- ============================================ -->
  <!-- ENDPOINTS SENSIBLES -->
  <!-- ============================================ -->

  <!-- Acceso a endpoints de cuentas -->
  <rule id="100106" level="6">
    <if_sid>100101</if_sid>
    <url>/banking/cuentas</url>
    <description>Kong: Access to accounts endpoint - $(protocol) $(url) from $(srcip)</description>
    <group>kong,banking,sensitive,accounts</group>
  </rule>

  <!-- Acceso a endpoints de transacciones -->
  <rule id="100107" level="6">
    <if_sid>100101</if_sid>
    <url>/banking/transacciones</url>
    <description>Kong: Access to transactions endpoint - $(protocol) $(url) from $(srcip)</description>
    <group>kong,banking,sensitive,transactions</group>
  </rule>

  <!-- Acceso a endpoints de transferencias -->
  <rule id="100108" level="7">
    <if_sid>100101</if_sid>
    <url>/banking/transferencias</url>
    <description>Kong: Access to money transfer endpoint - $(protocol) $(url) from $(srcip)</description>
    <group>kong,banking,sensitive,transfers,high_risk</group>
  </rule>

  <!-- ============================================ -->
  <!-- MÉTODOS HTTP ESPECÍFICOS -->
  <!-- ============================================ -->

  <!-- Peticiones DELETE en banking (alta sensibilidad) -->
  <rule id="100110" level="8">
    <if_sid>100100</if_sid>
    <url>/banking/</url>
    <protocol>DELETE</protocol>
    <description>Kong: DELETE request on banking API - $(url) from $(srcip)</description>
    <group>kong,banking,modification,delete,high_risk</group>
  </rule>

  <!-- Peticiones PUT/PATCH en banking -->
  <rule id="100111" level="6">
    <if_sid>100100</if_sid>
    <url>/banking/</url>
    <protocol>PUT|PATCH</protocol>
    <description>Kong: Modification request on banking API - $(protocol) $(url) from $(srcip)</description>
    <group>kong,banking,modification</group>
  </rule>

  <!-- Peticiones POST en banking -->
  <rule id="100112" level="5">
    <if_sid>100100</if_sid>
    <url>/banking/</url>
    <protocol>POST</protocol>
    <id>^2\d\d$</id>
    <description>Kong: POST request on banking API - $(url) from $(srcip)</description>
    <group>kong,banking,creation</group>
  </rule>

  <!-- ============================================ -->
  <!-- CÓDIGOS DE ESTADO ESPECÍFICOS -->
  <!-- ============================================ -->

  <!-- 401 - No autorizado -->
  <rule id="100120" level="7">
    <if_sid>100100</if_sid>
    <url>/banking/</url>
    <id>^401$</id>
    <description>Kong: Unauthorized access attempt to banking API - $(protocol) $(url) from $(srcip)</description>
    <group>kong,banking,authentication,unauthorized</group>
  </rule>

  <!-- Múltiples 401 desde la misma IP -->
  <rule id="100121" level="9" frequency="3" timeframe="60">
    <if_matched_sid>100120</if_matched_sid>
    <same_source_ip />
    <description>Kong: Multiple unauthorized access attempts from $(srcip) - Possible credential stuffing attack</description>
    <group>kong,banking,attack,authentication,credential_stuffing</group>
  </rule>

  <!-- 403 - Prohibido -->
  <rule id="100122" level="7">
    <if_sid>100100</if_sid>
    <url>/banking/</url>
    <id>^403$</id>
    <description>Kong: Forbidden access attempt to banking API - $(protocol) $(url) from $(srcip)</description>
    <group>kong,banking,authorization,forbidden</group>
  </rule>

  <!-- 404 - No encontrado -->
  <rule id="100123" level="5">
    <if_sid>100100</if_sid>
    <url>/banking/</url>
    <id>^404$</id>
    <description>Kong: Resource not found on banking API - $(protocol) $(url) from $(srcip)</description>
    <group>kong,banking,not_found</group>
  </rule>

  <!-- Múltiples 404 desde la misma IP (posible escaneo de endpoints) -->
  <rule id="100124" level="8" frequency="10" timeframe="120">
    <if_matched_sid>100123</if_matched_sid>
    <same_source_ip />
    <description>Kong: Multiple 404 errors from $(srcip) - Possible endpoint enumeration attack</description>
    <group>kong,banking,attack,enumeration</group>
  </rule>

  <!-- 429 - Too Many Requests (Rate Limiting) -->
  <rule id="100125" level="6">
    <if_sid>100100</if_sid>
    <url>/banking/</url>
    <id>^429$</id>
    <description>Kong: Rate limit exceeded on banking API from $(srcip)</description>
    <group>kong,banking,rate_limit,abuse</group>
  </rule>

  <!-- ============================================ -->
  <!-- TRÁFICO NO BANKING (Otros endpoints) -->
  <!-- ============================================ -->

  <!-- Accesos exitosos a otros endpoints -->
  <rule id="100130" level="3">
    <if_sid>100100</if_sid>
    <id>^2\d\d$</id>
    <description>Kong: Successful request - $(protocol) $(url) from $(srcip)</description>
    <group>kong,success</group>
  </rule>

  <!-- Errores en otros endpoints -->
  <rule id="100131" level="5">
    <if_sid>100100</if_sid>
    <id>^4\d\d$</id>
    <description>Kong: Client error - $(protocol) $(url) - Status: $(id) from $(srcip)</description>
    <group>kong,error</group>
  </rule>

</group>

Listo! Ya estamos para ejecutar.

docker-compose up -d

Vamos a pegarle una mirada a los contenedores.

Para que tengamos una idea de los puertos y contenedores, te los paso en limpio aquí.

Banking API

Es una API generada para este Prueba de Concepto con información ficticia. Pueden encontrar el código en el repositorio, pero a grandes rasgos nos data esta información:

• Gestiona clientes (nombre, email, teléfono, fecha de registro).

• Gestiona cuentas vinculadas a clientes (número, tipo, saldo, moneda).

• Gestiona tarjetas de crédito asociadas a cuentas (número, límite, saldo usado, vencimiento). En las respuestas públicas el CVV se oculta.

• Registra transacciones (depósitos, retiros, transferencias, compras).

• Provee un resumen por cliente que agrega cuentas y tarjetas (totales de saldos y crédito disponible).

• Incluye endpoints de salud y la documentación.

Kong

Voy a proporcionarles los comandos para que nuestro API Manager consuma la Banking API. Vamos paso a paso: primero, debemos crear un "Service" en Kong que represente tu API backend.

curl -i -X POST http://localhost:8001/services/ \
  --data "name=banking-api" \
  --data "url=http://banking-api:3000"

Creamos un "Route" que define cómo los clientes accederán a tu servicio. Vincula la ruta al servicio creado anteriormente.

curl -i -X POST http://localhost:8001/services/banking-api/routes \
  --data "name=banking-route" \
  --data "paths[]=/banking" \
  --data "strip_path=true"

Habilitamos CORS (Cross-Origin Resource Sharing) para permitir peticiones desde navegadores. Aca lo voy a crear de una forma permisiva.

curl -i -X POST http://localhost:8001/services/banking-api/plugins \
  --data "name=cors" \
  --data "config.origins=*" \
  --data "config.methods[]=GET" \
  --data "config.methods[]=HEAD" \
  --data "config.methods[]=PUT" \
  --data "config.methods[]=PATCH" \
  --data "config.methods[]=POST" \
  --data "config.methods[]=DELETE" \
  --data "config.methods[]=OPTIONS" \
  --data "config.headers[]=*" \
  --data "config.exposed_headers[]=*" \
  --data "config.credentials=true" \
  --data "config.max_age=3600"

Como saben, Kong es un API Manager. Podríamos habilitar varios plugins, pero para la PoC no son necesarios. Podrías habilitar Rate Limiting, Request Size Limiting, Correlation ID o Request Transformer. Vamos a probarlo.

# Vamos a ver los clientes
curl http://localhost:8000/banking/clientes | jq
# Cliente con ID 1
curl http://localhost:8000/banking/clientes/1 | jq

Konga

Todo lo que hicimos con curl, podemos hacerlo a través de la interfaz gráfica. Primero, vamos a crear nuestra cuenta en Konga y luego agregar la conexión para gestionar Kong.

Ahí se ve todo lo creado, anteriormente. Por ejemplo el servicio.

o la ruta.

Wazuh

Si todo salió bien, ingresamos a Wazuh para ver nuestras consultas. Para ver las reglas de Kong, aplique un filtro decoder.name: kong-decoder

N8N

Ya levantado el contenedor ingresamos a http://localhost:5678. Ahí armaremos dos workflows, uno para el análisis y otro para que los administradores puedan liberar la ip bloqueada.

Una vez que suframos el ataque, habrá lógica para decidir si debemos bloquear o no. Esto es una prueba, pero imagino consultas de diferentes API, Slack o servicios internos. Una vez que se ejecute el Workflow Block IP, deberíamos recibir un correo como este:

Al final del correo, podemos invocar el Workflow Release IP para liberar la dirección del atacante.

Simulacion de Ataque

Les dejo un script para simular un ataque rápidamente.

#!/bin/bash
# quick-test.sh - Prueba rpida

echo " Generando alertas de prueba..."

# Trfico normal
curl -s http://localhost:8000/banking/cuentas

# Mltiples 404 (activar regla de correlacin)
for i in {1..12}; do
    curl -s http://localhost:8000/banking/fake-endpoint-$i
    sleep 0.5
done

# Mltiples 401 (credential stuffing)
for i in {1..5}; do
    curl -s http://localhost:8000/banking/cuentas -H "Authorization: Bearer fake_$i"
    sleep 1
done

# DELETE peligroso
curl -s -X DELETE http://localhost:8000/banking/cuentas/123

echo " Alertas generadas. Revisa n8n y Wazuh!"

Espero que les sirva y puedan usarlo en sus empresas, si necesitan una mano me avisan.

Saludos, Santi.

Bonus Track

Dejo los Worflows de N8N para analizar con Ollama. Código.

Comandos Útiles

# 1. Reiniciar Wazuh Manager
docker-compose restart single-node-wazuh.manager-1

# 2. Verificar que está escuchando en el puerto 514
docker exec single-node-wazuh.manager-1 netstat -tlnp | grep 514

# 3. Revisar ossec.conf
docker exec single-node-wazuh.manager-1 cat /var/ossec/etc/ossec.conf

# 4. Ver logs de Integraciones
docker exec single-node-wazuh.manager-1 tail -f /var/ossec/logs/integrations.log

# 5. Ver logs de Alarmas de Kong
docker exec -it single-node-wazuh.manager-1 tail -f /var/ossec/logs/alerts/alerts.log | grep -A 10 "kong"

# 6. Ver logs de Wazuh Manager
docker logs -f single-node-wazuh.indexer-1

Referencias

https://ipv6.rs/tutorial/Ubuntu_Server_Latest/Kong/

https://documentation.wazuh.com/current/deployment-options/docker/wazuh-container.html

Hace un tiempo escribí sobre Wazuh y recibí muchas consultas. Voy a avanzar un poco más y vamos a monitorear un equipo Fortigate para tener alarmas en tiempo real y actuar en consecuencia. La verdad es que este SIEM nos ofrece una gran variedad de opciones para configurar. En este caso en particular, vamos a crear dos tipos de reglas personalizadas, una para las IPs y otra para las conexiones VPN. Queremos que cuando se ejecute una regla, nos envíe un correo. Claro que puedes modificarlo para que envíe un mensaje a Slack o Teams. Y por qué no llevarlo a un N8N, algo en lo que estoy trabajando.

La idea es tener esta clase de alarmas. Dejo estos ejemplos, uno de IPs con un ataque de DoS y uno de VPN con un usuario fuera de horario laboral.

Prerequisitos

Necesitamos tener instalado un Wazuh Server. En mi caso, uso la versión 4.12. Debemos modificar el archivo ossec.conf para que reciba eventos UDP en el puerto 514. De esta manera, podemos dirigir nuestros dispositivos Fortinet a nuestro SIEM para enviar los Syslogs.

# La Ruta es /var/ossec/etc/ossec.conf
  <!-- Logs de VPN -->
  <remote>
    <connection>syslog</connection>
    <port>514</port>
    <protocol>udp</protocol>
    <allowed-ips>any</allowed-ips>
  </remote>

Luego, como en cada cambio en el Wazuh Manager.

sudo systemctl restart wazuh-manager

Ya nos deberian llegar los Logs de Fortigate, si configuraste bien el equipo. Aca ten dejo un instructivo, para ello.

Configurar Decoders

Un decoder es el componente encargado de interpretar y extraer información de los logs en bruto que recibe Wazuh. Piensa en él como un traductor que convierte texto plano en datos estructurados que Wazuh puede analizar y sobre los cuales puede crear reglas de detección. Para que tengas una idea te dejo la lista de los que son mantenido por la comunidad.

En nuestro caso vamos a generar una lista propia, creandola aqui /var/ossec/etc/decoders/custom-fortigate-ips.xml

<!--
  - Fortigate IPS Decoders Santiago Fernandez
  -->

<decoder name="fortigate-ips">
  <prematch>type=ips</prematch>
</decoder>

<decoder name="fortigate-ips-details">
  <parent>fortigate-ips</parent>
  <regex>severity=(\w+)</regex>
  <order>severity</order>
</decoder>

<decoder name="fortigate-ips-details">
  <parent>fortigate-ips</parent>
  <regex>srcip=(\S+)</regex>
  <order>srcip</order>
</decoder>

<decoder name="fortigate-ips-details">
  <parent>fortigate-ips</parent>
  <regex>dstip=(\S+)</regex>
  <order>dstip</order>
</decoder>

<decoder name="fortigate-ips-details">
  <parent>fortigate-ips</parent>
  <regex>dstport=(\d+)</regex>
  <order>dstport</order>
</decoder>

<decoder name="fortigate-ips-details">
  <parent>fortigate-ips</parent>
  <regex>attack="([^"]+)"</regex>
  <order>attack</order>
</decoder>

<decoder name="fortigate-ips-details">
  <parent>fortigate-ips</parent>
  <regex>action=(\w+)</regex>
  <order>action</order>
</decoder>

Configurando las Reglas

Una regla es el componente que analiza los datos extraídos por los decoders y determina si un evento es relevante, cuán crítico es, y qué acciones tomar. Las reglas transforman datos en alertas de seguridad. Una explicacion burda seria la siguiente: Se envia el log para que el decoder extraiga los campos, la regla evalua y clasifican para saber si debe o no generar la alerta.

Vamos a crear dos reglas, custom, para fortigate. Ambas deben estar en este path /var/ossec/etc/rules.

<!-- ----------------------- -->
<!-- custom-fortigate-ips.xml -->
<!-- ----------------------- -->
<group name="fortigate,ids,ips,utm,">

  <!-- Base rule for Fortigate IPS -->

  <rule id="196200" level="3">
    <if_sid>81629</if_sid>
    <description>Fortigate IPS event detected</description>
    <group>fortigate,fortigate_ips</group>
  </rule>

 <!-- ========== CLASIFICACIÓN POR SEVERIDAD ========== -->

  <!-- IPS - Critical Severity -->
  <rule id="196201" level="13">
    <if_sid>196200</if_sid>
    <field name="severity">critical</field>
    <description>FGT IPS: CRITICAL attack detected - $(attack) from $(srcip)</description>
    <options>no_full_log</options>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>attack,critical,fortigate_ips</group>
  </rule>

  <!-- IPS - High Severity -->
  <rule id="196202" level="10">
    <if_sid>196200</if_sid>
    <field name="severity">high</field>
    <description>FGT IPS: HIGH severity attack - $(attack) from $(srcip)</description>
    <options>no_full_log</options>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>attack,high,fortigate_ips</group>
  </rule>

  <!-- IPS - Medium Severity -->
  <rule id="196203" level="7">
    <if_sid>196200</if_sid>
    <field name="severity">medium</field>
    <description>FGT IPS: MEDIUM severity attack - $(attack) from $(srcip)</description>
    <options>no_full_log</options>
    <group>attack,medium,fortigate_ips</group>
  </rule>

  <!-- IPS - Low Severity pero repetido -->
  <rule id="196204" level="5" frequency="10" timeframe="300">
    <if_matched_sid>196200</if_matched_sid>
    <field name="severity">low</field>
    <same_source_ip />
    <description>FGT IPS: Multiple LOW severity attacks from same IP (10+ in 5min)</description>
    <group>attack,low,fortigate_ips_repeated</group>
  </rule>

  <!-- ========== CLASIFICACIÓN POR ACCIÓN ========== -->

  <!-- Attack Blocked/Dropped (acción exitosa del IPS) -->
  <rule id="196205" level="5">
    <if_sid>196200</if_sid>
    <match>action="dropped"</match>
    <description>FGT IPS: Attack BLOCKED from $(srcip) - $(attack)</description>
    <options>no_full_log</options>
    <group>attack,blocked,fortigate_ips</group>
  </rule>

  <!-- Attack Detected but NOT Blocked (PELIGROSO) -->
  <rule id="196206" level="9">
    <if_sid>196200</if_sid>
    <match>action="detected"</match>
    <description>FGT IPS: Attack DETECTED but NOT blocked - $(attack) from $(srcip)</description>
    <options>no_full_log</options>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>attack,detected,fortigate_ips_unblocked</group>
  </rule>

  <!-- Critical Attack NOT Blocked (MUY PELIGROSO) -->
  <rule id="196207" level="14">
    <if_sid>196200</if_sid>
    <field name="severity">critical</field>
    <match>action="detected"</match>
    <description>FGT IPS: CRITICAL attack NOT BLOCKED - $(attack) from $(srcip) to $(dstip)</description>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>attack,critical,fortigate_ips_unblocked,emergency</group>
  </rule>

  <!-- ========== ATAQUES WEB ESPECÍFICOS ========== -->

  <!-- SQL Injection -->
  <rule id="196208" level="11">
    <if_sid>196200</if_sid>
    <match>SQL|sql_injection|SQLi</match>
    <description>FGT IPS: SQL Injection attempt from $(srcip) to $(dstip):$(dstport)</description>
    <mitre>
      <id>T1190</id>
      <id>T1505.003</id>
    </mitre>
    <group>attack,sql_injection,web,fortigate_ips</group>
  </rule>

  <!-- XSS (Cross-Site Scripting) -->
  <rule id="196209" level="10">
    <if_sid>196200</if_sid>
    <match>XSS|Cross.Site|cross-site</match>
    <description>FGT IPS: XSS attack attempt from $(srcip) to $(dstip)</description>
    <mitre>
      <id>T1189</id>
    </mitre>
    <group>attack,xss,web,fortigate_ips</group>
  </rule>

  <!-- Command Injection -->
  <rule id="196210" level="11">
    <if_sid>196200</if_sid>
    <match>command.injection|Command.Execution</match>
    <description>FGT IPS: Command Injection attempt from $(srcip)</description>
    <mitre>
      <id>T1059</id>
    </mitre>
    <group>attack,command_injection,fortigate_ips</group>
  </rule>

  <!-- Path Traversal / Directory Traversal -->
  <rule id="196211" level="9">
    <if_sid>196200</if_sid>
    <match>Directory.Traversal|Path.Traversal</match>
    <description>FGT IPS: Path Traversal attempt from $(srcip)</description>
    <mitre>
      <id>T1083</id>
    </mitre>
    <group>attack,path_traversal,web,fortigate_ips</group>
  </rule>

  <!-- ========== EXPLOITS Y MALWARE ========== -->

  <!-- Buffer Overflow -->
  <rule id="196212" level="12">
    <if_sid>196200</if_sid>
    <match>Buffer.Overflow|buffer-overflow</match>
    <description>FGT IPS: Buffer Overflow exploit attempt from $(srcip)</description>
    <mitre>
      <id>T1203</id>
    </mitre>
    <group>attack,buffer_overflow,exploit,fortigate_ips</group>
  </rule>

  <!-- Remote Code Execution (RCE) -->
  <rule id="196213" level="13">
    <if_sid>196200</if_sid>
    <match>Remote.Code|RCE|code.execution</match>
    <description>FGT IPS: Remote Code Execution attempt from $(srcip)</description>
    <mitre>
      <id>T1203</id>
      <id>T1059</id>
    </mitre>
    <group>attack,rce,exploit,fortigate_ips,critical</group>
  </rule>

  <!-- ========== RECONOCIMIENTO Y ESCANEOS ========== -->

  <!-- Nmap Scan -->
  <rule id="196214" level="7">
    <if_sid>196200</if_sid>
    <match>Nmap|nmap|Network.Mapper</match>
    <description>FGT IPS: Nmap scan detected from $(srcip)</description>
    <mitre>
      <id>T1046</id>
    </mitre>
    <group>attack,reconnaissance,scan,fortigate_ips</group>
  </rule>

  <!-- Port Scan (múltiples intentos) -->
  <rule id="196215" level="7" frequency="5" timeframe="60">
    <if_matched_sid>196200</if_matched_sid>
    <same_source_ip />
    <match>Port.Scan|port.scanning</match>
    <description>FGT IPS: Port scanning activity from $(srcip) (5+ in 1min)</description>
    <mitre>
      <id>T1046</id>
    </mitre>
    <group>attack,reconnaissance,port_scan,fortigate_ips</group>
  </rule>

  <!-- Vulnerability Scanner -->
  <rule id="196216" level="8">
    <if_sid>196200</if_sid>
    <match>Vulnerability.Scanner|Nikto|OpenVAS|Nessus</match>
    <description>FGT IPS: Vulnerability scanner detected from $(srcip)</description>
    <mitre>
      <id>T1595</id>
    </mitre>
    <group>attack,reconnaissance,vuln_scan,fortigate_ips</group>
  </rule>

  <!-- ========== ATAQUES DoS / DDoS ========== -->

  <!-- DoS Attack -->
  <rule id="196217" level="11">
    <if_sid>196200</if_sid>
    <match>DoS|Denial.of.Service</match>
    <description>FGT IPS: DoS attack detected from $(srcip) to $(dstip)</description>
    <mitre>
      <id>T1498</id>
    </mitre>
    <group>attack,dos,fortigate_ips</group>
  </rule>

  <!-- DDoS Attack -->
  <rule id="196218" level="13">
    <if_sid>196200</if_sid>
    <match>DDoS|Distributed.Denial</match>
    <description>FGT IPS: DDoS attack detected targeting $(dstip)</description>
    <mitre>
      <id>T1498</id>
    </mitre>
    <group>attack,ddos,fortigate_ips,critical</group>
  </rule>

  <!-- SYN Flood -->
  <rule id="196219" level="10">
    <if_sid>196200</if_sid>
    <match>SYN.Flood|syn-flood</match>
    <description>FGT IPS: SYN Flood attack from $(srcip)</description>
    <mitre>
      <id>T1498.001</id>
    </mitre>
    <group>attack,dos,syn_flood,fortigate_ips</group>
  </rule>

  <!-- ========== MALWARE Y AMENAZAS AVANZADAS ========== -->

  <!-- Malware Detection -->
  <rule id="196220" level="12">
    <if_sid>196200</if_sid>
    <match>Malware|malicious|trojan|virus|worm</match>
    <description>FGT IPS: Malware detected from $(srcip) - $(attack)</description>
    <mitre>
      <id>T1204</id>
    </mitre>
    <group>attack,malware,fortigate_ips,critical</group>
  </rule>

  <!-- Exploit Attempt -->
  <rule id="196221" level="11">
    <if_sid>196200</if_sid>
    <match>Exploit|exploit-kit|CVE-</match>
    <description>FGT IPS: Exploit attempt detected - $(attack) from $(srcip)</description>
    <mitre>
      <id>T1203</id>
    </mitre>
    <group>attack,exploit,fortigate_ips</group>
  </rule>

  <!-- Ransomware Activity -->
  <rule id="196222" level="14">
    <if_sid>196200</if_sid>
    <match>Ransomware|ransom|crypto-locker</match>
    <description>FGT IPS: Ransomware activity detected from $(srcip)</description>
    <mitre>
      <id>T1486</id>
    </mitre>
    <group>attack,ransomware,malware,fortigate_ips,emergency</group>
  </rule>

  <!-- ========== ATAQUES A SERVICIOS ESPECÍFICOS ========== -->

  <!-- Apache/Nginx/Web Server Exploit -->
  <rule id="196223" level="10">
    <if_sid>196200</if_sid>
    <match>Apache|Nginx|HTTP.Server</match>
    <description>FGT IPS: Web server exploit attempt - $(attack)</description>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>attack,web,apache,fortigate_ips</group>
  </rule>

  <!-- WordPress Attack -->
  <rule id="196224" level="9">
    <if_sid>196200</if_sid>
    <match>WordPress|wp-admin|wp-login</match>
    <description>FGT IPS: WordPress attack from $(srcip)</description>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>attack,web,wordpress,fortigate_ips</group>
  </rule>

  <!-- PHP Exploit -->
  <rule id="196225" level="10">
    <if_sid>196200</if_sid>
    <match>PHP|php-cgi</match>
    <description>FGT IPS: PHP exploit attempt from $(srcip)</description>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>attack,web,php,fortigate_ips</group>
  </rule>

  <!-- ========== CORRELACIÓN DE ATAQUES ========== -->

  <!-- Múltiples ataques desde misma IP (5+ en 2min) -->
  <rule id="196226" level="12" frequency="5" timeframe="120">
    <if_matched_sid>196200</if_matched_sid>
    <same_source_ip />
    <description>FGT IPS: Multiple attacks from same IP $(srcip) (5+ in 2min)</description>
    <mitre>
      <id>T1595</id>
    </mitre>
    <group>attack,correlated,fortigate_ips_repeated</group>
  </rule>

  <!-- Ataque a múltiples destinos desde una IP (spray attack) -->
  <rule id="196227" level="11" frequency="10" timeframe="300">
    <if_matched_sid>196200</if_matched_sid>
    <same_source_ip />
    <not_same_field>data.dstip</not_same_field>
    <description>FGT IPS: Single IP attacking multiple targets (10+ targets in 5min)</description>
    <mitre>
      <id>T1595</id>
    </mitre>
    <group>attack,correlated,fortigate_ips_spray</group>
  </rule>

  <!-- Critical attacks en ráfaga (burst) -->
  <rule id="196228" level="14" frequency="3" timeframe="60">
    <if_matched_sid>196201</if_matched_sid>
    <same_source_ip />
    <description>FGT IPS: Multiple CRITICAL attacks in short time from $(srcip)</description>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>attack,critical,fortigate_ips_burst,emergency</group>
  </rule>

  <!-- ========== FILTROS GEOGRÁFICOS ========== -->

  <!-- Ataque desde país restringido -->
  <rule id="196229" level="10">
    <if_sid>196200</if_sid>
    <match>srccountry="China"|srccountry="Russia"|srccountry="Iran"|srccountry="North Korea"</match>
    <description>FGT IPS: Attack from restricted country - $(attack)</description>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>attack,geo_restricted,fortigate_ips</group>
  </rule>

  <!-- ========== ATAQUES A PUERTOS CRÍTICOS ========== -->

  <!-- Attack to RDP Port (3389) -->
  <rule id="196230" level="10">
    <if_sid>196200</if_sid>
    <match>dstport=3389</match>
    <description>FGT IPS: Attack targeting RDP port (3389) from $(srcip)</description>
    <mitre>
      <id>T1021.001</id>
    </mitre>
    <group>attack,rdp,fortigate_ips</group>
  </rule>

  <!-- Attack to SSH Port (22) -->
  <rule id="196231" level="9">
    <if_sid>196200</if_sid>
    <match>dstport=22</match>
    <description>FGT IPS: Attack targeting SSH port (22) from $(srcip)</description>
    <mitre>
      <id>T1021.004</id>
    </mitre>
    <group>attack,ssh,fortigate_ips</group>
  </rule>

</group>

Y el de VPN.

<group name="fortigate,custom,bruteforce,">

  <!-- ========== REGLAS BÁSICAS FUNCIONALES ========== -->

  <!-- Admin Brute Force -->
  <rule id="196100" level="12" frequency="6" timeframe="300" ignore="300">
    <if_matched_sid>81606</if_matched_sid>
    <same_source_ip />
    <description>FGT: ADMIN bruteforce from same IP (6+ attempts in 5min)</description>
    <mitre>
      <id>T1110.001</id>
    </mitre>
    <group>fortigate_admin_bruteforce,critical</group>
  </rule>

  <!-- VPN SSL Brute Force -->
  <rule id="196101" level="12" frequency="10" timeframe="180" ignore="300">
    <if_matched_sid>81614</if_matched_sid>
    <same_source_ip />
    <description>FGT: SSL VPN bruteforce from same IP (10+ attempts in 3min)</description>
    <mitre>
      <id>T1110.001</id>
      <id>T1133</id>
    </mitre>
    <group>fortigate_vpn_bruteforce,critical</group>
  </rule>

  <!-- ========== VPN FUERA DE HORARIO ========== -->

  <!-- Regla base: VPN fuera de horario (TODOS los usuarios, nivel bajo, sin email) -->
  <rule id="196102" level="5" ignore="60">
    <if_sid>81622</if_sid>
    <time>7:00 pm - 6:00 am</time>
    <weekday>monday,tuesday,wednesday,thursday,friday</weekday>
    <description>FGT: VPN connection outside business hours (19:00-06:00) - $(user)</description>
    <mitre>
      <id>T1078</id>
      <id>T1133</id>
    </mitre>
    <group>fortigate_vpn_after_hours</group>
  </rule>

  <!-- Regla específica: VPN fuera de horario de USUARIOS MONITOREADOS (nivel alto, CON email) -->
  <rule id="196104" level="8" ignore="60">
    <if_sid>196102</if_sid>
    <list field="user" lookup="match_key">etc/lists/vpn-monitored-users</list>
    <description>FGT VPN: Usuario monitoreado $(user) conectado fuera de horario laboral</description>
    <mitre>
      <id>T1078</id>
      <id>T1133</id>
    </mitre>
    <group>fortigate_vpn_suspicious,after_hours,monitored_user</group>
  </rule>

  <!-- ========== VPN FIN DE SEMANA ========== -->

  <!-- Regla base: VPN fin de semana (TODOS los usuarios, nivel bajo, sin email) -->
  <rule id="196103" level="5" ignore="60">
    <if_sid>81622</if_sid>
    <weekday>saturday,sunday</weekday>
    <description>FGT: VPN connection during weekend - $(user)</description>
    <mitre>
      <id>T1078</id>
      <id>T1133</id>
    </mitre>
    <group>fortigate_vpn_weekend</group>
  </rule>

  <!-- Regla específica: VPN fin de semana de USUARIOS MONITOREADOS (nivel alto, CON email) -->
  <rule id="196105" level="7" ignore="60">
    <if_sid>196103</if_sid>
    <list field="user" lookup="match_key">etc/lists/vpn-monitored-users</list>
    <description>FGT VPN: Usuario monitoreado $(user) conectado en fin de semana</description>
    <mitre>
      <id>T1078</id>
      <id>T1133</id>
    </mitre>
    <group>fortigate_vpn_weekend,monitored_user</group>
  </rule>

  <!-- Múltiples IPs diferentes para mismo usuario -->
  <rule id="196104" level="11" frequency="3" timeframe="3600" ignore="300">
    <if_matched_sid>81622</if_matched_sid>
    <same_user />
    <not_same_source_ip />
    <description>FGT: VPN user connecting from multiple IPs (possible account compromise)</description>
    <mitre>
      <id>T1078</id>
      <id>T1090</id>
    </mitre>
    <group>fortigate_vpn_multiple_ips,critical</group>
  </rule>

  <!-- VPN desde país restringido  -->
  <rule id="196112" level="11">
    <if_sid>81622</if_sid>
    <match>srccountry="China"|srccountry="Russia"|srccountry="Iran"|srccountry="North Korea"</match>
    <description>FGT: VPN connection from restricted country (BLOCKED)</description>
    <mitre>
      <id>T1133</id>
    </mitre>
    <group>fortigate_geo_blocked,critical</group>
  </rule>

  <!-- Usuario admin fuera de horario -->
  <rule id="196113" level="12">
    <if_sid>81605</if_sid>
    <user>^admin$</user>
    <time>6:00 pm - 8:00 am</time>
    <description>FGT: Admin account login outside business hours</description>
    <mitre>
      <id>T1078.003</id>
    </mitre>
    <group>fortigate_admin_after_hours,critical</group>
  </rule>

</group>

Perfecto, ya tenemos las listas. Como les dije antes, vamos a reinciar Wazuh Manager para saber si tenemos problemas de sintaxis.

sudo systemctl restart wazuh-manager

Tambien podes usar el siguiente comando.

sudo apt-get install libxml2-utils    
xmllint --noout /var/ossec/etc/ossec.conf

Integracion con Email

Para que nos lleguen esos bellos correos vamos a crear un script en Python que sera referenciado en el ossec.conf.

{
  "smtp_host": "HOST",
  "smtp_port": 587,
  "use_tls": true,
  "username": "wazuh",
  "password": "TUPASSWORD",
  "from": "Wazuh SIEM <wazuh@TUDOMINIO>",
  "to": [
    "alertas_wazuh@TUDOMINIO",
    "sfernandez@TUDOMINIO"
  ],
  "subject_prefix": "[Wazuh SIEM]",
  "insecure_skip_verify": true,
  "geoip_db": "/usr/share/GeoIP/dbip-city-lite.mmdb" # Geo
}

Hay que instalar la GeoLocalizacion si desean. Si no eliminarlo.

Le damos los permisos.

sudo chown root:wazuh /var/ossec/etc/email-config.json
sudo chmod 640 /var/ossec/etc/email-config.json

Ahora vamos a crear el Python que hara la magia en la ruta /var/ossec/integrations. Yo lo voy a llamar custom-email.

#!/usr/bin/env python3
"""
Wazuh Unified Email Notifier v4.0
- Maneja Active Directory (reglas 100080-100085 y 60107-60113)
- Maneja FortiGate VPN/Admin (reglas 196100-196113)
- Maneja FortiGate IPS (reglas 196200-196231)
- Template HTML unificado y profesional
- GeoIP integrado
- Logging mejorado
- Configuración centralizada
"""

import sys, json, smtplib, ssl, pathlib, html, logging, re, os
from datetime import datetime
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.header import Header
from typing import Dict, Any, Tuple, Optional

# GeoIP opcional
try:
    import geoip2.database
    HAS_GEOIP = True
except ImportError:
    HAS_GEOIP = False

class UnifiedEmailNotifier:
    def __init__(self, config_path: str):
        self.config = self._load_config(config_path)
        self._setup_logging()

        # Grupos privilegiados de AD
        self.privileged_groups = {
            "Domain Admins", "Enterprise Admins", "Administrators", "Schema Admins",
            "Account Operators", "Server Operators", "Backup Operators", "Print Operators",
            "DnsAdmins", "Domain Controllers", "Enterprise Key Admins", "Key Admins",
            "Cert Publishers", "Group Policy Creator Owners", "RAS and IAS Servers"
        }

        # Países de alto riesgo (ajustar según política organizacional)
        self.high_risk_countries = {
            'China', 'Russia', 'North Korea', 'Iran', 'Vietnam', 'Nigeria',
            'Romania', 'Ukraine', 'Belarus', 'Myanmar', 'Pakistan'
        }

    def _setup_logging(self):
        """Configurar logging con rotación"""
        log_file = self.config.get("log_file", "/var/ossec/logs/integrations.log")

        handlers = [logging.StreamHandler(sys.stderr)]
        if log_file and os.path.dirname(log_file):
            try:
                os.makedirs(os.path.dirname(log_file), exist_ok=True)
                file_handler = logging.FileHandler(log_file)
                file_handler.setFormatter(logging.Formatter(
                    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
                ))
                handlers.append(file_handler)
            except Exception:
                pass

        logging.basicConfig(
            level=getattr(logging, self.config.get("log_level", "INFO").upper()),
            format="%(asctime)s - %(levelname)s - %(message)s",
            handlers=handlers
        )
        self.logger = logging.getLogger("unified-email-notifier")

    def _load_config(self, config_path: str) -> Dict[str, Any]:
        """Cargar configuración con validación"""
        try:
            cfg = json.loads(pathlib.Path(config_path).read_text(encoding="utf-8"))

            required_fields = ["smtp_host", "to"]
            for field in required_fields:
                if field not in cfg:
                    raise ValueError(f"Campo requerido '{field}' faltante en configuración")

            cfg.setdefault("smtp_port", 587)
            cfg.setdefault("use_tls", True)
            cfg.setdefault("from", "wazuh@localhost")
            cfg.setdefault("subject_prefix", "[Wazuh SIEM]")
            cfg.setdefault("timeout", 30)
            cfg.setdefault("log_level", "INFO")

            return cfg
        except Exception as e:
            raise RuntimeError(f"Error cargando configuración {config_path}: {e}")

    def _load_alert(self, file_path: str) -> Dict[str, Any]:
        """Cargar alerta de Wazuh con manejo robusto de errores"""
        try:
            if not pathlib.Path(file_path).exists():
                raise FileNotFoundError(f"Archivo de alerta no encontrado: {file_path}")

            raw = pathlib.Path(file_path).read_text(encoding="utf-8", errors="ignore").strip()
            if not raw:
                raise ValueError("Archivo de alerta vacío")

            candidates = []
            if raw.startswith("{"):
                candidates.append(raw)
            else:
                for line in raw.splitlines():
                    line = line.strip()
                    if line.startswith("{") and line.endswith("}"):
                        candidates.append(line)

            for candidate in reversed(candidates):
                try:
                    return json.loads(candidate)
                except json.JSONDecodeError:
                    continue

            raise ValueError("No se encontró JSON válido en el archivo de alerta")

        except Exception as e:
            raise RuntimeError(f"Error cargando alerta {file_path}: {e}")

    def _get_field(self, data: Dict[str, Any], *paths: str, default: str = "-") -> str:
        """Buscar campo en múltiples rutas con tolerancia a casos"""
        for path in paths:
            current = data
            found = True

            for key in path.split("."):
                if not isinstance(current, dict):
                    found = False
                    break

                possible_keys = [key, key.lower(), key.capitalize(), key.upper()]
                matched_key = None

                for possible_key in possible_keys:
                    if possible_key in current:
                        matched_key = possible_key
                        break

                if matched_key is None:
                    found = False
                    break

                current = current[matched_key]

            if found and current is not None:
                return str(current).strip()

        return default

    def _format_timestamp(self, ts: str) -> str:
        """Formatear timestamp de manera consistente"""
        if not ts or ts == "-":
            return "-"

        try:
            if "T" in ts:
                if ts.endswith("Z"):
                    dt = datetime.fromisoformat(ts.replace("Z", "+00:00"))
                else:
                    dt = datetime.fromisoformat(ts)
                return dt.strftime("%d/%m/%Y %H:%M:%S")
            else:
                for fmt in ["%Y-%m-%d %H:%M:%S", "%d/%m/%Y %H:%M:%S"]:
                    try:
                        dt = datetime.strptime(ts, fmt)
                        return dt.strftime("%d/%m/%Y %H:%M:%S")
                    except ValueError:
                        continue
        except Exception:
            pass

        return ts

    def _create_badge(self, text: str, style: str = "default") -> str:
        """Crear badges HTML con estilos predefinidos"""
        styles = {
            "default": {"bg": "#f1f5f9", "fg": "#334155", "border": "#e2e8f0"},
            "success": {"bg": "#dcfce7", "fg": "#166534", "border": "#bbf7d0"},
            "warning": {"bg": "#fef3c7", "fg": "#92400e", "border": "#fde68a"},
            "danger": {"bg": "#fee2e2", "fg": "#7f1d1d", "border": "#fecaca"},
            "info": {"bg": "#dbeafe", "fg": "#1e40af", "border": "#93c5fd"},
            "critical": {"bg": "#7f1d1d", "fg": "#ffffff", "border": "#991b1b"},
            "geo": {"bg": "#ecfeff", "fg": "#0c4a6e", "border": "#7dd3fc"},
            "geo-risk": {"bg": "#fee2e2", "fg": "#7f1d1d", "border": "#fca5a5"}
        }

        style_config = styles.get(style, styles["default"])

        return (f"<span style='display:inline-block;padding:4px 12px;border-radius:16px;"
                f"background:{style_config['bg']};color:{style_config['fg']};"
                f"border:1px solid {style_config['border']};"
                f"font:bold 11px/14px Segoe UI,Roboto,Arial,sans-serif;"
                f"text-transform:uppercase;letter-spacing:0.5px;white-space:nowrap;'>"
                f"{html.escape(str(text))}</span>")

    def _get_country_flag(self, iso_code: str) -> str:
        """Convertir código ISO a emoji de bandera"""
        if not iso_code or len(iso_code) != 2:
            return ""
        try:
            return "".join(chr(0x1F1E6 + ord(char) - 65) for char in iso_code.upper())
        except Exception:
            return ""

    def _get_geoip_info(self, ip: str) -> Dict[str, Any]:
        """Obtener información GeoIP con múltiples bases de datos"""
        if not ip or not HAS_GEOIP:
            return {}

        db_paths = [
            self.config.get("geoip_db", ""),
            "/var/ossec/etc/GeoIP/GeoLite2-City.mmdb",
            "/var/ossec/etc/GeoLite2-City.mmdb",
            "/usr/share/GeoIP/GeoLite2-City.mmdb",
            "/usr/share/GeoIP/dbip-city-lite.mmdb",
            "/opt/geoip/GeoLite2-City.mmdb"
        ]

        for db_path in db_paths:
            if not db_path or not pathlib.Path(db_path).exists():
                continue

            try:
                with geoip2.database.Reader(db_path) as reader:
                    response = reader.city(ip)
                    return {
                        "country": response.country.name or "",
                        "iso": response.country.iso_code or "",
                        "city": response.city.name or "",
                        "latitude": response.location.latitude,
                        "longitude": response.location.longitude
                    }
            except Exception as e:
                self.logger.debug(f"Error con base GeoIP {db_path}: {e}")
                continue

        return {}

    def _detect_alert_type(self, alert: Dict[str, Any]) -> str:
        """Detectar tipo de alerta basándose en rule_id y contenido"""
        rule_id = self._get_field(alert, "rule.id")

        # Reglas de Active Directory
        ad_rules = {"100080", "100081", "100082", "100083", "100084", "100085",
                   "60107", "60108", "60109", "60113"}

        # Reglas de FortiGate VPN/Admin
        fgt_vpn_rules = {"196100", "196101", "196102", "196103", "196104", "196105", 
                         "196106", "196112", "196113"}

        # Reglas de FortiGate IPS (196200-196231)
        fgt_ips_rules = set(str(x) for x in range(196200, 196232))

        if rule_id in ad_rules:
            return "active_directory"
        elif rule_id in fgt_vpn_rules:
            return "fortigate_vpn"
        elif rule_id in fgt_ips_rules:
            return "fortigate_ips"
        else:
            # Detectar por contenido si no es por rule_id
            rule_desc = self._get_field(alert, "rule.description", default="").lower()
            if any(term in rule_desc for term in ["active directory", "windows", "user account", "group"]):
                return "active_directory"
            elif any(term in rule_desc for term in ["vpn", "admin", "brute"]):
                return "fortigate_vpn"
            elif any(term in rule_desc for term in ["ips", "attack", "exploit", "malware"]):
                return "fortigate_ips"
            else:
                return "generic"

    def _extract_common_data(self, alert: Dict[str, Any]) -> Dict[str, Any]:
        """Extraer datos comunes a todos los tipos de alerta"""
        data = {
            "rule_id": self._get_field(alert, "rule.id"),
            "rule_level": self._get_field(alert, "rule.level"),
            "rule_desc": self._get_field(alert, "rule.description"),
            "rule_groups": self._get_field(alert, "rule.groups"),
            "fired_times": self._get_field(alert, "rule.firedtimes", default="1"),
            "agent_name": self._get_field(alert, "agent.name"),
            "agent_id": self._get_field(alert, "agent.id"),
            "manager_name": self._get_field(alert, "manager.name"),
            "timestamp": self._format_timestamp(self._get_field(alert, "timestamp", "data.eventtime")),
            "location": self._get_field(alert, "location"),
            "decoder": self._get_field(alert, "decoder.name")
        }

        return data

    def _extract_ad_data(self, alert: Dict[str, Any]) -> Dict[str, Any]:
        """Extraer datos específicos de Active Directory"""
        data = self._extract_common_data(alert)

        data["subject_user"] = self._get_field(alert, "data.win.eventdata.subjectUserName")
        data["subject_domain"] = self._get_field(alert, "data.win.eventdata.subjectDomainName")
        data["target_user"] = self._get_field(alert, "data.win.eventdata.targetUserName")
        data["sam_account"] = self._get_field(alert, "data.win.eventdata.samAccountName")
        data["user_principal"] = self._get_field(alert, "data.win.eventdata.userPrincipalName")
        data["display_name"] = self._get_field(alert, "data.win.eventdata.displayName")
        data["group_name"] = self._get_field(alert, "data.win.eventdata.targetUserName")
        data["member_name"] = self._get_field(alert, "data.win.eventdata.memberName")
        data["computer"] = self._get_field(alert, "data.win.system.computer")
        data["event_id"] = self._get_field(alert, "data.win.system.eventID")

        group_name = data.get("group_name", "")
        data["is_privileged"] = group_name in self.privileged_groups
        data["is_anonymous"] = data.get("subject_user", "") == "ANONYMOUS LOGON"

        event_id = data["event_id"]
        if event_id == "4720":
            data["title"] = "Usuario Creado en Active Directory"
            data["color"] = "#059669"
            data["priority"] = "MEDIO"
            data["pivot"] = data["target_user"]
        elif event_id == "4726":
            data["title"] = "Usuario Eliminado de Active Directory"
            data["color"] = "#dc2626"
            data["priority"] = "ALTO"
            data["pivot"] = data["target_user"]
        elif event_id in ("4732", "4728"):
            action = "Alta en Grupo"
            group_type = "LOCAL" if event_id == "4732" else "GLOBAL"
            data["title"] = f"{action} {group_type}"
            data["color"] = "#0284c7" if event_id == "4732" else "#ea580c"
            data["priority"] = "CRÍTICO" if data["is_privileged"] else "MEDIO"
            data["pivot"] = f"{data['member_name']} → {data['group_name']}"
        elif event_id in ("4733", "4729"):
            action = "Baja de Grupo"
            group_type = "LOCAL" if event_id == "4733" else "GLOBAL"
            data["title"] = f"{action} {group_type}"
            data["color"] = "#6b7280" if event_id == "4733" else "#9ca3af"
            data["priority"] = "MEDIO" if data["is_privileged"] else "BAJO"
            data["pivot"] = f"{data['member_name']} ← {data['group_name']}"
        else:
            data["title"] = f"Evento Active Directory {event_id}"
            data["color"] = "#6366f1"
            data["priority"] = "MEDIO"
            data["pivot"] = data.get("target_user", "N/A")

        return data

    def _extract_fortigate_vpn_data(self, alert: Dict[str, Any]) -> Dict[str, Any]:
        """Extraer datos específicos de FortiGate VPN/Admin"""
        data = self._extract_common_data(alert)

        data["dst_user"] = self._get_field(alert, "data.dstuser", "data.user", "data.srcuser")
        data["status"] = self._get_field(alert, "data.status")
        data["reason"] = self._get_field(alert, "data.reason")
        data["log_desc"] = self._get_field(alert, "data.logdesc")
        data["ui"] = self._get_field(alert, "data.ui")
        data["method"] = self._get_field(alert, "data.method")
        data["action"] = self._get_field(alert, "data.action")
        data["dev_name"] = self._get_field(alert, "data.devname")
        data["dev_id"] = self._get_field(alert, "data.devid")

        src_ip = self._get_field(alert, "data.srcip", "data.remip")
        if not src_ip or src_ip == "-":
            ui_text = data.get("ui", "")
            ip_match = re.search(r'(\d{1,3}(?:\.\d{1,3}){3})', ui_text)
            src_ip = ip_match.group(1) if ip_match else "-"
        data["src_ip"] = src_ip

        geo_info = self._get_geoip_info(src_ip)
        data["country"] = geo_info.get("country", "")
        data["iso"] = geo_info.get("iso", "")
        data["city"] = geo_info.get("city", "")
        data["is_high_risk"] = data["country"] in self.high_risk_countries

        method = data.get("method", "").lower()
        ui = data.get("ui", "").lower()
        action = data.get("action", "").lower()

        if "ssh" in method or "ssh(" in ui:
            data["vector"] = "SSH"
        elif "https" in method or "http(" in ui or "https(" in ui:
            data["vector"] = "Web (HTTPS)"
        elif "tunnel" in action or "vpn" in action:
            data["vector"] = "VPN"
        else:
            data["vector"] = "Desconocido"

        rule_id = data["rule_id"]
        if rule_id == "196100":
            data["title"] = "FortiGate ADMIN Brute-Force Attack"
            data["color"] = "#dc2626"
            data["priority"] = "CRÍTICO"
            data["pivot"] = data["src_ip"]
            data["recommendation"] = "Bloquear IP inmediatamente. Revisar logs de intentos previos."
        elif rule_id == "196101":
            data["title"] = "FortiGate VPN SSL Brute-Force Attack"
            data["color"] = "#b91c1c"
            data["priority"] = "CRÍTICO"
            data["pivot"] = f"{data['dst_user']} from {data['src_ip']}"
            data["recommendation"] = "Bloquear IP y verificar estado de la cuenta VPN."
        elif rule_id == "196102":
            data["title"] = "VPN - Conexión Fuera de Horario Laboral"
            data["color"] = "#ea580c"
            data["priority"] = "MEDIO-ALTO"
            data["pivot"] = f"{data['dst_user']} @ {data['timestamp']}"
            data["recommendation"] = "Verificar si el acceso es autorizado con el usuario."
        elif rule_id == "196103":
            data["title"] = "VPN - Conexión Fin de Semana"
            data["color"] = "#f59e0b"
            data["priority"] = "MEDIO"
            data["pivot"] = f"{data['dst_user']} @ {data['timestamp']}"
            data["recommendation"] = "Verificar si el acceso de fin de semana es necesario."
        elif rule_id == "196104":
            data["title"] = "POSIBLE COMPROMISO DE CUENTA VPN"
            data["color"] = "#7f1d1d"
            data["priority"] = "EMERGENCIA"
            data["pivot"] = f"Usuario {data['dst_user']} - Múltiples países"
            data["recommendation"] = "DESHABILITAR CUENTA INMEDIATAMENTE. Contactar usuario."
        elif rule_id == "196106":
            data["title"] = "Conexión desde TOR/Proxy Anónimo"
            data["color"] = "#b91c1c"
            data["priority"] = "CRÍTICO"
            data["pivot"] = f"IP TOR: {data['src_ip']}"
            data["recommendation"] = "Bloquear todas las conexiones desde nodos TOR."
        else:
            level = int(data.get("rule_level", "0"))
            if level >= 12:
                data["title"] = "FortiGate Critical Security Alert"
                data["color"] = "#dc2626"
                data["priority"] = "CRÍTICO"
            elif level >= 10:
                data["title"] = "FortiGate High Security Alert"
                data["color"] = "#ea580c"
                data["priority"] = "ALTO"
            else:
                data["title"] = "FortiGate Security Event"
                data["color"] = "#f59e0b"
                data["priority"] = "MEDIO"

            data["pivot"] = f"{data.get('dst_user', 'N/A')} @ {data['src_ip']}"
            data["recommendation"] = "Revisar evento para determinar acciones necesarias."

        return data

    def _extract_fortigate_ips_data(self, alert: Dict[str, Any]) -> Dict[str, Any]:
        """Extraer datos específicos de IPS de FortiGate"""
        data = self._extract_common_data(alert)

        # Campos específicos de IPS
        data["src_ip"] = self._get_field(alert, "data.srcip")
        data["dst_ip"] = self._get_field(alert, "data.dstip")
        data["dst_port"] = self._get_field(alert, "data.dstport")
        data["attack"] = self._get_field(alert, "data.attack", "data.attack_name", "data.signature")
        data["severity"] = self._get_field(alert, "data.severity")
        data["action"] = self._get_field(alert, "data.action")
        data["protocol"] = self._get_field(alert, "data.proto", "data.protocol")
        data["dev_name"] = self._get_field(alert, "data.devname")
        data["dev_id"] = self._get_field(alert, "data.devid")

        # GeoIP para IP origen
        geo_info = self._get_geoip_info(data["src_ip"])
        data["country"] = geo_info.get("country", "")
        data["iso"] = geo_info.get("iso", "")
        data["city"] = geo_info.get("city", "")
        data["is_high_risk"] = data["country"] in self.high_risk_countries

        # Determinar criticidad y tipo
        severity = data.get("severity", "").lower()
        attack_name = data.get("attack", "").lower()
        action = data.get("action", "").lower()

        # Configurar por severidad
        if severity == "critical":
            data["priority"] = "CRÍTICO"
            data["color"] = "#dc2626"
            data["title"] = f"IPS CRÍTICO: {data['attack']}"
        elif severity == "high":
            data["priority"] = "ALTO"
            data["color"] = "#ea580c"
            data["title"] = f"IPS ALTO: {data['attack']}"
        elif severity == "medium":
            data["priority"] = "MEDIO"
            data["color"] = "#f59e0b"
            data["title"] = f"IPS MEDIO: {data['attack']}"
        else:
            data["priority"] = "BAJO"
            data["color"] = "#3b82f6"
            data["title"] = f"IPS: {data['attack']}"

        # Ajustar por acción
        if action == "detected" and severity in ["critical", "high"]:
            data["priority"] = "EMERGENCIA"
            data["color"] = "#7f1d1d"
            data["title"] = "ATAQUE CRÍTICO NO BLOQUEADO"
            data["recommendation"] = "BLOQUEAR IP INMEDIATAMENTE - Ataque no fue bloqueado por IPS"

        # Detectar tipo de ataque específico
        if "sql" in attack_name or "injection" in attack_name:
            data["attack_type"] = "SQL Injection"
            data["recommendation"] = "Revisar WAF y logs de aplicación web. Verificar consultas SQL."
        elif "xss" in attack_name or "cross-site" in attack_name:
            data["attack_type"] = "Cross-Site Scripting"
            data["recommendation"] = "Validar entrada de usuarios. Revisar sanitización de datos."
        elif "command" in attack_name and "injection" in attack_name:
            data["attack_type"] = "Command Injection"
            data["recommendation"] = "Revisar ejecución de comandos en aplicación. Deshabilitar funciones peligrosas."
        elif "dos" in attack_name or "ddos" in attack_name or "flood" in attack_name:
            data["attack_type"] = "Denial of Service"
            data["recommendation"] = "Activar mitigación DDoS. Considerar rate limiting."
        elif "malware" in attack_name or "trojan" in attack_name or "virus" in attack_name:
            data["attack_type"] = "Malware"
            data["recommendation"] = "Escanear sistemas afectados. Aislar hosts comprometidos."
        elif "ransomware" in attack_name:
            data["attack_type"] = "Ransomware"
            data["recommendation"] = "AISLAR RED INMEDIATAMENTE. Verificar backups. Contactar equipo de respuesta."
            data["priority"] = "EMERGENCIA"
            data["color"] = "#7f1d1d"
        elif "exploit" in attack_name or "cve-" in attack_name:
            data["attack_type"] = "Exploit Attempt"
            data["recommendation"] = "Verificar parches de seguridad. Revisar CVE mencionado."
        elif "buffer" in attack_name and "overflow" in attack_name:
            data["attack_type"] = "Buffer Overflow"
            data["recommendation"] = "Actualizar software vulnerable. Verificar parches disponibles."
        elif "scan" in attack_name or "nmap" in attack_name:
            data["attack_type"] = "Network Scan"
            data["recommendation"] = "Monitorear IP origen para detectar fase de explotación."
        elif "wordpress" in attack_name or "wp-" in attack_name:
            data["attack_type"] = "WordPress Attack"
            data["recommendation"] = "Actualizar WordPress y plugins. Revisar permisos de archivos."
        else:
            data["attack_type"] = "IPS Detection"
            data["recommendation"] = "Revisar logs del firewall para más detalles."

        data["pivot"] = f"{data['src_ip']} → {data['dst_ip']}:{data['dst_port']} • {data['attack']}"

        return data

    def _build_ad_info_rows(self, data: Dict[str, Any]) -> str:
        """Construir filas de información para Active Directory"""
        esc = lambda x: html.escape(str(x or "-"))

        rows = []
        event_id = data.get("event_id", "")

        if event_id in ("4720", "4726"):
            rows.extend([
                f"<tr><td class='label'>Usuario:</td><td class='value'><code>{esc(data.get('target_user', ''))}</code></td></tr>",
                f"<tr><td class='label'>SAM Account:</td><td class='value'><code>{esc(data.get('sam_account', ''))}</code></td></tr>",
                f"<tr><td class='label'>UPN:</td><td class='value'><code>{esc(data.get('user_principal', ''))}</code></td></tr>",
                f"<tr><td class='label'>Nombre:</td><td class='value'>{esc(data.get('display_name', ''))}</td></tr>"
            ])
        elif event_id in ("4732", "4733", "4728", "4729"):
            privilege_badge = self._create_badge("GRUPO PRIVILEGIADO", "danger") if data.get("is_privileged") else ""
            rows.extend([
                f"<tr><td class='label'>Miembro:</td><td class='value'><code>{esc(data.get('member_name', ''))}</code></td></tr>",
                f"<tr><td class='label'>Grupo:</td><td class='value'><code>{esc(data.get('group_name', ''))}</code> {privilege_badge}</td></tr>"
            ])

        anon_badge = self._create_badge("ANONYMOUS LOGON", "warning") if data.get("is_anonymous") else ""
        agent_name = data.get('agent_name', '')
        agent_id = data.get('agent_id', '')
        agent_badge = self._create_badge(f"{agent_name} (ID {agent_id})", 'default')
        computer_badge = self._create_badge(data.get('computer', ''), 'info')

        rows.extend([
            f"<tr><td class='label'>Ejecutado por:</td><td class='value'><code>{esc(data.get('subject_user', ''))}</code> [{esc(data.get('subject_domain', ''))}] {anon_badge}</td></tr>",
            f"<tr><td class='label'>Equipo/DC:</td><td class='value'>{computer_badge}</td></tr>",
            f"<tr><td class='label'>Agente Wazuh:</td><td class='value'>{agent_badge}</td></tr>",
            f"<tr><td class='label'>Timestamp:</td><td class='value'><code>{esc(data.get('timestamp', ''))}</code></td></tr>",
            f"<tr><td class='label'>Intentos:</td><td class='value'><strong>{esc(data.get('fired_times', '1'))}</strong></td></tr>"
        ])

        return "\n".join(rows)

    def _build_fgt_vpn_info_rows(self, data: Dict[str, Any]) -> str:
        """Construir filas de información para FortiGate VPN/Admin"""
        esc = lambda x: html.escape(str(x or "-"))

        geo_badge = ""
        if data.get("country"):
            flag = self._get_country_flag(data.get("iso", ""))
            geo_text = f"{flag} {data['country']}"
            if data.get("city"):
                geo_text += f" • {data['city']}"

            geo_style = "geo-risk" if data.get("is_high_risk") else "geo"
            geo_badge = self._create_badge(geo_text, geo_style)

        vector_badge = self._create_badge(data.get('vector', 'Desconocido'), 'info')
        dev_name = data.get('dev_name', '')
        dev_id = data.get('dev_id', '')
        device_badge = self._create_badge(f"{dev_name} / {dev_id}", 'default')
        agent_name = data.get('agent_name', '')
        agent_id = data.get('agent_id', '')
        agent_badge = self._create_badge(f"{agent_name} (ID {agent_id})", 'warning')
        status_badge = self._create_badge(data.get('status', ''), 'default')

        rows = [
            f"<tr><td class='label'>IP Origen:</td><td class='value'><code>{esc(data.get('src_ip', ''))}</code> {geo_badge}</td></tr>",
            f"<tr><td class='label'>Usuario:</td><td class='value'><code>{esc(data.get('dst_user', ''))}</code></td></tr>",
            f"<tr><td class='label'>Vector:</td><td class='value'>{vector_badge}</td></tr>",
            f"<tr><td class='label'>Dispositivo:</td><td class='value'>{device_badge}</td></tr>",
            f"<tr><td class='label'>Agente Wazuh:</td><td class='value'>{agent_badge}</td></tr>",
            f"<tr><td class='label'>Estado:</td><td class='value'>{status_badge} • {esc(data.get('reason', ''))}</td></tr>",
            f"<tr><td class='label'>Descripción:</td><td class='value'>{esc(data.get('log_desc', ''))}</td></tr>",
            f"<tr><td class='label'>Intentos:</td><td class='value'><strong>{esc(data.get('fired_times', '1'))}</strong></td></tr>",
            f"<tr><td class='label'>Timestamp:</td><td class='value'><code>{esc(data.get('timestamp', ''))}</code></td></tr>"
        ]

        return "\n".join(rows)

    def _build_ips_info_rows(self, data: Dict[str, Any]) -> str:
        """Construir filas de información para IPS"""
        esc = lambda x: html.escape(str(x or "-"))

        # Badge de GeoIP
        geo_badge = ""
        if data.get("country"):
            flag = self._get_country_flag(data.get("iso", ""))
            geo_text = f"{flag} {data['country']}"
            if data.get("city"):
                geo_text += f" • {data['city']}"

            geo_style = "geo-risk" if data.get("is_high_risk") else "geo"
            geo_badge = self._create_badge(geo_text, geo_style)

        # Badges
        severity_styles = {
            "critical": "critical",
            "high": "danger",
            "medium": "warning",
            "low": "info"
        }
        severity_badge = self._create_badge(
            data.get('severity', 'unknown').upper(),
            severity_styles.get(data.get('severity', '').lower(), 'default')
        )

        action_style = "danger" if data.get('action') == 'detected' else "success"
        action_badge = self._create_badge(data.get('action', '').upper(), action_style)

        attack_type_badge = self._create_badge(data.get('attack_type', 'IPS Detection'), 'info')

        device_badge = self._create_badge(f"{data.get('dev_name', '')} / {data.get('dev_id', '')}", 'default')
        agent_badge = self._create_badge(f"{data.get('agent_name', '')} (ID {data.get('agent_id', '')})", 'warning')

        rows = [
            f"<tr><td class='label'>Tipo de Ataque:</td><td class='value'>{attack_type_badge}</td></tr>",
            f"<tr><td class='label'>Firma:</td><td class='value'><code>{esc(data.get('attack', ''))}</code></td></tr>",
            f"<tr><td class='label'>IP Origen:</td><td class='value'><code>{esc(data.get('src_ip', ''))}</code> {geo_badge}</td></tr>",
            f"<tr><td class='label'>IP Destino:</td><td class='value'><code>{esc(data.get('dst_ip', ''))}:{esc(data.get('dst_port', ''))}</code></td></tr>",
            f"<tr><td class='label'>Severidad:</td><td class='value'>{severity_badge}</td></tr>",
            f"<tr><td class='label'>Acción IPS:</td><td class='value'>{action_badge}</td></tr>",
            f"<tr><td class='label'>Protocolo:</td><td class='value'><code>{esc(data.get('protocol', ''))}</code></td></tr>",
            f"<tr><td class='label'>Dispositivo:</td><td class='value'>{device_badge}</td></tr>",
            f"<tr><td class='label'>Agente Wazuh:</td><td class='value'>{agent_badge}</td></tr>",
            f"<tr><td class='label'>Intentos:</td><td class='value'><strong>{esc(data.get('fired_times', '1'))}</strong></td></tr>",
            f"<tr><td class='label'>Timestamp:</td><td class='value'><code>{esc(data.get('timestamp', ''))}</code></td></tr>"
        ]

        return "\n".join(rows)

    def _build_generic_info_rows(self, data: Dict[str, Any]) -> str:
        """Construir filas de información para alertas genéricas"""
        esc = lambda x: html.escape(str(x or "-"))

        agent_name = data.get('agent_name', '')
        agent_id = data.get('agent_id', '')
        agent_badge = self._create_badge(f"{agent_name} (ID {agent_id})", 'default')
        decoder_badge = self._create_badge(data.get('decoder', ''), 'info')

        rows = [
            f"<tr><td class='label'>Agente:</td><td class='value'>{agent_badge}</td></tr>",
            f"<tr><td class='label'>Ubicación:</td><td class='value'><code>{esc(data.get('location', ''))}</code></td></tr>",
            f"<tr><td class='label'>Decoder:</td><td class='value'>{decoder_badge}</td></tr>",
            f"<tr><td class='label'>Grupos:</td><td class='value'>{esc(data.get('rule_groups', ''))}</td></tr>",
            f"<tr><td class='label'>Intentos:</td><td class='value'><strong>{esc(data.get('fired_times', '1'))}</strong></td></tr>",
            f"<tr><td class='label'>Timestamp:</td><td class='value'><code>{esc(data.get('timestamp', ''))}</code></td></tr>"
        ]

        return "\n".join(rows)

    def _build_html_body(self, data: Dict[str, Any], alert_type: str) -> str:
        """Construir cuerpo HTML del email con template unificado"""
        esc = lambda x: html.escape(str(x or "-"))

        css_styles = """
        <style>
            body { font-family: 'Segoe UI', Roboto, Arial, sans-serif; background: #f8fafc; margin: 0; padding: 20px; }
            .container { max-width: 800px; margin: 0 auto; background: white; border-radius: 12px; box-shadow: 0 4px 6px rgba(0,0,0,0.1); overflow: hidden; }
            .header { padding: 24px; border-left: 8px solid """ + data.get('color', '#6366f1') + """; background: linear-gradient(135deg, #f8fafc 0%, #e2e8f0 100%); }
            .title { font-size: 24px; font-weight: 700; margin-bottom: 8px; color: #1f2937; }
            .subtitle { font-size: 14px; color: #64748b; margin-bottom: 16px; }
            .badges { display: flex; gap: 8px; flex-wrap: wrap; }
            .pivot-section { background: #fef2f2; padding: 16px; margin: 20px; border-radius: 8px; border-left: 4px solid """ + data.get('color', '#6366f1') + """; }
            .pivot-label { font-weight: bold; color: #374151; margin-bottom: 4px; }
            .pivot-value { font-family: 'Courier New', monospace; font-size: 16px; font-weight: bold; color: #1f2937; }
            .info-table { width: 100%; border-collapse: collapse; margin: 20px 0; }
            .info-table td { padding: 12px 16px; border-bottom: 1px solid #e5e7eb; }
            .info-table .label { font-weight: 600; color: #374151; width: 160px; background: #f9fafb; }
            .info-table .value { color: #1f2937; }
            .recommendation { background: #fef3c7; padding: 16px; margin: 20px; border-radius: 8px; border-left: 4px solid #f59e0b; }
            .recommendation-title { font-weight: bold; color: #92400e; margin-bottom: 8px; }
            .recommendation-text { color: #78350f; }
            .actions { background: #f0f9ff; padding: 16px; margin: 20px; border-radius: 8px; border-left: 4px solid #0284c7; }
            .actions-title { font-weight: bold; color: #0c4a6e; margin-bottom: 8px; }
            .actions ul { margin: 8px 0; padding-left: 20px; color: #075985; }
            .footer { padding: 16px; background: #f8fafc; border-top: 1px solid #e5e7eb; font-size: 12px; color: #64748b; text-align: center; }
        </style>
        """

        priority_styles = {
            "EMERGENCIA": "critical",
            "CRÍTICO URGENTE": "critical",
            "CRÍTICO": "danger",
            "ALTO": "warning",
            "MEDIO-ALTO": "warning",
            "MEDIO": "info",
            "BAJO": "default"
        }
        priority_style = priority_styles.get(data.get("priority", "MEDIO"), "default")

        badges_html = f"""
            {self._create_badge(f"RULE {data['rule_id']} • NIVEL {data['rule_level']}", "info")}
            {self._create_badge(data.get('priority', 'MEDIO'), priority_style)}
        """

        pivot_html = f"""
        <div class="pivot-section">
            <div class="pivot-label">Información Principal:</div>
            <div class="pivot-value">{esc(data.get('pivot', 'N/A'))}</div>
        </div>
        """

        if alert_type == "active_directory":
            info_rows = self._build_ad_info_rows(data)
        elif alert_type == "fortigate_vpn":
            info_rows = self._build_fgt_vpn_info_rows(data)
        elif alert_type == "fortigate_ips":
            info_rows = self._build_ips_info_rows(data)
        else:
            info_rows = self._build_generic_info_rows(data)

        recommendation_html = ""
        if data.get("recommendation"):
            recommendation_html = f"""
            <div class="recommendation">
                <div class="recommendation-title">Recomendación:</div>
                <div class="recommendation-text">{esc(data['recommendation'])}</div>
            </div>
            """

        actions_html = f"""
        <div class="actions">
            <div class="actions-title">Acciones Sugeridas:</div>
            <ul>
                <li>Revisar actividad reciente en los logs del sistema</li>
                <li>Verificar la legitimidad del evento con usuarios involucrados</li>
                <li>Documentar el incidente en el sistema de tickets</li>
                <li>Aplicar medidas correctivas si es necesario</li>
                {f"<li><strong>{data['recommendation']}</strong></li>" if data.get('recommendation') else ""}
            </ul>
        </div>
        """

        return f"""<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{esc(data.get('title', 'Wazuh Alert'))}</title>
    {css_styles}
</head>
<body>
    <div class="container">
        <div class="header">
            <div class="title">{data.get('title', 'Alerta de Seguridad')}</div>
            <div class="subtitle">{esc(data.get('rule_desc', ''))}</div>
            <div class="badges">{badges_html}</div>
        </div>

        {pivot_html}

        <table class="info-table">
            {info_rows}
        </table>

        {recommendation_html}

        {actions_html}

        <div class="footer">
            <strong>Wazuh SIEM Alert</strong> • Unified Email Notifier v4.0<br>
            Generado: {datetime.now().strftime('%d/%m/%Y %H:%M:%S')}
        </div>
    </div>
</body>
</html>"""

    def _build_text_body(self, data: Dict[str, Any], alert_type: str) -> str:
        """Construir cuerpo de texto plano del email"""
        lines = [
            f"{data.get('title', 'Alerta de Seguridad')}",
            "=" * 80,
            f"PRIORIDAD: {data.get('priority', 'MEDIO')}",
            f"Rule: {data.get('rule_id', '')} (Nivel {data.get('rule_level', '')})",
            f"Descripción: {data.get('rule_desc', '')}",
            "",
            f"INFORMACIÓN PRINCIPAL: {data.get('pivot', 'N/A')}",
            "-" * 50
        ]

        if alert_type == "active_directory":
            lines.extend(self._build_ad_text_info(data))
        elif alert_type == "fortigate_vpn":
            lines.extend(self._build_fgt_text_info(data))
        elif alert_type == "fortigate_ips":
            lines.extend(self._build_ips_text_info(data))
        else:
            lines.extend(self._build_generic_text_info(data))

        lines.extend([
            "",
            f"Agente: {data.get('agent_name', '')} (ID {data.get('agent_id', '')})",
            f"Intentos: {data.get('fired_times', '1')}",
            f"Timestamp: {data.get('timestamp', '')}",
            ""
        ])

        if data.get("recommendation"):
            lines.extend([
                f"RECOMENDACIÓN: {data['recommendation']}",
                ""
            ])

        lines.extend([
            "ACCIONES SUGERIDAS:",
            "- Revisar actividad reciente en los logs",
            "- Verificar legitimidad con usuarios involucrados",
            "- Documentar en sistema de tickets",
            "- Aplicar medidas correctivas si es necesario",
            "",
            "=" * 80
        ])

        return "\n".join(lines)

    def _build_ad_text_info(self, data: Dict[str, Any]) -> list:
        """Información de texto para AD"""
        lines = []
        event_id = data.get("event_id", "")

        if event_id in ("4720", "4726"):
            lines.extend([
                f"Usuario: {data.get('target_user', '')}",
                f"SAM: {data.get('sam_account', '')}",
                f"UPN: {data.get('user_principal', '')}",
                f"Nombre: {data.get('display_name', '')}"
            ])
        elif event_id in ("4732", "4733", "4728", "4729"):
            privilege_note = " [GRUPO PRIVILEGIADO]" if data.get("is_privileged") else ""
            lines.extend([
                f"Miembro: {data.get('member_name', '')}",
                f"Grupo: {data.get('group_name', '')}{privilege_note}"
            ])

        anon_note = " [ANONYMOUS LOGON]" if data.get("is_anonymous") else ""
        lines.extend([
            f"Ejecutado por: {data.get('subject_user', '')} [{data.get('subject_domain', '')}]{anon_note}",
            f"Equipo/DC: {data.get('computer', '')}"
        ])

        return lines

    def _build_fgt_text_info(self, data: Dict[str, Any]) -> list:
        """Información de texto para FortiGate VPN/Admin"""
        geo_info = ""
        if data.get("country"):
            geo_info = f" ({data['country']}"
            if data.get("city"):
                geo_info += f" - {data['city']}"
            geo_info += ")"
            if data.get("is_high_risk"):
                geo_info += " [PAÍS DE ALTO RIESGO]"

        return [
            f"IP Origen: {data.get('src_ip', '')}{geo_info}",
            f"Usuario: {data.get('dst_user', '')}",
            f"Vector: {data.get('vector', 'Desconocido')}",
            f"Dispositivo: {data.get('dev_name', '')} / {data.get('dev_id', '')}",
            f"Estado: {data.get('status', '')}  Motivo: {data.get('reason', '')}",
            f"Log: {data.get('log_desc', '')}"
        ]

    def _build_ips_text_info(self, data: Dict[str, Any]) -> list:
        """Información de texto para IPS"""
        geo_info = ""
        if data.get("country"):
            geo_info = f" ({data['country']}"
            if data.get("city"):
                geo_info += f" - {data['city']}"
            geo_info += ")"
            if data.get("is_high_risk"):
                geo_info += " [PAÍS DE ALTO RIESGO]"

        return [
            f"Tipo de Ataque: {data.get('attack_type', 'IPS Detection')}",
            f"Firma: {data.get('attack', '')}",
            f"IP Origen: {data.get('src_ip', '')}{geo_info}",
            f"IP Destino: {data.get('dst_ip', '')}:{data.get('dst_port', '')}",
            f"Severidad: {data.get('severity', '').upper()}",
            f"Acción IPS: {data.get('action', '').upper()}",
            f"Protocolo: {data.get('protocol', '')}",
            f"Dispositivo: {data.get('dev_name', '')} / {data.get('dev_id', '')}"
        ]

    def _build_generic_text_info(self, data: Dict[str, Any]) -> list:
        """Información de texto para alertas genéricas"""
        return [
            f"Ubicación: {data.get('location', '')}",
            f"Decoder: {data.get('decoder', '')}",
            f"Grupos: {data.get('rule_groups', '')}"
        ]

    def _build_subject(self, data: Dict[str, Any]) -> str:
        """Construir asunto del email"""
        prefix = self.config.get("subject_prefix", "[Wazuh SIEM]")
        priority = data.get("priority", "MEDIO")
        title = data.get("title", "Alerta de Seguridad")
        pivot = data.get("pivot", "N/A")
        level = data.get("rule_level", "")

        max_title_len = 40
        max_pivot_len = 30

        if len(title) > max_title_len:
            title = title[:max_title_len-3] + "..."
        if len(pivot) > max_pivot_len:
            pivot = pivot[:max_pivot_len-3] + "..."

        return f"{prefix} {priority} • {title} • {pivot} • L{level}"

    def _send_email(self, message: MIMEMultipart):
        """Enviar email con manejo robusto de errores"""
        smtp_config = {
            "host": self.config["smtp_host"],
            "port": int(self.config.get("smtp_port", 587)),
            "use_tls": bool(self.config.get("use_tls", True)),
            "username": self.config.get("username"),
            "password": self.config.get("password"),
            "timeout": int(self.config.get("timeout", 30))
        }

        recipients = self.config.get("to", [])
        if not recipients:
            raise ValueError("No hay destinatarios configurados")

        self.logger.info(f"Enviando email a {len(recipients)} destinatarios via {smtp_config['host']}:{smtp_config['port']}")

        try:
            if smtp_config["use_tls"]:
                context = ssl.create_default_context()
                if self.config.get("insecure_skip_verify", False):
                    context.check_hostname = False
                    context.verify_mode = ssl.CERT_NONE
                    self.logger.warning("Verificación SSL deshabilitada")

                with smtplib.SMTP(smtp_config["host"], smtp_config["port"],
                                timeout=smtp_config["timeout"]) as server:
                    server.ehlo()
                    server.starttls(context=context)
                    server.ehlo()

                    if smtp_config["username"] and smtp_config["password"]:
                        server.login(smtp_config["username"], smtp_config["password"])
                        self.logger.debug("Autenticación SMTP exitosa")

                    server.sendmail(message["From"], recipients, message.as_string())
            else:
                with smtplib.SMTP(smtp_config["host"], smtp_config["port"],
                                timeout=smtp_config["timeout"]) as server:
                    if smtp_config["username"] and smtp_config["password"]:
                        server.login(smtp_config["username"], smtp_config["password"])
                        self.logger.debug("Autenticación SMTP exitosa")

                    server.sendmail(message["From"], recipients, message.as_string())

            self.logger.info("Email enviado exitosamente")

        except smtplib.SMTPAuthenticationError as e:
            raise RuntimeError(f"Error de autenticación SMTP: {e}")
        except smtplib.SMTPRecipientsRefused as e:
            raise RuntimeError(f"Destinatarios rechazados: {e}")
        except smtplib.SMTPException as e:
            raise RuntimeError(f"Error SMTP: {e}")
        except Exception as e:
            raise RuntimeError(f"Error enviando email: {e}")

    def build_email(self, alert: Dict[str, Any]) -> Tuple[MIMEMultipart, str]:
        """Construir mensaje de email completo"""
        alert_type = self._detect_alert_type(alert)
        self.logger.info(f"Procesando alerta tipo: {alert_type}")

        if alert_type == "active_directory":
            data = self._extract_ad_data(alert)
        elif alert_type == "fortigate_vpn":
            data = self._extract_fortigate_vpn_data(alert)
        elif alert_type == "fortigate_ips":
            data = self._extract_fortigate_ips_data(alert)
        else:
            data = self._extract_common_data(alert)
            data["title"] = "Alerta de Seguridad Wazuh"
            data["color"] = "#6366f1"
            data["priority"] = "MEDIO"
            data["pivot"] = f"Rule {data['rule_id']} • {data.get('agent_name', 'N/A')}"

        html_body = self._build_html_body(data, alert_type)
        text_body = self._build_text_body(data, alert_type)
        subject = self._build_subject(data)

        message = MIMEMultipart("alternative")
        message["Subject"] = Header(subject, "utf-8")
        message["From"] = self.config.get("from", "wazuh@localhost")
        message["To"] = ", ".join(self.config.get("to", []))
        message["X-Priority"] = "1" if data.get("priority") in ["EMERGENCIA", "CRÍTICO URGENTE", "CRÍTICO"] else "3"

        message.attach(MIMEText(text_body, "plain", "utf-8"))
        message.attach(MIMEText(html_body, "html", "utf-8"))

        return message, subject

    def process_alert(self, alert_file: str):
        """Procesar alerta y enviar email"""
        try:
            alert = self._load_alert(alert_file)
            self.logger.info(f"Alerta cargada desde: {alert_file}")

            message, subject = self.build_email(alert)
            self.logger.info(f"Email construido: {subject}")

            self._send_email(message)
            self.logger.info("Procesamiento completado exitosamente")

        except Exception as e:
            self.logger.error(f"Error procesando alerta: {e}")
            raise


def main():
    """Función principal"""
    if len(sys.argv) < 4:
        print("Uso: custom-email-unified <alert_file> <api_key|''> <config_file>", file=sys.stderr)
        print("", file=sys.stderr)
        print("Ejemplos:", file=sys.stderr)
        print("  custom-email-unified /tmp/alert.json '' /var/ossec/etc/email-config.json", file=sys.stderr)
        print("", file=sys.stderr)
        sys.exit(1)

    alert_file = sys.argv[1]
    config_file = sys.argv[3]

    try:
        notifier = UnifiedEmailNotifier(config_file)
        notifier.process_alert(alert_file)
        print("Email enviado exitosamente")

    except Exception as e:
        print(f"ERROR: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()