Introdução
O Secure Shell (SSH) não é apenas uma ferramenta para acesso remoto a terminais; é também um poderoso utilitário de rede. O Tunelamento SSH, também conhecido como Encaminhamento de Portas SSH (SSH Port Forwarding), permite que você roteie o tráfego de rede local através de uma conexão SSH segura para hosts remotos.
A ideia central é que você está "pegando emprestada" a conectividade de outra máquina. O túnel não cria uma nova acessibilidade de rede do nada; ele reutiliza a posição e o acesso do host remoto.
Essa técnica é amplamente utilizada por administradores de sistemas, desenvolvedores e profissionais de segurança para contornar firewalls corporativos rígidos, criptografar o tráfego de aplicações legadas e acessar serviços internos ocultos que não estão diretamente expostos à internet pública.
Neste laboratório, você aprenderá os conceitos e as aplicações práticas de dois tipos principais de encaminhamento de porta SSH:
- Encaminhamento de Porta Local (
-L): Encaminha uma porta da sua máquina local para um destino remoto. - Encaminhamento de Porta Remoto (
-R): Encaminha uma porta de um servidor remoto de volta para a sua máquina local.
Entenda a Topologia de Rede
Nesta etapa, exploraremos o ambiente de rede simulado que foi preparado para você.
Para praticar o tunelamento SSH, precisamos de um cenário que envolva várias máquinas. Como estamos trabalhando em um ambiente de máquina virtual única, simulamos uma topologia de rede complexa usando diferentes portas de rede em seu sistema local (127.0.0.1).
Aqui está o mapeamento conceitual da nossa simulação. Sua Máquina Local é representada pela sua sessão de terminal atual. O Bastion Host, ou Servidor de Borda, é simulado usando um contêiner Docker que expõe o SSH em 127.0.0.1:2222. O Serviço Interno é um servidor web rodando na mesma rede Docker privada em 172.31.0.20:80. Conceitualmente, imagine que este serviço está profundamente dentro de uma rede corporativa e bloqueado por um firewall, o que significa que ele só pode ser acessado a partir do Bastion Host. Finalmente, o Serviço Local é um servidor web rodando na porta 8000 na VM do LabEx. Você pode pensar nisso como um servidor de desenvolvimento rodando no seu laptop pessoal que você deseja compartilhar com alguém na internet.
Vamos verificar se nossos serviços simulados estão rodando. Usaremos o comando curl, que é uma ferramenta de linha de comando para transferir dados com URLs.
Primeiro, verifique o "Serviço Local" rodando na porta 8000:
curl http://127.0.0.1:8000
Você deverá ver a saída Local Developer Machine Data.
O serviço interno não está exposto diretamente na VM do LabEx intencionalmente. Você chegará até ele através do túnel SSH na próxima etapa.
Nas etapas a seguir, usaremos o tunelamento SSH para manipular como acessamos esses serviços, simulando cenários reais de contorno de firewall.
Configure o Encaminhamento de Porta Local (-L)
Nesta etapa, você configurará o Encaminhamento de Porta Local.
Imagine que você está em casa e precisa acessar um painel corporativo interno (nosso serviço em 172.31.0.20:80). Um firewall bloqueia o acesso direto a esse endereço interno a partir do mundo exterior. No entanto, o firewall permite conexões SSH para um servidor de borda específico (nosso Bastion Host).
O Encaminhamento de Porta Local permite que você abra uma porta em sua máquina local, e o SSH encaminhará com segurança qualquer tráfego enviado para essa porta local através do túnel SSH até o destino.
A sintaxe para o Encaminhamento de Porta Local é: ssh -L [local_port]:[destination_host]:[destination_port] [user]@[ssh_server]
O encaminhamento local é mais fácil de entender como "fazer um serviço remoto parecer local para mim".
Encaminharemos nossa porta local 8080 para o serviço interno (172.31.0.20:80) através do nosso bastion host SSH simulado. Também usaremos duas flags adicionais. A flag -N diz ao SSH para não executar um comando remoto, o que é útil quando você deseja apenas encaminhar portas. A flag -f diz ao SSH para rodar em segundo plano, permitindo que continuemos usando nosso terminal.
Execute o seguinte comando para criar o túnel:
ssh -N -f -L 8080:172.31.0.20:80 \
-o StrictHostKeyChecking=no \
-o UserKnownHostsFile=/dev/null \
-i ~/project/pivot_key -p 2222 pivot@127.0.0.1
O túnel agora está rodando silenciosamente em segundo plano.
Agora, vamos testar o túnel. Em vez de acessar o endereço Docker interno diretamente, você acessará sua porta local 8080 recém-aberta. O túnel SSH capturará essa solicitação, criptografá-la-á, enviará para o bastion host, que então a encaminhará para 172.31.0.20:80.
curl http://127.0.0.1:8080
Você deverá ver a saída Secret Internal Corporate Data. Você contornou com sucesso o firewall conceitual!
Configure o Encaminhamento de Porta Remoto (-R)
Nesta etapa, você configurará o Encaminhamento de Porta Remoto.
Imagine que você está desenvolvendo uma aplicação web no seu laptop local (nosso serviço na porta 8000). Você deseja mostrar seu progresso a um cliente, mas seu laptop está atrás de um roteador doméstico (NAT) e não possui um endereço IP público.
O Encaminhamento de Porta Remoto resolve isso permitindo que você se conecte a um servidor SSH público e abra uma porta nesse servidor remoto. Qualquer tráfego que atinja essa porta remota é encaminhado de volta através do túnel SSH para sua máquina local.
A sintaxe para o Encaminhamento de Porta Remoto é: ssh -R [remote_port]:[local_host]:[local_port] [user]@[ssh_server]
O encaminhamento remoto inverte a perspectiva: "faça meu serviço local parecer acessível a partir do lado remoto".
Exporemos nosso serviço local (127.0.0.1:8000) para o bastion host na porta 8081.
Execute o seguinte comando para criar o túnel remoto:
ssh -N -f -R 8081:127.0.0.1:8000 \
-o StrictHostKeyChecking=no \
-o UserKnownHostsFile=/dev/null \
-i ~/project/pivot_key -p 2222 pivot@127.0.0.1
O túnel agora está estabelecido em segundo plano. O bastion host agora está escutando na porta 8081. Quando alguém acessa a porta 8081 no servidor remoto, o tráfego é enviado de volta para sua porta local 8000.
Vamos testar isso consultando o serviço encaminhado através do contêiner bastion host:
docker exec bastion_host curl -s http://127.0.0.1:8081
Você deverá ver a saída Local Developer Machine Data. Você expôs com sucesso um serviço local para um servidor remoto!
Acesse o Serviço Web Interno
Nesta etapa final, consolidaremos nosso entendimento usando os túneis que criamos para baixar os dados e salvá-los em arquivos no nosso diretório de projeto.
Certifique-se de estar no seu diretório de projeto padrão:
cd ~/project
Primeiro, vamos usar o túnel de Encaminhamento de Porta Local (porta 8080) para buscar os dados corporativos internos e salvá-los em um arquivo chamado internal_data.txt. Usaremos a flag -o com o curl para especificar o arquivo de saída.
curl http://127.0.0.1:8080 -o internal_data.txt
Em seguida, vamos usar o túnel de Encaminhamento de Porta Remoto (porta 8081) para buscar os dados do desenvolvedor local através do bastion host e salvá-los em um arquivo chamado remote_data.txt.
docker exec bastion_host curl -s http://127.0.0.1:8081 > remote_data.txt
Finalmente, vamos verificar o conteúdo dos arquivos que você acabou de baixar usando o comando cat:
cat internal_data.txt
cat remote_data.txt
Secret Internal Corporate Data
Local Developer Machine Data
Ao baixar com sucesso esses arquivos através das portas encaminhadas, você provou que os túneis SSH estão roteando o tráfego ativamente e com segurança entre os endpoints.
Resumo
Parabéns! Você concluiu com sucesso o laboratório de Tunelamento SSH e Encaminhamento de Portas.
Neste laboratório, você aprendeu a entender os conceitos de tunelamento SSH e como ele pode ser usado para contornar restrições de rede. Você configurou o Encaminhamento de Porta Local (-L) para acessar com segurança serviços internos ocultos, roteando o tráfego local através de um bastion host. Além disso, você configurou o Encaminhamento de Porta Remoto (-R) para expor serviços de desenvolvimento local a um servidor remoto, contornando com sucesso NATs e firewalls locais. Finalmente, você aprendeu como executar túneis SSH silenciosamente em segundo plano usando as flags -N e -f.
Essas habilidades são essenciais para a administração segura de sistemas, desenvolvimento remoto e navegação segura em topologias de rede complexas.
