> For the complete documentation index, see [llms.txt](https://mysther.gitbook.io/knowledge-base/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mysther.gitbook.io/knowledge-base/ataques/linux/pivoting-tunneling.md). # 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 ```