Listar túneis SSH abertos

Eu uso muitos túneis SSH para vários servidores na minha máquina linux (para tunelamento de bancos de dados, servidores web etc.) e seria realmente útil exibir uma lista dos túneis abertos atuais por meio de um script de shell.

Posso identificar conexões locais por meio de um grep no netstat ao longo das linhas de:

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

mas isso não me mostrará a porta remota à qual está conectada (e obviamente inclui conexões SSH padrão que não são tuneladas)

ATUALIZAÇÃO : As respostas são boas, mas não estão me mostrando a porta remota à qual estou conectado. Por exemplo, geralmente tenho um túnel para o mysql, digamos localhost: 3308 mapeando para: 3306 no servidor. Normalmente, posso adivinhar pelas portas locais que escolhi, mas seria bom ter acesso a ambas.

Alguma ideia?

se você deseja apenas listar túneis criados por 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)

(isso seria um túnel -L 9090: localhost: 80)

se você quiser ver os túneis / conexões feitos para 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)

o ssh-daemon escuta na porta 22 (última linha), são gerados 2 subprocessos (primeiras 2 linhas, logon do 'usuário'), um túnel -R criado na porta 5000 e um túnel -L que encaminha uma porta do meu ( local) para localhost: 80 (www).

Experimente este comando, pode ser útil:

ps aux | grep ssh

não é exatamente a solução para o seu problema, mas também é útil algumas vezes:

De dentro de uma sessão ssh:

1. pressione Enter
2. digite ~ e depois #

mostra uma lista de todas as conexões abertas nos seus túneis para essa sessão.

netstat -tpln | grep ssh

• t: TCP
• processo p: show
• l: ouvindo
• n: valores numéricos

EDIT: exemplo para o comentário @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        

Que pode ser lido como: SSH (não SSHd) está escutando a porta TCP local 1443.

Este é o principal resultado do Google para esta pergunta, então colocarei minha resposta aqui. Fiquei acordado a noite toda filtrando os resultados e criei um comando longo e complexo que mostra apenas seus túneis ssh reversos neste formato:

publicipaddress: remoteforwardedport

Aqui está o código, estou executando o Ubuntu Server 12. Estou executando túneis ssh reversos que encaminham a porta local 5900 para meu servidor público ssh, e este comando bacana mostra todos os meus endereços IP públicos com a porta remota.

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

Saída de amostra:

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
eco SSH Tunnels Connected
eco
foreach f (`netstat -an -p | grep tcp | grep sshd | grep -v :: | grep -v 0:22 | grep LISTEN | cut -d" "-f45- | cut -d" / "-f1` )
configure ip = `netstat -an -p | grep tcp | grep sshd | grep -v :: | grep -v 0:22 | grep ESTABELECER | grep $ f | cortar -d "" -f20- | cut -d ":" -f1`
#set h = `grep -a" $ ip "/htdocs/impsip.html | grep br | cut -d "" -f2`
eco -n "$ ip"
echo `netstat -an -p | grep tcp | grep sshd | grep -v :: | grep -v 0:22 | grep ESCUTE | grep $ f | cut -d ":" -f2 | cut -d "" -f1`
#echo "$ h"
fim

Como não gosto de lsof, sugiro um método alternativo (outro cara me ensinou :)):

$ netstat -l | grep ssh

Dessa forma, você mostra os túneis ssh criados por sshque são abertos no modo LISTEN (e são omitidos por padrão por netstat).