Lista de túneles SSH abiertos

68

Utilizo muchos túneles SSH a varios servidores en mi máquina Linux (para hacer túneles a bases de datos, servidores web, etc.) y sería realmente útil ver una lista de túneles abiertos actuales a través de un script de shell.

Puedo identificar conexiones locales a través de un grep en netstat a lo largo de las líneas de:

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

pero esto no me mostrará el puerto remoto al que está conectado (y obviamente incluye conexiones SSH estándar que no están en túnel)

ACTUALIZACIÓN : Las respuestas están bien, pero no me muestran el puerto remoto al que estoy conectado. Por ejemplo, a menudo tengo un túnel a través de mysql, digamos localhost: 3308 mapeado a: 3306 en el servidor. Normalmente puedo adivinar por los puertos locales que he elegido, pero sería bueno tener acceso a ambos.

¿Algunas ideas?

James Frost
fuente
44
He visto un par de preguntas como esta recientemente (no específicamente lo que está preguntando), pero relacionadas con ssh que proporciona información sobre la conexión. A pesar de lo genial que es ssh, es una mierda proporcionar información útil básica como esa. Hay algunos comandos internos del cliente que puede ejecutar como <ret> <ret> ~ # y la variable de entorno $ SSH_CONNECTION, pero realmente son escasos en detalles. Una lista de túneles en funcionamiento estaría bien. Tal vez es hora de una solicitud de función.
deltaray

Respuestas:

73

si solo desea enumerar túneles creados 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)

(eso sería un -L 9090: localhost: túnel 80)

si desea ver los túneles / conexiones realizadas a 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)

el ssh-daemon escucha en el puerto 22 (última línea), se generan 2 subprocesos (primeras 2 líneas, inicio de sesión de 'usuario'), un túnel -R creado en el puerto 5000 y un túnel -L que reenvía un puerto desde mi ( máquina local) a localhost: 80 (www).

akira
fuente
La tercera línea solo está allí porque el socket TCP está en uso. Simplemente dice que algo a través de un túnel ssh ha afectado a su servidor web local, no es que el puerto 33999 se reenvíe al 80.
shellholic
esa es la esencia de un túnel -L ...
akira
Está bien, muestra la dirección IP remota y la lista de puertos tunelizados. Lo que idealmente quiero saber es a qué se dirige el puerto remoto. Por ejemplo, si tengo un túnel abierto de 3308 localmente a 3306 en el servidor, quiero ver ambos.
James Frost
para eso tendrías que iniciar sesión en el servidor y ejecutar el lsof allí relacionado con sshd (confiable) o analizar la salida de / proc / PID / cmdline para todos tus comandos ssh ... lo que podría darte resultados engañosos ya que también puede especificar túneles a través de .ssh / config.
akira
Sí, tiene sentido. Debe ser un poco más inteligente con el script para luego analizar los resultados, obtener una lista de servidores remotos y ejecutar el mismo comando en cada uno para recuperar los puertos remotos. Definitivamente factible. ¡Lo conseguiré!
James Frost
16

Pruebe este comando, puede ser útil:

ps aux | grep ssh
Rajesh
fuente
mi sugerencia sería: ps aux | grep [s] shd
CousinCocaine
16

no es exactamente la solución para su problema, pero a veces también es útil:

Desde una sesión ssh:

  1. presione enter
  2. escriba ~ y luego #

le muestra una lista de todas las conexiones abiertas sobre sus túneles para esa sesión.

reto
fuente
2
Eso funciona solo para túneles interactivos (sin -N y -f, ...), pero es interesante saberlo.
erik
6
netstat -tpln | grep ssh
  • t: TCP
  • p: mostrar proceso
  • l: escuchando
  • n: valores numéricos

EDITAR: ejemplo para el comentario de @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 se puede leer como: SSH (no SSHd) está escuchando el puerto TCP local 1443.

concha
fuente
También tenga en cuenta que -pmuestra solo sus propios procesos (todos los procesos por raíz). Además, ese comando sshdtambién se muestra .
Olli
para -R túneles que debes evitar-l
akira
No puede ver localmente los -Rtúneles si no está en uso. Pero bien, si está en uso, se puede tomar sin el-l
shellholic
5

Este es el principal resultado de Google para esta pregunta, por lo que pondré mi respuesta aquí. Me quedé despierto toda la noche filtrando los resultados y se me ocurrió un comando largo y complejo que solo muestra los túneles ssh inversos en este formato:

publicipaddress: remoteforwardport

Aquí está el código, estoy ejecutando Ubuntu Server 12. Estoy ejecutando túneles ssh inversos que reenvían el puerto local 5900 a mi servidor ssh público, y este comando ingenioso muestra todas mis direcciones IP públicas con el puerto remoto.

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
Brandon
fuente
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

Salida de muestra:

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
Robin A. Meade
fuente
0
/sbin/ip tunnel list # replacement for the deprecated iptunnel command
Lucas Cimon
fuente
0
#! / bin / csh -f
echo Túneles SSH conectados
eco
foreach f (`netstat -an -p | grep tcp | grep sshd | grep -v :: | grep -v 0:22 | grep ESCUCHAR | cortar -d" "-f45- | cortar -d" / "-f1` )
establecer ip = `netstat -an -p | grep tcp | grep sshd | grep -v :: | grep -v 0:22 | grep ESTABLECER | grep $ f | cortar -d "" -f20- | corte -d ":" -f1`
#set h = `grep -a" $ ip "/htdocs/impsip.html | grep br | corte -d "" -f2`
echo -n "$ ip"
echo `netstat -an -p | grep tcp | grep sshd | grep -v :: | grep -v 0:22 | grep ESCUCHAR | grep $ f | corte -d ":" -f2 | corte -d "" -f1`
#echo "$ h"
fin
Ricardo
fuente
0

Como no me gusta lsof, sugiero un método alternativo (otro chico me enseñó :)):

$ netstat -l | grep ssh

De esta manera, muestra los túneles ssh creados por ellos sshque se abren en el modo ESCUCHAR (y se omiten de forma predeterminada netstat).

FSp
fuente