ssh -L encaminha várias portas

Atualmente, estou executando um monte de:

sudo ssh -L PORT:IP:PORT root@IP

em que IP é o destino de uma máquina protegida e PORT representa as portas que estou encaminhando.

Isso ocorre porque eu uso muitos aplicativos que não consigo acessar sem esse encaminhamento. Depois de fazer isso, posso acessar o localhost:PORT.

O principal problema ocorreu agora que na verdade tenho 4 dessas portas que devo encaminhar.

Minha solução é abrir 4 shells e constantemente pesquisar meu histórico para trás para procurar exatamente quais portas precisam ser encaminhadas, etc, e então executar este comando - um em cada shell (tendo que preencher as senhas etc).

Se eu pudesse fazer algo como:

sudo ssh -L PORT1+PORT2+PORT+3:IP:PORT+PORT2+PORT3 root@IP

então isso já ajudaria muito.

Existe uma maneira de tornar mais fácil fazer isso?

A -Lopção pode ser especificada várias vezes no mesmo comando. Cada vez com portas diferentes.

Exatamente o que NaN respondeu, você especifica vários argumentos -L. Eu faço isso toda hora. Aqui está um exemplo de encaminhamento de várias portas:

ssh remote-host -L 8822:REMOTE_IP_1:22 -L 9922:REMOTE_IP_2:22

Observação : é o mesmo que -L localhost:8822:REMOTE_IP_1:22se você não especificar localhost.

Agora, com isso, você pode agora (de outro terminal) fazer:

ssh localhost -p 8822

para conectar REMOTE_IP_1na porta22

e similarmente

ssh localhost -p 9922

para conectar REMOTE_IP_2na porta22

Claro, não há nada que o impeça de embrulhar isso em um script ou automatizá-lo se você tiver muitos hosts / portas diferentes para encaminhar e para alguns específicos.

Espero que isto ajude.

Você pode usar a seguinte função bash (basta adicioná-la ao seu ~/.bashrc):

function pfwd {
  for i in ${@:2}
  do
    echo Forwarding port $i
    ssh -N -L $i:localhost:$i $1 &
  done  
}

Exemplo de uso:

pfwd hostname {6000..6009}

Para as pessoas que estão encaminhando várias portas através do mesmo host podem configurar algo assim em seu ~ / .ssh / config

Host all-port-forwards Hostname 10.122.0.3 User username LocalForward PORT_1 IP:PORT_1 LocalForward PORT_2 IP:PORT_2 LocalForward PORT_3 IP:PORT_3 LocalForward PORT_4 IP:PORT_4

e se torna um simples ssh all-port-forwardsafastamento.

jbchichoko e yuval deram soluções viáveis. Mas a resposta de jbchichoko não é uma resposta flexível como uma função, e os túneis abertos pela resposta de yuval não podem ser fechados ctrl+cporque ele funciona em segundo plano. Dou minha solução abaixo, resolvendo as duas falhas:

Definindo uma função em ~/.bashrcou~/.zshrc :

# fsshmap multiple ports
function fsshmap() {
  echo -n "-L 1$1:127.0.0.1:$1 " > $HOME/sh/sshports.txt
  for ((i=($1+1);i<$2;i++))
  do
    echo -n "-L 1$i:127.0.0.1:$i " >> $HOME/sh/sshports.txt
  done
  line=$(head -n 1 $HOME/sh/sshports.txt)
  cline="ssh "$3" "$line
  echo $cline
  eval $cline
}

Um exemplo de execução da função:

fsshmap 6000 6010 hostname

Resultado deste exemplo:

Você pode acessar 127.0.0.1:16000~16009o mesmo quehostname:6000~6009

Um dos benefícios de fazer login em um servidor com encaminhamento de porta é facilitar o uso do Jupyter Notebook. Este link fornece uma excelente descrição de como fazer isso. Aqui eu gostaria de fazer um resumo e uma expansão para todos vocês referirem.

Situação 1. Efetue login de uma máquina local chamada Host-A (por exemplo, seu próprio laptop) para uma máquina de trabalho remota chamada Host-B.

ssh user@Host-B -L port_A:localhost:port_B
jupyter notebook --NotebookApp.token='' --no-browser --port=port_B

Em seguida, você pode abrir um navegador e inserir: http: // localhost: port_A / para fazer seu trabalho no Host-B, mas vê-lo no Host-A.

Situação 2. Faça login de uma máquina local chamada Host-A (por exemplo, seu próprio laptop) para uma máquina de login remota chamada Host-B e, a partir daí, faça login na máquina de trabalho remota chamada Host-C. Esse é geralmente o caso da maioria dos servidores analíticos dentro das universidades e pode ser obtido usando dois ssh -Lconectados com -t.

ssh -L port_A:localhost:port_B user@Host-B -t ssh -L port_B:localhost:port_C user@Host-C
jupyter notebook --NotebookApp.token='' --no-browser --port=port_C

Em seguida, você pode abrir um navegador e inserir: http: // localhost: port_A / para fazer seu trabalho no Host-C, mas vê-lo no Host-A.

Situação 3. Faça login de uma máquina local chamada Host-A (por exemplo, seu próprio laptop) em uma máquina de login remota chamada Host-B e, a partir daí, faça login na máquina de trabalho remota chamada Host-C e, finalmente, faça o login na máquina de trabalho remota Host- D. Normalmente não é esse o caso, mas pode acontecer algum dia. É uma extensão da Situação 2 e a mesma lógica pode ser aplicada em mais máquinas.

ssh -L port_A:localhost:port_B user@Host-B -t ssh -L port_B:localhost:port_C user@Host-C -t ssh -L port_C:localhost:port_D user@Host-D
jupyter notebook --NotebookApp.token='' --no-browser --port=port_D

Em seguida, você pode abrir um navegador e inserir: http: // localhost: port_A / para fazer seu trabalho no Host-D, mas vê-lo no Host-A.

Observe que port_A, port_B, port_C, port_D podem ser números aleatórios, exceto os números de porta comuns listados aqui . Na Situação 1, port_A e port_B podem ser iguais para simplificar o procedimento.

Na minha empresa, eu e os membros da minha equipe precisamos acessar 3 portas de um servidor "alvo" não alcançável, então criei um túnel permanente (que é um túnel que pode ser executado em segundo plano indefinidamente, consulte parâmetros -fe -N) de um servidor alcançável para o alvo. Na linha de comando do servidor alcançável, executei:

ssh root@reachableIP -f -N  -L *:8822:targetIP:22  -L *:9006:targetIP:9006  -L *:9100:targetIP:9100

Usei usuário, rootmas seu próprio usuário funcionará. Você terá que inserir a senha do usuário escolhido (mesmo se já estiver conectado ao servidor alcançável com esse usuário).

Agora a porta 8822 da máquina alcançável corresponde à porta 22 da máquina de destino (para ssh / PuTTY / WinSCP) e as portas 9006 e 9100 na máquina alcançável correspondem às mesmas portas da máquina de destino (elas hospedam dois serviços da web no meu caso )

Desenvolvi o loco para obter ajuda com o encaminhamento de ssh. Ele pode ser usado para compartilhar as portas 5000 e 7000 no local remoto nas mesmas portas:

pip install loco

loco listen SSHINFO -r 5000 -r 7000

Se você quiser uma solução simples que rode em segundo plano e seja fácil de eliminar - use um soquete de controle

# start
$ ssh -f -N -M -S $SOCKET -L localhost:9200:localhost:9200 $HOST
# stop
$ ssh -S $SOCKET -O exit $HOST

Aqui está uma solução inspirada na de Yuval Atzmon.

Tem alguns benefícios em relação à solução inicial:

• primeiro, ele cria um único processo em segundo plano e não um por porta
• ele gera o alias que permite que você mate seus túneis
• ele se liga apenas a 127.0.0.1 que é um pouco mais seguro

Você pode usá-lo como:

• tnl your.remote.com 1234
• tnl your.remote.com {1234,1235}
• tnl your.remote.com {1234..1236}

E, finalmente, mate todos eles com tnlkill.

function tnl {
  TUNNEL="ssh -N "
  echo Port forwarding for ports:
  for i in ${@:2}
  do
    echo " - $i"
    TUNNEL="$TUNNEL -L 127.0.0.1:$i:localhost:$i"
  done
  TUNNEL="$TUNNEL $1"
  $TUNNEL &
  PID=$!
  alias tnlkill="kill $PID && unalias tnlkill"
}

Você pode usar esta função zsh (provavelmente funciona com bash também) (colocá-la ~/.zshrc):

ashL () {
    local a=() i
    for i in "$@[2,-1]"
    do
        a+=(-L "${i}:localhost:${i}")
    done
    autossh -M 0 -o "ServerAliveInterval 30" -o "ServerAliveCountMax 3" -NT "$1" "$a[@]"
}

Exemplos:

ashL [email protected] 6480 7690 7477

ashL [email protected] {6000..6050} # Forwards the whole range. This is simply shell syntax sugar.