Liste des tunnels SSH ouverts


68

J'utilise beaucoup de tunnels SSH vers différents serveurs sur ma machine Linux (pour la tunnelisation de bases de données, de serveurs Web, etc.) et il serait très pratique d'afficher une liste des tunnels ouverts en cours via un script shell.

Je peux identifier les connexions locales via un grep sur netstat du type:

netstat -n --protocol inet | grep ':22'

mais cela ne me montrera pas le port distant auquel elle est connectée (et inclut évidemment les connexions SSH standard non tunnellées)

UPDATE : Les réponses sont correctes mais ne me montrent pas le port distant auquel je suis connecté. Par exemple, j'ai souvent un tunnel menant à mysql, disons localhost: 3308 en correspondance avec: 3306 sur le serveur. Normalement, je peux deviner par les ports locaux que j'ai choisis, mais ce serait bien d'avoir accès aux deux.

Des idées?


4
J'ai récemment vu quelques questions comme celle-ci (pas précisément ce que vous demandez), mais plutôt sur le fait que ssh fournisse des informations sur la connexion. Aussi cool que soit SSH, il est vraiment incapable de fournir des informations de base utiles comme ça. Certaines commandes internes du client peuvent être exécutées, telles que <ret> <ret> ~ # et la variable d'environnement $ SSH_CONNECTION, mais elles sont vraiment fragmentaires en détails. Une liste de tunnels en cours d'exécution serait bien. Peut-être que son heure pour une demande de fonctionnalité.
Deltaray

Réponses:


73

si vous voulez seulement lister les tunnels créés par ssh:

% sudo lsof -i -n | egrep '\<ssh\>'
ssh  19749  user  3u  IPv4 148088244   TCP x.x.x.x:39689->y.y.y.y:22 (ESTABLISHED)
ssh  19749  user  4u  IPv6 148088282   TCP [::1]:9090 (LISTEN)
ssh  19749  user  5u  IPv4 148088283   TCP 127.0.0.1:9090 (LISTEN)

(ce serait un -L 9090: localhost: 80 tunnel)

si vous voulez voir les tunnels / connexions faites à un sshd:

 % sudo lsof -i -n | egrep '\<sshd\>'
sshd  15767  root  3u  IPv4 147401205   TCP x.x.x.x:22->y.y.y.y:27479 (ESTABLISHED)
sshd  15842  user  3u  IPv4 147401205   TCP x.x.x.x:22->y.y.y.y:27479 (ESTABLISHED)
sshd  15842  user  9u  IPv4 148002889   TCP 127.0.0.1:33999->127.0.0.1:www (ESTABLISHED)
sshd  1396   user  9u  IPv4 148056581   TCP 127.0.0.1:5000 (LISTEN)
sshd  25936  root  3u  IPv4 143971728   TCP *:22 (LISTEN)

le démon ssh écoute sur le port 22 (dernière ligne), 2 sous-processus sont générés (les 2 premières lignes, login de 'utilisateur'), ​​un tunnel -R créé sur le port 5000 et un tunnel -L qui transfère un port de my ( local) machine à localhost: 80 (www).


La 3ème ligne est uniquement là car le socket TCP est utilisé. Il indique simplement que quelque chose dans un tunnel ssh a touché votre serveur Web local, mais pas que le port 33999 est transféré vers le port 80.
shellholic

C’est l’essence d’un -L tunnel ...
mercredi

C'est bien, il affiche l'adresse IP distante et la liste des ports tunnellisés. Ce que je souhaite idéalement savoir, c’est à quoi le port distant est destiné. Par exemple, si un tunnel est ouvert de 3308 localement à 3306 sur le serveur, je souhaite voir les deux.
James Frost

pour cela, vous devez soit vous connecter au serveur et exécuter le lsof (fiable) lié à sshd, soit analyser la sortie de / proc / PID / cmdline pour toutes vos commandes ssh .. ce qui pourrait vous donner des résultats trompeurs pouvez spécifier des tunnels via .ssh / config.
Akira

Oui, cela a du sens. Il faut être un peu plus intelligent avec le script, puis analyser les résultats, obtenir une liste des serveurs distants et exécuter la même commande sur chacun d'eux pour récupérer les ports distants. Certainement faisable. Va y aller!
James Frost


16

pas exactement la solution à votre problème, mais aussi pratique parfois:

Depuis une session SSH:

  1. appuyez sur Entrée
  2. tapez ~ puis #

vous montre une liste de toutes les connexions ouvertes sur vos tunnels pour cette session.


2
Cela ne fonctionne que pour les tunnels interactifs (sans -N et -f,…), mais intéressant à connaître.
erik

6
netstat -tpln | grep ssh
  • t: TCP
  • p: montrer le processus
  • l: écoute
  • n: valeurs numériques

EDIT: exemple pour le commentaire @akira:

(header added, tested on Debian wheezy)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 127.0.0.1:1443          0.0.0.0:*               LISTEN      4036/ssh        

Ce qui peut être lu comme suit: SSH (pas SSHd) écoute le port TCP local 1443.


Notez également que -pne montre que vos propres processus (tous les processus par root). En outre, cette commande montre sshdaussi.
Olli

pour les tunnels que vous devez éviter-l
akira

Vous ne pouvez pas voir localement les -Rtunnels s’ils ne sont pas utilisés. Mais bon, si vous les utilisez, vous pouvez les attraper sans les-l
shellholic le

5

Ceci est le meilleur résultat de Google pour cette question, je vais donc mettre ma réponse ici. Je suis resté éveillé toute la nuit à filtrer les résultats et à proposer une longue commande complexe qui vous montre uniquement vos tunnels ssh inversés dans ce format:

publicipaddress: remoteforwardedport

Voici le code. J'utilise Ubuntu Server 12. J'utilise des tunnels SSH inversés qui transmettent le port local 5900 à mon serveur SSH public, et cette commande astucieuse affiche toutes mes adresses IP publiques avec le port distant.

sudo lsof -i -n | egrep '\<sshd\>' | grep -v ":ssh" | grep LISTEN | sed 1~2d | awk '{ print $2}' | while read line; do sudo lsof -i -n | egrep $line | sed 3~3d | sed 's/.*->//' | sed 's/:......*(ESTABLISHED)//' | sed 's/.*://' | sed 's/(.*//' | sed 'N;s/\n/:/' 2>&1 ;done

2
report_local_port_forwardings() {

  # -a ands the selection criteria (default is or)
  # -i4 limits to ipv4 internet files
  # -P inhibits the conversion of port numbers to port names
  # -c /regex/ limits to commands matching the regex
  # -u$USER limits to processes owned by $USER
  # http://man7.org/linux/man-pages/man8/lsof.8.html
  # https://stackoverflow.com/q/34032299

  echo 
  echo "LOCAL PORT FORWARDING"
  echo
  echo "You set up the following local port forwardings:"
  echo

  lsof -a -i4 -P -c '/^ssh$/' -u$USER -s TCP:LISTEN

  echo
  echo "The processes that set up these forwardings are:"
  echo

  ps -f -p $(lsof -t -a -i4 -P -c '/^ssh$/' -u$USER -s TCP:LISTEN)

}

report_remote_port_forwardings() {

  echo 
  echo "REMOTE PORT FORWARDING"
  echo
  echo "You set up the following remote port forwardings:"
  echo

  ps -f -p $(lsof -t -a -i -c '/^ssh$/' -u$USER -s TCP:ESTABLISHED) | awk '
  NR == 1 || /R (\S+:)?[[:digit:]]+:\S+:[[:digit:]]+.*/
  '
}

report_local_port_forwardings
report_remote_port_forwardings

Exemple de sortie:

LOCAL PORT FORWARDING

You set up the following local port forwardings:

COMMAND   PID  USER   FD   TYPE  DEVICE SIZE/OFF NODE NAME
ssh     10086 user     7u  IPv4 1924960      0t0  TCP localhost:2301 (LISTEN)
ssh     10086 user     9u  IPv4 1924964      0t0  TCP localhost:2380 (LISTEN)
ssh     10086 user    11u  IPv4 1924968      0t0  TCP localhost:2381 (LISTEN)

The processes that set up these forwardings are:

UID        PID  PPID  C STIME TTY          TIME CMD
user     10086  7074  0 13:05 pts/21   00:00:00 ssh -N ssh.example.com

REMOTE PORT FORWARDING

You set up the following remote port forwardings:

UID        PID  PPID  C STIME TTY      STAT   TIME CMD
user      7570 30953  0 11:14 pts/18   S      0:00 ssh -N -R 9000:localhost:3000 ssh.example.com

0
/sbin/ip tunnel list # replacement for the deprecated iptunnel command

0
#! / bin / csh -f
echo tunnels SSH connectés
écho
foreach f (`netstat -an -p | grep tcp | grep sshd | grep -v :: | grep -v 0:22 | grep LISTEN | cut -d" "-f45- | cut -d" / "-f1` )
set ip = `netstat -an -p | grep tcp | grep sshd | grep -v :: | grep -v 0:22 | grep ESTABLISH | grep $ f | cut -d "" -f20- | cut -d ":" -f1`
#set h = `grep -a" $ ip "/htdocs/impsip.html | grep br | cut -d "" -f2`
echo -n "$ ip"
echo `netstat -an -p | grep tcp | grep sshd | grep -v :: | grep -v 0:22 | grep LISTEN | grep $ f | cut -d ":" -f2 | cut -d "" -f1`
#echo "$ h"
fin

0

Comme je n'aime pas lsof, je suggère une méthode alternative (un autre gars m'a appris :)):

$ netstat -l | grep ssh

De cette façon, vous montrez que les tunnels SSH créés par sshsont ouverts en mode LISTEN (et sont omis par défaut par netstat).

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.