Este posiblemente sea el primer artículo de una serie que vamos a ir publicando llamada “Aplicaciones prácticas de Docker en ciberseguridad”, donde iremos mostraremos recursos, herramientas y soluciones siempre utilizando Docker como elemento principal. La versatilidad y sencillez de esta tecnología nos permite disponer de nuestra propia caja de herramientas, segura, en cualquier momento y en cualquier lugar.

Figura 1: Docker en ciberseguridad: Tu servidor Proxy para navegar por TOR

Esto para alguien que se dedica a la ciberseguridad o incluso para cualquier usuario que quiera probar o utilizar alguna aplicación, es una opción que debemos de tener en cuenta. Y recuerda, si necesitas ayuda para comenzar esta aventura con Docker, en nuestro libro “Docker: SecDevOps” tienes un buen punto de partida para comenzar en este fantástico mundo de los contenedores Docker.

Figura 2: Libro de Docker:SecDevOps

Utilizar un contenedor Docker nos permite encapsular toda la instalación (componentes, dependencias, etc) y aislarlo de nuestro host (por defecto). De esta manera, podemos, por ejemplo, crear un proxy para navegar a través de la red Tor de una manera segura y rápida. Y esto es justo lo que vamos a contarte hoy paso a paso, así que manos al a obra.

Cómo configurar un Proxy Tor

Para ello vamos a crear una imagen con dos herramientas que seguro ya conocéis: anonsurf y tiny proxy. Con anonsurf navegaremos a través de Tor y tiny proxy, actuará pues como su nombre indica: como un Proxy.  Todo ello para que puedas navegar con anonimato a través de la Deep Web o poder hacer labores de Ciberinvestigación.

Figura 3: Deep Web: Privacidad y Anonimato

Lo primero que haremos es crearnos una imagen Docker con dichas herramientas. Para facilitar este proceso, vamos a utilizar una aplicación llamada doig o Docker Image Generator, una aplicación Open Source en lenguaje Go, creada por Tuxotron ;) que tenéis disponible en este enlace.

Figura 4: Doig en GitHub

Esta aplicación permite crear imágenes Docker o ficheros Dockerfile personalizados, simplemente eligiendo las herramientas que necesites. Además de facilitar la tarea de crear la imagen, también es muy instructiva, ya que una vez creada la imagen nos permite exportar el fichero Dockerfile el cual podemos utilizar directamente con el comando docker build o simplemente para ver su funcionamiento. Para instalar doig:

git clone https://github.com/tuxotron/docker-image-generator
 cd docker-image-generator
 go build

Para crear nuestra imagen para navegar por la red Tor, ejecutamos:

./doig -i myproxy -t anonsurf tinyproxy
 …
 Successfully built 49e1529560fe
 Successfully tagged myproxy:latest
 
 Tools added to the image:
   [-] tinyproxy: When you run Tiny Proxy, by defautl listens on port 8888,
         so you will need to map that port to a local port. Ex: -p 8888:8888
   [-] anonsurf: You need to run the container in privileged mode

Con la opción -i especificamos el nombre de la imagen y con -t listamos las herramientas que queremos incluir en la misma. Una vez terminado el proceso de construcción de la imagen, vemos que al final nos aparecen dos mensajes:

[-] tinyproxy: When you run Tiny Proxy, by defautl listens on port 8888,
        so you will need to map that port to a local port. Ex: -p 8888:8888

Este nos avisa que tiny proxy por defecto escucha por el puerto 8888, y que para usarlo necesitaremos mapear dicho puerto al de nuestro host. Si tuvieras cualquier otra aplicación escuchando por ese puerto, mapéalo a cualquier otro. En Docker se pueden mapear puertos del contenedor al host con la opción -p (--publish) host-interface:puerto-host:puerto-contenedor. Por ejemplo:

docker run -p 127.0.0.1:80:8080

Esto mapearía el puerto 80 de la interfaz 127.0.0.1 al puerto 8080 del contenedor. Si se omite la interfaz, se usaría 0.0.0.0:

docker run -p 80:8080

También se pueden especificar rangos de puertos. Por ejemplo:

docker run -p 80-82:8080-8082

Esto mapearía el puerto 80 del host al puerto 8080, 81 al 8081 y el 82 al 8082.

Existe una segunda forma de mapear los puertos con la opción -P (--publish-all). Esta opción no requiere ningún valor, ya que lo que hace es mapear los puertos que expone el contenedor a puertos aleatorios (por encima del 30000) del host. La forma en que Docker identifica los puertos que expone un contenedor viene por el comando EXPOSE de la imagen.

El segundo mensaje:

[-] anonsurf: You need to run the container in privileged mode

Nos dice que anonsurf requiere permisos elevados, ya que éste necesita hacer cambios en las iptables del contenedor. Aquí podemos darle permisos usando las capacidades o bien ejecutar el contenedor en modo privilegiado. Cuando se ejecuta un contenedor en modo privilegiado, tenemos que asegurarnos bien de las funciones que ejecuta, ya que podría comprometer tu sistema.

Si todo ha marchado bien, siguiendo nuestro ejemplo, deberíamos tener una imagen Docker llamada myproxy. Ahora, para ejecutar nuestro contenedor, lo haremos de la siguiente forma:

docker run -it --rm --privileged -p 8888:8888 myproxy
 root@9ca7a81698d3:/opt#

Eso nos sitúa en una shell dentro del contenedor. Ahora todo lo que tenemos que hacer es arrancar anonsurf y tiny proxy:

anonsurf start
  * killing dangerous applications
  * cleaning some dangerous cache elements
 [ i ] Stopping IPv6 services:
 
 
 [ i ] Starting anonymous mode:
 
  * Tor is not running!  starting it  for you
 
  * Starting tor daemon...                                                                              [ OK ]
  * Saved iptables rules
 
  * Modified resolv.conf to use Tor and Private Internet Access DNS
  * All traffic was redirected through Tor
 
 [ i ] You are under AnonSurf tunnel
 
 
 root@9ca7a81698d3:/opt# tinyproxy
 root@9ca7a81698d3:/opt#

Si el indicas a tu navegador que use nuestro Proxy (localhost:8888), estarás navegando a través de Tor, como puede verse en ese vídeo.


Figura 5: Configurar un Proxy TOR en Docker Parte 1
De esta forma, cada vez que queramos arrancar nuestro Proxy Tor tenemos que arrancar el contenedor y levantar ambos servicios. Si queremos automatizar un poco el proceso y ahorrarnos los pasos de levantar dichos servicios de forma manual, podemos usar la opción -d de doig. Esta opción nos dará el fichero Dockerfile que nos permite construir nuestra imagen. Todo lo que tenemos que hacer es añadir al final de dicho fichero la instrucción CMD para que arranque nuestros servicios. Veamos un ejemplo:

./doig -d -t anonsurf tinyproxy > Dockerfile
 
 cat Dockerfile
 
 FROM ubuntu:18.04
 
 RUN apt update && \
     apt install -y software-properties-common git curl p7zip-full wget
                    whois locales python3 python3-pip upx psmisc && \
     add-apt-repository -y ppa:longsleep/golang-backports && \
     apt update && \
     localedef -i en_US -c -f UTF-8 -A /usr/share/locale/locale.alias en_US.UTF-8
 WORKDIR /opt
 ENV LANG en_US.utf8
 ARG DEBIAN_FRONTEND=noninteractive
 
 RUN   apt install -y tinyproxy && sed -i -e '/^Allow /s/^/#/' 
            -e '/^ConnectPort /s/^/#/'
            -e '/^#DisableViaHeader /s/^#//' /etc/tinyproxy/tinyproxy.conf && \
       apt install -y iptables &&
            git clone https://github.com/Und3rf10w/kali-anonsurf.git
            && cd kali-anonsurf && ./installer.sh && \
            rm -rf /var/lib/apt/lists/*

Lo que haremos es añadir al final del fichero Dockerfile es el comando:

CMD anonsurf start; tinyproxy -d

Aquí que le decimos a Docker es que ejecute ese comando cuando arranquemos el contenedor. Fíjate que a tiny proxy le pasamos el parámetro -d para que se ejecute en el foreground. Si no Docker terminaría el contenedor. Una vez hecho esto, ahora sólo nos queda construir la imagen:

docker build -t myproxy

Y arrancar el contenedor:

docker run -d -p 8888:8888 --privileged myproxy

Aquí tenemos que prestar un poco de atención, ya que ya no hemos arrancado el contenedor en modo interactivo (-it) si no en modo no interactivo con la opción -d (detach). De esta forma el contenedor corre en el background. También se podría ejecutar en modo interactivo, pero se nos quedaría la shell “enganchada” al contenedor. Aún así, en ambos casos debería de funcionar.


Figura 6: Configurar un Proxy TOR en Docker Parte 2
Recuerda que esta imagen está sólo disponible en tu sistema. Si queremos compartir esta imagen con alguien o simplemente quisieras usarla en otros entornos, sin tener que construir la imagen en cada uno de ellos, puedes subir ésta a un registro de imágenes. Un registro de imágenes es un repositorio donde se pueden almacenar, imágenes.

Dichas imágenes pueden ser públicas o privadas. A las públicas cualquiera puede acceder y a las privadas, pues cómo puedes imaginar, sólo son accesible por aquellos que tengan las credenciales necesarias. En Docker el registro de imágenes por defecto es https://hub.docker.com. Aquí cualquiera se puede crear una cuenta gratuita. Dicha cuenta te permite crear repositorios y subir imágenes a estos. Con la cuenta gratuita, sólo puedes crear un repositorio privado. El resto deben ser públicos.

Para descargar imágenes del https://hub.docker.com, no necesitas ni tener cuenta ni estar autenticado, siempre y cuanto la descarga de las imágenes que hagas sean públicas, pero si necesitas descargar imágenes privados y/o subir imágenes (ya sean privadas o públicas), sí que tienes que tener cuenta y estar autenticado. Con docker login puedes registrar tu cuenta en Docker y una vez hecho eso, ya podrías acceder a tus imágenes privadas y subir imágenes. Para subir una imagen tienes el comando docker push.

docker push usuario/imagen:tag

Es muy importante que crees una imagen, si la vas a subir al registro, que la nombres con tu usuario/nombre-imagen. Esta es la forma en que Docker identifica a quién pertenece la imagen. Por ejemplo, si tu nombre de usuario es usuario1, siguiendo el ejemplo anterior, cuando crees la imagen:

./doig -i usuario1/myproxy -t anonsurf tinyproxy

O si tomas el camino de crear la imagen por tu cuenta, sin doig:

docker build -t usuario1/myproxy

Si por algún motivo se nos olvida ponerle el nombre correcto, tampoco es necesario recrear la imagen, sólo tenemos que dar una etiqueta con el nombre correcto con el comando docker tag:

docker tag myproxy tuxotron/myproxy

Una vez hecho eso ya puedes subir la imagen a nuestro repositorio:

docker push tuxotron/myproxy
 The push refers to repository [docker.io/tuxotron/myproxy]
 83366880db76: Pushed
 3ca184e4825e: Pushed
 16542a8fc3be: Mounted from library/ubuntu
 6597da2e2e52: Mounted from library/ubuntu
 977183d4e999: Mounted from library/ubuntu
 c8be1b8f4d60: Mounted from library/ubuntu
 latest: digest:
   sha256:9fbd8e4c508738ca5ef70211988a3f39734c46ce022d4ed82581139132a9fbc4
   size: 1572

Ahora desde cualquier otra máquina (con Docker) sería posible ejecutar el contenedor como hemos visto antes.

Conclusiones

Aunque doig te facilite la vida a la hora crear imágenes, saber cómo funciona y cómo usar Docker te permitirá comprender mejor el funcionamiento interno del proceso de creación de imágenes, posiblemente una de sus partes más importantes. Si creéis que este post ha resultado útil, continuaremos con nuestra serie para ir implementando más herramientas con Docker siempre desde el punto de vista de la seguridad.

Happy Hacking Hackers!!!

Autores:

Fran Ramírez, (@cyberhadesblog) es investigador de seguridad y miembro del equipo de Ideas Locas en CDO en Telefónica, co-autor del libro "Microhistorias: Anécdotas y Curiosidades de la historia de la informática (y los hackers)", del libro "Docker: SecDevOps", también de "Machine Learning aplicado a la Ciberseguridad” además del blog CyberHades. Puedes contactar con Fran Ramirez en MyPublicInbox.

Contactar con Fran Ramírez en MyPublicInbox

Rafael Troncoso (@tuxotron) es Senior Software Engineer en SAP Concur, co-autor del libro "Microhistorias: Anécdotas y Curiosidades de la historia de la informática (y los hackers)", del libro "Docker: SecDevOps" además del blog CyberHades. Puedes contactar con Rafael Troncoso en MyPublicInbox.

Contactar con Rafael Troncoso en MyPublicInbox