Hola, supongo que todos conoceréis la capacidad de SSH para hacer túneles [1]. En definitiva es un mecanismo para establecer conexiones TCP seguras entre dos puntos, pudiendo ser de tres tipos: reenvío de puertos locales al servidor (-R
), reenvío de puertos del servidor al sistema local (-L
), y dinámico (-D
).
Dependiendo del caso puede interesar usar uno u otro, por ejemplo:
1- Nos puede interesar traernos el puerto 443 de un servidor A a nuestro sistema local B (que no tiene acceso al servidor A) como puerto 8443 utilizando un sistema intermedio C al que tenemos acceso SSH (que también tiene acceso al servidor A), ejecutando desde B:
# A(443) --> C -[CF]-> B(8443 = A(443))
ssh -vvv -NL 8443:A:443 usuario@C
2- Puede se necesario publicar el puerto 8080 del sistema local A en otro sistema B como puerto 80, que quizá permita acceso a otros sistemas, ejecutando desde A:
# A(8080) -[CF]-> B(80 = A(8080))
ssh -vvv -NR 80:localhost:8080 usuario@B
3- Publicar en un sistema A el puerto 25 del sistema B realizando esta publicando mediante un sistema C, ejecutando desde C:
# A(25 = B(25)) <-[CF]- C <-- B(25)
ssh -vvv -NR 25:B:25 usuario@A
4- Acceder desde un sistema C a cualquier otro sistema de la red privada a la que pertenece un sistema A utilizando como nodo intermedio un sistema público B.
# [A(RP)] -- A(22) -[FW]-> B(8022 = A(22)) -- [I] -- C
Para ello desde A hay que publicar su puerto SSH (22) en el sistema B (pongamos que como puerto 8022) ejecutando en A:
ssh -vvv -NR 8022:localhost:22 usuario@B
Y desde el sistema C creamos un proxy SOCKS [2] para túnel dinámico a través del puerto 8022 del sistema B, ejecutando desde C:
ssh -vvv -NL 8022:localhost:8022 usuario@B
ssh -vvv -p 8022 -ND localhost:8033 usuario@localhost
Esto crearía un proxy SOCKS en el puerto 8033 del localhost del sistema C a través del cual podríamos acceder a la red [A(RP)]. Usando Privoxy [3] en el sistema C se podría crear un porxy HTTP que enviara las peticiones a través del proxy SOCKS. También se puede utilizar tsocks
[4], corkscrew
[5], o varables de entorno /^.*_PROXY$/
[6].
De esta manera se pueden usar sistemas intermedios para dar acceso a sistemas que en principio pudieran ser no accesibles, o al menos por lo puertos TCP que nos pudieran interesar.
Bueno, pues también existen estas dos utilidades que he descubierto hoy y que me resultan muy interesantes:
-
sshuttle
[7] que usando internamente ssh al estilo de túnel dinámico, permite mapear una red (IP/MÁSCARA) (incluso delegando las peticiones de DNS) de modo que sin tener que usar proxy SOCKS tengamos acceso a la red remota. Ejemplo, supongamos que desde un sistema A queremos acceder a la red privada del sistema B:
# A([B(RP)]) -- B -- [B(RP)]
sshuttle -r usuario@B --dns 10.0.0.0/8
-
sshoot
[8] que permite gestionar un conjunto de configuracionessshuttle
a modo de servicios. Ejemplo:
sshoot create -r usuario@B -d B_RP 10.0.0.0/8
sshoot start B_RP
Quería compartirlo con vosotros por si os es de utilidad.
[1]: Secure Shell tunnelling en Wikipedia: https://en.wikipedia.org/wiki/Tunneling_protocol#Secure_Shell_tunneling.
[2]: SOCKS en Wikipedia: https://en.wikipedia.org/wiki/SOCKS.
[3]: Privoxy: https://www.privoxy.org/.
[4]: tsocks
: http://tsocks.sourceforge.net/.
[5]: corkscrew
: https://github.com/bryanpkc/corkscrew.
[6]: Variables de entorno: https://wiki.archlinux.org/index.php/Proxy_server#Environment_variables.
[7]: sshuttle
: https://github.com/apenwarr/sshuttle.
[8]: sshoot
: https://github.com/albertodonato/sshoot.
Nomenclatura:
[CF]: Corta fuegos, Un ejemplo de donde podría estar para limitar ciertos accesos.
[S(RP)]: Red privada a la que pertenece el sistema S.
[I]: Internet.