Cómo conectarme a un servidor remoto en una red protegida - Versión actualizada

En un artículo anterior describí cómo conectarse a un equipo remoto en una red protegida http://diego-k.blogspot.mx/2014/12/como-conectarme-un-servidor-remoto-con.html .

Esta vez vamos a perfeccionar el método, hacerlo más práctico y a la vez más estable.

El objetivo es el mismo:

"Quieres alcanzar un servidor desde tu PC pero estás detrás del firewall de tu modem y el servidor se encuentra detrás del firewall corporativo. Ambos pueden salir a Internet, pero ninguno publica puertos. "

Tenemos diferentes pasos a seguir: 

1) Podemos usar la capa gratuita de Amazon Web Services con un Linux AMI. Hay muchas guías de cómo configurarlo, como la siguiente: How to setup a Linux server on Amazon AWS
En caso de querer hacerlo nosotros mismos necesitaremos una vieja PC, Netbook o Notebook donde instalaremos Linux (puede ser Ubuntu con OpenSSH) y deberemos abrir un puerto para el SSH (recomiendo 443) en el firewall del router. La configuración depende del equipo y el proveedor, pero siempre hay tutoriales. 

2) En el IBM i o un Linux dentro de la infraestructura donde se encuentra el servidor debemos instalar OpenSSH y AUTOSSH. AutoSSH tiene una sintaxis similar a SSH, pero valida si se ha caído la conexión y la restablece. Con eso evitamos estar validando la conexión. Es muy util en conexiones poco estables.

3) Creamos una cuenta en DynU para que el IBM i encuentre nuestro servidor por nombre en lugar de IP. Si llegara a cambiar y la conexión cayera el AUTOSSH volverá a reconectar de forma correcta. 

Instalamos el cliente de DYNU en Linux o podemos agregar un trabajo CRON que ejecute lo siguiente:

* * * * * curl  "http://api.dynu.com/nic/update?hostname=myserver.dynu.com&password=MYPASSWORD">/dev/null 2>&1

Este ejemplo refrescará cada minuto la IP pública del servidor myserver.dynu.com . Recuerden, este es el servidor de Amazon o la PC/N*tbook que rehabilitamos para hacer de puente.

4) En el servidor IBM i o Linux creamos un tunnel reverso que publique el puerto de SSH (debe estar encendido el *SSHD)  en el puerto 8022 usando AutoSSH.
El script puede ser algo así:

autossh -M 10988 -f -N  -R 8022:127.0.0.1:22  -p 443 USUARIO@myserver.dynu.com -o "ServerAliveInterval 30" -o "ServerAliveCountMax 3"  

NOTA: Es importante que contemos con una llave de SSH para que nos podamos conectar SIN password al servidor Linux en Amazon/Casa/Oficina, como se indica en el artículo que publiqué con anterioridad.

5) En nuestra PC nos conectamos al mismo equipo, redirigiendo el puerto 8022 a nuestra PC:

autossh -M 10986 -f -N  -L 8022:127.0.0.1:8022  -p 443 USUARIO@myserver.dynu.com -o "ServerAliveInterval 30" -o "ServerAliveCountMax 3"  

(en caso de usar Linux)

o bien con PuTTY:

5) Ahora creamos una 2da conexión, pero esta vez a LOCALHOST, en el puerto 8022, para crear el tunel dinámico:

autossh -M 10984 -f -N  -D 3128  -p 8022 USUARIO@myserver.dynu.com -o "ServerAliveInterval 30" -o "ServerAliveCountMax 3"  

(Linux)

o bien en PuTTY:

Listo, ya tenemos una conexión a través de un equipo que nos hace de puente:

Ahora podemos usar el puerto 3128 en Localhost como un proxy SOCKS 5 en nuestro navegador, en PuTTY, en TN5250j o incluso con Proxychains/TSOCKS o ProxyFier

IBM i (iSeries / AS/400) - Haciendo respaldos en la nube/red (Cloud Backup) - Versión segura usando SCP

Esta versión es similar al post anterior de "http://diego-k.blogspot.com/2014/12/ibm-i-iseries-as400-haciendo-respaldos.html" pero es algo más simple (es un sólo CL) y según mis pruebas incluso es más veloz.

En lugar de armar un script de FTP, simplemente usa SCP para transferir archivos. Esto permite hacer una conexión sin depender de una password, la información viaja de forma segura, y el archivo es encriptado antes de ser enviado.

Necesitaremos tener instalado el 5733-SC1 (Portable Utilities) para contar con el comando SCP, un servidor que soporte SSH donde enviaremos el archivo, y la generación de la clave pública y clave privada para transferir sin necesidad de password.

El CLLE es un poco extenso, pero simple de seguir.

Los respaldos se hacen completos el primer día del mes y los lunes, e incrementales el resto de los días.
Se requiere crear la DTAARA BKP7ZPSWD con la llave de encripción. En este caso es una llave de 64 caracteres.

También necesitaremos el archivo BKPLIB que tiene la estructura de la salida de DSPOBJD pero en ODOBNM tendremos la lista de bibliotecas a respaldar.

Obviamente el servidor SSH debe ser visto desde el servidor IBM i (iSeries) donde tengamos el script.

             PGM
             DCL        VAR(&ENCKEY) TYPE(*CHAR) LEN(64)
             DCL        VAR(&zipCMD) TYPE(*CHAR) LEN(256)
             DCL        VAR(&SSHCMD) TYPE(*CHAR) LEN(256)
             DCL        VAR(&SCPCMD) TYPE(*CHAR) LEN(256)
             dcl        var(&FECHA) type(*CHAR) LEN(8)
             DCL        var(&HOY) type(*CHAR) LEN(8)
             DCL        VAR(&DIA)  TYPE(*CHAR) LEN(2)
             DCL        VAR(&NDIA) TYPE(*DEC) LEN(2 0)
             DCL        VAR(&MES)  TYPE(*CHAR) LEN(2)
             DCL        VAR(&ANIO)  TYPE(*CHAR) LEN(2)
             DCL        VAR(&DOW) TYPE(*CHAR) LEN(4)
             DCLF       FILE(MYLIB/BKPLIB)
             RTVDTAARA  DTAARA(MYLIB/BKP7ZPSWD *ALL) +
                          RTNVAR(&ENCKEY)
             RTVSYSVAL  SYSVAL(QDAYOFWEEK) RTNVAR(&DOW)
             RTVSYSVAL  SYSVAL(QDAY) RTNVAR(&DIA)
             RTVSYSVAL  SYSVAL(QMONTH) RTNVAR(&MES)
             RTVSYSVAL  SYSVAL(QYEAR) RTNVAR(&ANIO)
             CHGVAR     VAR(&FECHA) VALUE('01' *TCAT &MES *TCAT +
                          '20' *TCAT &ANIO)
             CHGVAR     VAR(&NDIA) VALUE(&DIA)
             CHGVAR     VAR(&HOY) VALUE( '20' *TCAT &ANIO *TCAT +
                        &MES *TCAT &DIA)
             CRTLIB LIB(BACKUPSAV) TEXT('Biblioteca de Backup')
             MONMSG     MSGID(CPF2111)
             CLRLIB     LIB(BACKUPSAV)
             /* Borro los archivos  SAVF y 7z que hayan quedado */
             QSH        CMD('/QOpenSys/usr/bin/sh -c " +
                        rm /home/backupsav/*.7z"')
             QSH        CMD('/QOpenSys/usr/bin/sh -c " +
                        rm /home/backupsav/*.savf"')
             /* Creo el archivo  SAVF con perfiles de usuarios */
             CRTSAVF    FILE(BACKUPSAV/SAVSECDTA) TEXT('Seguridad')
             SAVSECDTA  DEV(*SAVF) SAVF(BACKUPSAV/SAVSECDTA) +
                          DTACPR(*NO) COMPACT(*NO)
             /* Muevo el archivo  SAVF al IFS */
             QSH        CMD('/QOpenSys/usr/bin/sh -c " +
                          mv /QSYS.LIB/BACKUPSAV.LIB/SAVSECDTA.FILE +
                          /home/backupsav/SAVSECDTA.savf"')
             /* Comprimo el archivo  SAVF */
             CHGVAR     VAR(&zipCMD) VALUE('/QOpenSys/usr/bin/sh -c " +
                         7za a -p' *tcat +
                         &ENCKEY *BCAT '/home/backupsav/savsecdta.7z +
                           /home/backupsav/savsecdta.savf"')

             QSH        CMD(&ZIPCMD)
             /* Borro el archivo  SAVF */
             QSH        CMD('/QOpenSys/usr/bin/sh -c " +
                        rm /home/backupsav/SAVSECDTA.savf"')
             MONMSG     MSGID(CPF0000)
             /* Creo el directorio remoto con la fecha */
             CHGVAR     VAR(&SSHCMD) VALUE('ssh -p 443 -i +
                          /home/ituser1/.ssh/id_rsa +
                          ituser1@mysshserver.com "mkdir +
                          -p /mnt/USB1/BACKUP/'  +
                          *TCAT &HOY *TCAT '"')
             QSH        CMD(&SSHCMD)
             MONMSG     MSGID(CPF0000)
             /* Transfiero el archivo en background */
             CHGVAR     VAR(&SCPCMD) VALUE('scp -P 443 -i +
                          /home/ituser1/.ssh/id_rsa +
                          /home/backupsav/savsecdta.7z +
                          ituser1@mysshserver.com:/mnt/USB1/BA+
                          CKUP/' *TCAT &HOY *TCAT '/ &')
             QSH        CMD(&SCPCMD)
             MONMSG     MSGID(CPF0000)
 LEE:        RCVF
             MONMSG     MSGID(CPF0864) EXEC(GOTO CMDLBL(FIN))
             CRTSAVF    FILE(BACKUPSAV/&ODOBNM) TEXT(&ODOBTX)
             MONMSG     MSGID(CPF0000)
             IF         COND((&DOW  = '*MON') *OR (&NDIA=1)) THEN( +
                        SAVLIB LIB(&ODOBNM) +
                          DEV(*SAVF) SAVF(BACKUPSAV/&ODOBNM) +
                          SAVACT(*LIB) ACCPTH(*YES) DTACPR(*NO) +
                          COMPACT(*NO) )
             ELSE   CMD(   +
                 SAVCHGOBJ  OBJ(*ALL) LIB(&ODOBNM) DEV(*SAVF) +
                          REFDATE(&FECHA) REFTIME(000000) +
                          SAVF(BACKUPSAV/&ODOBNM) SAVACT(*LIB) +
                          ACCPTH(*YES) DTACPR(*NO) COMPACT(*NO))


             /* MUEVO el archivo  SAVF al IFS */
             CHGVAR     VAR(&ZIPCMD) VALUE('/QOpenSys/usr/bin/sh -c " +
                          mv /QSYS.LIB/BACKUPSAV.LIB/' *TCAT &ODOBNM +
                          *TCAT '.FILE /home/backupsav/' *TCAT +
                          &ODOBNM *TCAT '.savf"')

             QSH        CMD(&zipCMD)
             /* Comprimo con 7zip y clave el archivo  SAVF */
             CHGVAR     VAR(&ZIPCMD) VALUE('/QOpenSys/usr/bin/sh -c " +
                        7za a -p' *tcat +
                        &ENCKEY *BCAT '/home/backupsav/' *TCAT +
                        &ODOBNM *TCAT '.7z /home/backupsav/' *TCAT +
                        &ODOBNM *TCAT '.savf"')

             QSH        CMD(&zipCMD)
             /* Borro el archivo  SAVF */
             CHGVAR     VAR(&ZIPCMD) VALUE('/QOpenSys/usr/bin/sh -c " +
                        rm /home/backupsav/' +
                        *tcat &ODOBNM *TCAT '.savf"')
             QSH        CMD(&zipCMD)
             /* Transfiero el archivo en background */
             CHGVAR     VAR(&SCPCMD) VALUE('scp -P 443 -i +
                          /home/ituser1/.ssh/id_rsa +
                          /home/backupsav/' *TCAT &ODOBNM *TCAT '.7z +
                          ituser1@mysshserver.com:/mnt/USB1/BA+
                          CKUP/' *TCAT &HOY *TCAT '/ &')
             QSH        CMD(&SCPCMD)
             MONMSG     MSGID(CPF0000)

             GOTO       CMDLBL(LEE)
 FIN:        ENDPGM
Espero que sea de utilidad

Cómo conectarme a un servidor remoto en una red protegida

Para quienes trabajamos en sistemas brindando servicios, muchas veces nos sucede que necesitamos conectarnos a un servidor en la red de nuestros clientes, pero lamentablemente no tienen VPN (Red Privada Virtual)  ni otro mecanismo para conectarnos de forma remota.

Normalmente existen alternativas:

1) Seguir insistiendo en que nos den acceso a la red mediante VPN , o bien ofrecerles configurar una. Con tiempo veré de postear un tutorial del OpenVPN.

2) Poco probable, pero he visto empresas que publican directamente el servidor en Internet, sin filtros. Recuerdo alguna vez las estadísticas de cuantos minutos podía estar un servidor Windows en Internet sin  ser "hackeado" o infectado por algún tipo de virus o gusano de internet. No lo recomiendo ni un poquito

3) Programa de control remoto a alguna PC. Recomiendo TeamViewer. No siempre es posible obtener este tipo de acceso. http://www.teamviewer.com

4) Solicitar que abran el puerto de SSH en su conexión externa (Internet) para poder entrar creando túneles. Esta alternativa es bastante simple de usar, y existen diferentes formas de sacar provecho:
a) Si el acceso lo necesitamos a 1 sólo servidor , podemos redirigir el puerto, usando tuneles "locales". Esto permitirá transferir de forma lógica ese puerto hacia nuestro equipo desde donde nos conectamos.

Ejemplo con PuTTY:

* Configuramos una sesión, apuntando a la IP pública del servidor (si no tiene una IP fija podemos usar NO-IP o DynDNS para localizar su IP cambiante), e indicamos el puerto
* Vamos a la pestaña SSH y al expandirla seleccionamos Tunnels, y configuramos un tunnel de la siguiente manera














Seleccionamos

Source Port:  el puerto a redirigir. En este ejemplo el 23 (TELNET)
Destination: La IP del servidor seguido del puerto. Puede ser el mismo equipo donde apuntamos o a otro que sea visible desde el servidor de SSH
Local: Esto indica que el puerto remoto será transferido al puerto local. Esto permitirá que podamos conectarnos en la direccion 127.0.0.1 (localhost ) al puerto que indicamos en Source Port como si fuera el equipo remoto.
Add : debemos presionar el botón para agregar el puerto. Podemos repetirlo para diferentes puertos de diferentes equipos.

Es importante destacar 2 cosas:

a) No todos los servicios soportan "tunneling". Algunos servicios necesitan ser accedidos por VPN o estando en la red local
b) Si tenemos varios equipos a los cuales acceder en el mismo puerto, podemos elegir diferentes puertos locales en "Source Port). Sólo deberemos cambiar el puerto para acceder a un servidor diferente

En este ejemplo estamos conectándonos al puerto 23 de un servidor remoto que es visible para el servidor que usamos para conectarnos por SSH. En este ejemplo, usamos el 23 local. La forma de conectarnos a él sería:

telnet 127.0.0.1 23

Si fuera un servidor web, pondríamos el puerto 80 y podríamos acceder de la siguiente forma






 b) Si son varios servidores, dependiendo de la cantidad de equipos y puertos,  podemos hacer lo mismo de arriba seleccionando un puerto local diferente para cada servidor como en el ejemplo de la imagen












o podemos crear un "proxy socks" con un único puerto




El SSH permite crear un tunel "dinámico" o proxy socks. Esto permite usar múltiples puertos a través de un único tunel, siempre que el programa lo permita.

Por ejemplo, en Firefox podemos seleccionar el proxy socks en la configuración y estaremos navegando como si nuestro equipo fuera el servidor de SSH. Esto lo haremos en Opciones->Avanzado->Red->Conexión/Configurar :





Lo mismo podemos hacer con programas como PuTTY, Filezilla (FTP), etc, que permiten seleccionar un Proxy Socks para conectarse al servidor remoto.

c) Podemos usar el mismo mecanismo que en b)  , pero si nuestro programa NO soporta Proxy, o no queremos complicarnos la existencia, podemos usar Proxifier (hay un trial en la página del producto).
Proxifier permite hablar con la mayoría de los programas aunque no tengan la opción de configurar el proxy socks, de forma transparente. Permite configurar rangos de direcciones IP asociadas a un determinado proxy (podemos usar más de uno a la vez) sin tener que hacer nada en el programa.

Para mayor información, http://www.proxifier.com/

3) Usar un tunel remoto. Si nuestro cliente "no sabe como hacerle" y está perdido, pero sigue necesitando nuestra ayuda, podemos usar un Tunel Remoto. Cabe aclarar que hacer esto sin el consentimiento del cliente nos podría meter en problemas.

Un tunel remoto es similar a un tunel local, sólo que en lugar de mapear un puerto del servidor en nuestra PC/Servidor de la oficina, será el servidor del cliente quien se conectará a la PC/Servidor de la oficina para maperar su propio puerto. El resultado es similar, sólo que no seremos nostros quienes iniciemos la comunicación.

Para mayor claridad: Imaginemos que este cliente no tiene VPN ni está en las soluciones a corto plazo, que no tiene conocimiento de como abrir un puerto en el firewall para publicar el SSH o cualquier otro en Internet (no como Uds :-)  o no quiere complicarse la existencia, pero sigue necesitando nuestro apoyo, podemos hacer que la montaña vaya a Mahoma.

Para esto, necesitamos tener un servidor SSH publicado en Internet, o bien nuestra PC con un servicio de SSH. Me inclino más por el servidor. Lo ideal sería que usarámos un puerto como el 443 en lugar del 22 (default) para evitar los firewalls en nuestro cliente.

Si nuestra IP no es fija, podemos usar un servicio como NO-IP o DynDNS para obtener una direccion dinámica con un nombre permanente. Muchos routers de Internet soportan DYNDNS y NO-IP de forma nativa, pero de no ser así, podemos instalar el cliente en el servidor o cualquier PC de la oficina. http://www.no-ip.com . Sólo deben crear una cuenta de usuario, descargar el cliente y listo.


Volviendo a nuestro tema original, vamos a configurar PuTTY apuntando a nuestro servidor, asumamos:

Nombre de servidor: miempresa.no-ip.biz (no-ip.com dispone de varios dominios gratuitos y otros de paga).
Puerto:  443

Nuestro servidor puede ser Linux o Unix (lo ideal), o  Windows. En Windows debemos instalar OpenSSH para Windows, y es bastante simple de configurar. http://sourceforge.net/projects/sshwindows/

En el servidor del cliente, si es Windows, configuramos la conexión a esa dirección, y creamos un tunel con lo siguiente:



Esto va a crear una conexión desde el servidor del cliente hasta nuestro servidor en la oficina en el puerto 2222, apuntando al OTRO servidor, en este caso el 192.168.1.123 en el puerto 22 (defautl para SSH).

Es decir, si hacemos ssh -p 2222 usuario@127.0.0.1 no va a pedir la clave para llegar al servidor remoto dentro de la red del cliente, que no necesita estar publicado y no necesita ser el servidor que se conecta con nosotros.

Ahora, ya que podemos ver el servidor en nuestra máquina, podemos crear un proxy socks hacia el cliente.

En Windows: Creamos una conexión apuntando a 127.0.0.1 en el puerto 2222 y luego es simplemente crear un tunnel dinámico como antes




Si es en Linux la cosa se pone más simple:

ssh -p 2222 usuario@127.0.0.1 -D 8080

Si conocemos lo suficiente de scripts en Unix/Linux podremos incluso crear un tunel persistente, que se reconecte cada X tiempo.

NOTA: Deben tener acceso a Internet desde el equipo en el cliente que se conecta a sus oficinas.
NOTA2: Deben tener activado el TCP Forwarding en el servidor local (es el default)
NOTA3: Repito, deben obtener el permiso del cliente, o sentirá que se están conectando a sus espaldas.