Establecer una conexión web segura con un sitio web sin HTTPS a través de un tunel SSH con GNU/Linux

Introducción.

A pesar de que el hosting donde se almacena mi blog no cuenta con certificados SSL para poder implementar HTTPS siempre me había preguntado si era posible realizar conexiones seguras con ese servidor específico para realizar ciertas transacciones, es decir, me importaba especialmente mi acceso de administrador cuando debía ingresar mi nombre de usuario y contraseña para autenticarme ya que mediante el HTTP estas viajan planas (sin cifrado).

Ya que por estos días he vuelto a escribir acerca del protocolo SSH, me doy por fin la tarea de detallar este procedimiento, que a través de un túnel SSH con el servidor permite establecer conexiones seguras y temporales con el mismo.

Precondiciones.

  • El servidor cuenta, además del servicio HTTP, con el servicio de SSH.
  • El usuario cuenta con una cuenta de usuario y contraseña válidas para acceder al servidor a través de SSH.
  • La conexión se considera segura hasta el servidor que se contacta (el hosting del blog en mi caso), si se acceden sitios mas allá de él la transmisión será insergura.
  • El cliente cuenta con un navegador web que permita configurar su proxy.  Se recomienda utilizar Firefox.

Procedimiento.

Establecer el túnel seguro.

En esta etapa inicial se crea un túnel SSH entre el equipo cliente y el servidor (que almacena el blog).

$ ssh -fND 4711 usuario@mi.blog.com

El túnel se conecta del lado del cliente mediante el puerto 4711 (definido por el usuario).  La instrucción ssh es enviada automáticamente a background después de realizarse la autenticación (normalmente basada en nombre de usuario y contraseña).  Si desea evitar este comportamiento, remueva el parámetro -f de la instrucción.

Configurar a Firefox para utilizar el túnel.

Es necesario indicarle a Firefox que enrrute el tráfico de información a través del túnel recién creado.  Para hacer esto es necesario acceder a las preferencias de red mediante los menúes Edit > Preferences y allí activar la sección Advanced (parte superior) y presionar el botón Settings en la pestaña Network (parte media).

Configuración de conexión de Firefox

En el diálogo de configuración de conexiones seleccione la opción Manual proxy configuration y especifique la dirección 127.0.0.1 como SOCKS Host y 4711 como Port.  Este último valor deberá coincidir con el utilizado durante el establecimiento del túnel.

Una alternativa mas flexible a esta es el uso de FoxyProxy, un plugin para Firefox que permite manipular sus proxies de una forma mas eficiente.  Presione CTRL+F2 para acceder a la configuración de este plugin, presione el botón Add New Proxy e ingrese la información del túnel.

FoxyProxy plugin, Proxy Settings

Configurar a Firefox para incluír las peticiones de DNS a través del túnel (opcional).

Hasta este punto la comunicación entre el cliente y el servidor, a pesar de que se realiza utilizando el protocolo HTTP, se realiza de manera cifrada ya que se hace utilizando el túnel SSH.  Por fuera de esta comunicación quedan las solicitudes para resolver nombres a través del servicio DNS que hace el cliente antes de transmitir la información a través del túnel.  Esto probablemente no sea un riesgo significativo de seguridad pero enrrutarlas a través del túnel confiere un poco mas de privacidad, al menos a nivel de la LAN ya que no será posible identificar localmente esta información mediante el uso de un sniffer.

Por suerte Firefox permite configurarse para incluír las peticiones al DNS a través de un proxy SOCKS, el cual en este caso es el túnel SSH.  Para hacer esto es necesario acceder al siguiente URL en el navegador: about:config.

Opciones de configuración de Firefox relacionadas con proxies.

Finalmente ubique la variable network.proxy.socks_remote_dns y modifique su valor a true.

Si utiliza FoxyProxy puede realizar esta configuración por proxy ingresando a la configuración del proxy elegido (Proxy Settings) y seleccionando la casilla de verificación Perform remote DNS lookups on hostnames loading through this proxy en la pestaña General.

Finalizar el túnel.

Para terminar la existencia del túnel simplemente finalice la aplicación de ssh, ya sea terminando la aplicación con CTRL+C (si no estaba en background) o matando su proceso mediante el comando kill.

Recuerde ajustar nuevamente el proxy activo en Firefox para continuar utilizando el tipo de conexión habitual en su equipo.

Navegar a través de un servidor como proxy utilizando un puente SSH y un cliente GNU/Linux

Introducción.

SSH es uno de los protocolos mas interesantes, con él se pueden hacer múltiples cosas muy útiles y flexibles.  En este caso voy a describir el proceso de creación de un túnel SSH para acceder a Internet a través de un servidor que actúe como proxy.

Esto es muy útil cuando se pertenece a una red LAN que tiene un acceso limitado o nulo a la red WAN pero es posible acceder a servidores sin restricciones.  En este caso se crea un túnel entre el cliente (LAN) y el servidor (LAN/WAN) y se le indica al cliente que enrrute su tráfico WAN a través de esta conexión.

Requerimientos.

  • Un equipo en la red LAN con GNU/Linux.  Igual se puede implementar con Putty para Windows.
  • Un servidor con acceso a la red WAN que puede ser visto desde la red LAN y que cuenta con el servicio de SSH (versión 2).
  • Una cuenta de usuario para el acceso al servidor a través de SSH.

Procedimiento.

Establecer el túnel.

En el cliente, es decir el equipo en la red LAN que desea acceder a la WAN, crear un túnel hacia el servidor a través de un puerto local (en este caso, el 4711).

$ ssh -ND 4711 usuario@servidor

Por obvias razones, para establecer el túnel es necesario contar con la contraseña asociada al usuario@servidor.

La descripción de los parámetros utilizados por ssh para crear el túnel son los siguientes.

-D [bind_address:]port
Specifies a local “dynamic” application-level port forwarding.
This works by allocating a socket to listen to port on the local
side, optionally bound to the specified bind_address.  Whenever a
connection is made to this port, the connection is forwarded over
the secure channel, and the application protocol is then used to
determine where to connect to from the remote machine.  Currently
the SOCKS4 and SOCKS5 protocols are supported, and ssh will act
as a SOCKS server.
Only root can forward privileged ports.
Dynamic port forwardings can also be specified in the configura‐
tion file.

-N Do not execute a remote command.  This is useful for just for‐
warding ports
(protocol version 2 only).

Configurar el navegador para utilizar al túnel para acceder al proxy.

Acceder a la configuración de Firefox a través de los menúes Edit > Preferences.

Elegir la sección Advanced (parte superior), la pestaña Network y presione el botón Settings.

Configuración de red de Firefox

Seleccione la opción de Manual proxy configuration y especifique la información para el SOCKS Host.  Para este caso el host será localhost (el equipo local donde se creó el puente) y el puerto será el 4711 (el mismo utilizado durante la creación del túnel).

Después de aceptados los cambios deberá ser posible navegar a través de la red WAN utilizando Firefox y utilizando al servidor como proxy.  Para verificar esto, acceda a un sitio como http://whatismyipaddress.com/ y verifique la dirección IP reportada, deberá ser la misma del servidor.

Esta configuración sólo aplica para Firefox así que no afecta la navegación de las demás aplicaciones ni del sistema operativo.

Configurar a GNOME para utilizar al túnel para acceder al proxy.

Configurar el proxy desde la administración del sistema de ventanas tiene un alcance mas profundo, incluyendo a las aplicaciones que utilizan sus valores como predeterminados e incluyendo al sistema operativo.

Para hacer esto es necesario acceder a las Network Proxy Preferences de la siguiente manera.

$ /usr/bin/gnome-network-properties

Seleccione la opción Manual proxy configuration y especifique los valores utilizados anteriormente: el Socks host es localhost y el Port es 4711.

Configuración de Proxy de GNOME.

Si desea que estos cambios sean permanentes y afecten a todos los usuarios del equipo, presione el botón Apply System-Wide (requiere acceso de root).

Configurar a GNOME para utilizar al túnel para acceder al proxy (línea de comando).

Es posible realizar la configuración anterior desde la línea de comando, lo cual es útil para la implementación de scripts.  Para obtener los mismos efectos es necesario ejecutar las siguientes instrucciones.

$ gconftool -s /system/proxy/socks_host -t string 127.0.0.1

$ gconftool -s /system/proxy/socks_port -t int 4711

$ gconftool -s /system/proxy/mode -t string manual

Enlaces.

Instalar Polipo, un proxy web/caché en ArchLinux 2010.05 x64

Introducción.

Para hacer unas pruebas esta tarde necesito un proxy que haga caché sobre los datos descargados; inicialmente iba a instalar Squid sobre un Scientific Linux pero decidí hacerlo sobre ArchLinux, con el cual estoy jugando desde el día de ayer.  Leyendo la documentación del wiki de ArchLinux, que por cierto es muy buena, encontré que hacen referencia a Polipo, un software similar en funciones a Squid pero con mayores limitaciones y destinado a servidores con muy pocos usuarios.  Ese es mi caso, así que procedí a instalarlo en una máquina virtual con VirtualBox y 512MB de RAM.  Espero que aguante.

Instalación de los paquetes.

Desafortunadamente lo paquetes de Polipo no están disponibles en los repositorios, sin embargo estos pueden ser creados utilizando una facilidad interesante del sistema operativo.

Los siguientes pasos deben realizarse como un usuario sin privilegios.

Descargar la versión mas reciente de los archivos (sección de files) de Polipo de la siguiente ubicación.

http://aur.archlinux.org/packages.php?ID=14579

$ wget http://aur.archlinux.org/packages/polipo/polipo/PKGBUILD

$ wget http://aur.archlinux.org/packages/polipo/polipo/polipo.install

$ wget http://aur.archlinux.org/packages/polipo/polipo/polipo

Generar el paquete.

$ makepkg -s

Instalar el paquete recién generado.

$ sudo pacman -u polipo-1.0.4.1-1-x86_64.pkg.tar.xz

Configuración de Polipo.

Crear un archivo básico de configuración a partir de la plantilla.

$ sudo cp /etc/polipo/config-sample /etc/polipo/config

Permitir las conexiones externas, además de localhost.

$ sudo vi /etc/polipo/config

proxyAddress = “0.0.0.0”

Si se desea permitir el uso del caché por equipos diferentes del mismo (localhost)  es necesario especificar las redes autorizadas en la siguiente variable del mismo archivo config.  Nótese que, a diferencia del ejemplo en el mismo archivo, fue necesario remover las comillas dobles que encerraban las direcciones de red.

allowedClients = 127.0.0.1, 10.0.0.0/16, 192.168.1.0/24

Actualizar el archivo de inicio de Polipo.  Nótese en el script que por razones de seguridad se utilizará al usuario nobody para ejecutar el servicio.

$ sudo cp /etc/rc.d/polipo /etc/rc.d/polipo.orig

$ sudo vi /etc/rc.d/polipo

#!/bin/bash
. /etc/rc.conf
. /etc/rc.d/functions

DAEMON=polipo
ARGS="daemonise=true pidFile=/var/run/$DAEMON/$DAEMON.pid"
PID=`pidof -o %PPID /usr/bin/$DAEMON`

case $1 in
    start)
        stat_busy "Starting $DAEMON"
        rm /var/run/$DAEMON/$DAEMON.pid 2> /dev/null
        install -d /var/run/$DAEMON
        ## /usr/bin/$DAEMON $ARGS >/dev/null 2>&1
        sudo -u nobody /usr/bin/$DAEMON $ARGS >/dev/null 2>&1
        if [[ $? != 0 ]]; then
            stat_fail
        else
            add_daemon $DAEMON
            stat_done
        fi
    ;;
    stop)
        stat_busy "Stopping $DAEMON"
        kill $PID >/dev/null 2>&1
        if [[ $? != 0 ]]; then
            stat_fail
        else
            rm_daemon $DAEMON
            stat_done
        fi
    ;;
    purge)
        stat_busy "Purging polipo"
        [[ ! -d /var/run/polipo ]] && mkdir /var/run/polipo
        if ! ck_daemon polipo; then
            kill -USR1 $DAEMON >/dev/null 2>&1 || stat_die $?
            sleep 1
            /usr/bin/$DAEMON -x $ARGS >/dev/null 2>&1 || stat_die $?
            kill -USR2 $PID >/dev/null 2>&1 || stat_die $?
            stat_done
        else
            /usr/bin/$DAEMON -x $ARGS >/dev/null 2>&1 || stat_die $?
            stat_done
        fi

    ;;
    restart)
        $0 stop
        sleep 1
        $0 start
    ;;
    *)
        echo "usage: $0 {start|stop|restart|purge}"
    ;;
esac

Ajustes al sistema operativo.

Crear un proceso cron para purgar el servicio.

$ sudo vi /etc/cron.weekly/polipo

#!/bin/sh
/etc/rc.d/polipo purge >/dev/null 2>&1

$ sudo chmod +x /etc/cron.weekly/polipo

Crear las rutas necesarias para los archivos del proxy.

$ sudo touch /var/log/polipo

$ sudo chown nobody:nobody /var/log/polipo

$ sudo mkdir /var/run/polipo

$ sudo chown nobody:nobody /var/run/polipo

$ sudo mkdir /var/cache/polipo

$ sudo chown nobody:nobody /var/cache/polipo

Configurar el inicio automático de Polipo con el sistema operativo.

$ sudo vi /etc/rc.conf

DAEMONS=(syslog-ng network netfs polipo crond)

Prueba del caché.

Configure el proxy de Firefox o de cualquier otro cliente y acceda a los recursos que desee, estos deberán almacenarse en el caché por lo cual futuros accesos (recuerde limpiar el caché local de ser necesario para hacer mas confiable la prueba) deberían ser más rápidos.  Como ubicación del servidor de caché utilice la IP del servidor donde se instaló Polipo y el puerto -por defecto- 8123.

Enlaces.