Skip to main content

Tunelamento SSH | Solyd One

  • Tunelamento SSH | Solyd One
info

Arquivos de configurações do ssh ficam em /etc/ssh/ dentro do arquivo sshd

 vim /etc/ssh/sshd

  • Ativar o ssh

      service start ssh

  • Realizar o tunelamento

ssh -N -L 3001:127.0.0.1:5984 usuario@10.132.213.150

Documentação rápida​

Tunelamento SSH — direto ao ponto​

Documento curto e prático sobre tunelamento (port forwarding) com SSH: o quê, quando usar, comandos essenciais, exemplos, segurança e checagem.

Conceito rápido​

Tunelamento SSH encapsula tráfego TCP (ou atua como proxy SOCKS) dentro de uma conexão SSH criptografada. Três tipos principais:

  • Local (L): encaminha uma porta da sua máquina local para um serviço acessível pelo servidor SSH.
  • Remoto (R) / reverso: expõe uma porta do servidor SSH para um serviço na sua máquina local (útil para atravessar NAT).
  • Dinâmico (D): cria um proxy SOCKS (proxy dinâmico) que roteia múltiplas conexões através do SSH.

Sintaxe básica (OpenSSH)​

  • Local: ssh -L [bind_address:]local_port:dest_host:dest_port user@ssh_server

  • Remoto: ssh -R [bind_address:]remote_port:dest_host:dest_port user@ssh_server

  • Dinâmico (SOCKS): ssh -D [bind_address:]local_port user@ssh_server

  • Flags comuns:

    • -N — não executa shell/remote command (só forward).
    • -f — coloca em background (use com -N).
    • -C — compressão.
    • -g — permite conexões remotas à porta ligada localmente.
    • -p PORT — porta do servidor SSH.
    • -i /caminho/key — chave privada.

Exemplo rápido:

# Encaminhar 8080 local -> destino interno 10.0.0.5:80 via ssh.example.com
ssh -L 8080:10.0.0.5:80 user@ssh.example.com -N -f

Exemplos práticos​

1) Acessar serviço interno da rede do servidor​

Usuário local quer ver http://10.0.0.5:80 (inacessível diretamente):

ssh -L 8080:10.0.0.5:80 user@ssh.example.com -N -f
# No navegador: http://localhost:8080

2) Reverse tunnel — expor serviço local atrás de NAT​

Servidor público ssh.example.com recebe conexões à porta 2222 e as encaminha para máquina local (útil para suporte/remoto):

ssh -R 2222:localhost:22 user@ssh.example.com -N -f
# Agora, no servidor público: ssh -p 2222 localhost  -> acessa sua máquina local

Se quiser que qualquer host acesse a porta remota, no servidor SSH sshd_config habilite GatewayPorts yes (mais abaixo).

3) Proxy SOCKS (navegar via outro servidor)​

ssh -D 1080 user@ssh.example.com -N -f
# Configure navegador para usar SOCKS5 localhost:1080

4) Encaminhar porta com bind em endereço específico​

Bind em 0.0.0.0 para aceitar conexões externas:

ssh -L 0.0.0.0:8080:10.0.0.5:80 user@ssh.example.com -N -f
# Requer -g para permitir conexões externas em algumas versões

PuTTY (Windows) — resumo rápido​

  • Sessão → HostName/Port

  • Connection → SSH → Tunnels:

    • Source port = local port (ex: 8080)
    • Destination = dest_host:dest_port (ex: 10.0.0.5:80)
    • Local / Remote / Dynamic → escolher
    • Add → Open

Configurações úteis em ~/.ssh/config​

Host ssh-tunel
  HostName ssh.example.com
  User user
  IdentityFile ~/.ssh/id_ed25519
  LocalForward 8080 10.0.0.5:80
  RemoteForward 2222 localhost:22
  ServerAliveInterval 30
  ServerAliveCountMax 3

Inicie com ssh -f -N ssh-tunel ou apenas ssh ssh-tunel se preferir.

Requisitos no servidor (sshd_config)​

  • AllowTcpForwarding yes — permite forwarding (padrão é yes em muitos sistemas).
  • GatewayPorts yes — para permitir que portas remotas sejam acessíveis externamente (cuidado).
  • Reinicie/recicle sshd após mudanças.

Segurança — pontos críticos​

  • Prefira autenticação por chave (sem senha) e use passphrase na chave.
  • Restrinja quem pode tunelar no servidor (AllowTcpForwarding no por padrão e use Match blocks se necessário).
  • Evite abrir GatewayPorts yes sem controle: expõe serviços para internet.
  • Monitore logs (/var/log/auth.log ou journalctl -u sshd) para conexões inesperadas.
  • Use tcpwrappers/firewall (ufw/iptables/nft) para controlar acesso às portas expostas.
  • Cuidado com proxying de tráfego sensível sem inspeção.

Testes e verificação​

  • Checar portas: ss -tunlp | grep :8080 ou netstat -tulpn

  • Testar encaminhamento HTTP:

    • curl --socks5 localhost:1080 http://ifconfig.me (para SOCKS)
    • curl http://localhost:8080 (para L)

  • Ver conexões SSH ativas: ps aux | grep ssh ou ssh -G host (para debug de config).

  • Debug do SSH: ssh -vvv -L 8080:10.0.0.5:80 user@ssh.example.com

Automação / persistência​

  • Use autossh para manter túnel persistente (reconecta automaticamente):
autossh -M 0 -f -N -L 8080:10.0.0.5:80 user@ssh.example.com
  • Para iniciar no boot, crie systemd unit simples que execute autossh ou comando ssh -f -N ....

Troubleshooting rápido​

  • Conexão cai: habilite ServerAliveInterval 30 no cliente; ClientAliveInterval no servidor.
  • Porta já em uso: escolha outra porta local; verifique com ss.
  • Forwarding negado: verifique AllowTcpForwarding no servidor e política do account (Match blocks, ForceCommand).
  • Reverse não acessível externamente: verifique GatewayPorts, firewall do servidor e binding (0.0.0.0 vs localhost).

Casos de uso típicos (resumido)​

  • Acesso a serviços internos (banco de dados, painéis) sem VPN.
  • Acesso remoto a máquina atrás de NAT (reverse tunnel).
  • Navegação segura em Wi‑Fi pública (SOCKS).
  • Tunelamento de um serviço específico sem expor porta pública.

Resumo final (comandos essenciais)​

# Local forward
ssh -L 8080:10.0.0.5:80 user@ssh.example.com -N -f

# Remote (reverse) forward
ssh -R 2222:localhost:22 user@ssh.example.com -N -f

# Dynamic SOCKS proxy
ssh -D 1080 user@ssh.example.com -N -f

# Keep-alive + key
ssh -i ~/.ssh/id_ed25519 -o ServerAliveInterval=30 -L 8080:10.0.0.5:80 user@ssh.example.com -N -f