Liste offener SSH-Tunnel

Ich benutze viele SSH-Tunnel zu verschiedenen Servern auf meinem Linux-Rechner (zum Tunneln zu Datenbanken, Webservern usw.) und es wäre sehr praktisch, eine Liste der aktuellen offenen Tunnel über ein Shell-Skript anzuzeigen.

Ich kann lokale Verbindungen über ein grep auf netstat identifizieren, und zwar wie folgt:

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

Dies zeigt mir jedoch nicht, mit welchem ​​Remote-Port er verbunden ist (und enthält offensichtlich Standard-SSH-Verbindungen, die nicht getunnelt sind).

UPDATE : Die Antworten sind in Ordnung, zeigen mir jedoch nicht den Remote-Port, mit dem ich verbunden bin. ZB habe ich oft einen Tunnel durch zu MySQL, sagen wir localhost: 3308 Mapping zu: 3306 auf dem Server. Normalerweise kann ich anhand der von mir ausgewählten lokalen Ports raten, wäre aber nett, Zugang zu beiden zu haben.

Irgendwelche Ideen?

wenn Sie nur Tunnel auflisten möchten, die erstellt wurden von 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)

(das wäre ein -L 9090: localhost: 80 tunnel)

Wenn Sie die Tunnel / Verbindungen zu einem sehen möchten 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)

der ssh-daemon lauscht auf port 22 (letzte zeile), es werden 2 subprozesse erzeugt (erste 2 zeilen, login von 'user'), ein -R tunnel auf port 5000 erstellt und ein -L tunnel, der einen port von my ( local) machine to localhost: 80 (www).

Versuchen Sie diesen Befehl, es könnte nützlich sein:

ps aux | grep ssh

Nicht gerade die Lösung für Ihr Problem, aber manchmal auch praktisch:

Aus einer SSH-Sitzung heraus:

1. Drücken Sie Enter
2. tippe ~ und dann #

zeigt Ihnen eine Liste aller offenen Verbindungen über Ihre Tunnel für diese Sitzung.

netstat -tpln | grep ssh

• t: TCP
• p: zeige Prozess
• l: zuhören
• n: numerische Werte

BEARBEITEN: Beispiel für @akira Kommentar:

(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        

Dies kann wie folgt gelesen werden: SSH (nicht SSHd) überwacht den lokalen TCP-Port 1443.

Dies ist das Top-Google-Ergebnis für diese Frage. Ich werde meine Antwort hier einfügen. Ich bin die ganze Nacht wach geblieben, um die Ergebnisse zu filtern, und habe einen langen, komplexen Befehl gefunden, der Ihnen nur Ihre Reverse-SSH-Tunnel in diesem Format anzeigt:

publicipaddress: remoteforwardedport

Hier ist der Code: Ich verwende Ubuntu Server 12. Ich verwende Reverse-SSH-Tunnel, die den lokalen Port 5900 an meinen öffentlichen SSH-Server weiterleiten, und dieser raffinierte Befehl zeigt alle meine öffentlichen IP-Adressen mit dem Remote-Port an.

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

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

Beispielausgabe:

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

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

#! / bin / csh -f
Echo SSH-Tunnel verbunden
Echo
foreach f (`netstat -an -p | grep tcp | grep sshd | grep -v :: | grep -v 0:22 | grep LISTEN | cut -d" "-f45- | cut -d" / "-f1` )
setze 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 | schneiden Sie -d "" -f2` aus
echo -n "$ ip"
echo `netstat -an -p | grep tcp | grep sshd | grep -v :: | grep -v 0:22 | grep LISTEN | grep $ f | cut -d ":" -f2 | schneiden Sie -d "" -f1` aus
#echo "$ h"
Ende

Da ich lsof nicht mag, schlage ich eine alternative Methode vor (ein anderer Typ hat es mir beigebracht :)):

$ netstat -l | grep ssh

Auf diese Weise zeigen Sie die von Ihnen erstellten SSH-Tunnel an ssh, die im LISTEN-Modus geöffnet sind (und standardmäßig weggelassen werden netstat).