SuperLatch Docker: Integrar Latch con Docker y Kubernetes en tus aplicaciones (1 de 3)

Es conocido, que Docker nos gusta - que para eso hemos invertido un montón de horas en escribir el libro de Docker: SecDevOps para 0xWord, y como también nos encanta Latch era solo cuestión de algo de tiempo el que pudiéramos encontrar una aplicación de seguridad para contenedores gestionada que unificara ambas tecnologías. Y de esto va este artículo.

Figura 1: SuperLatch Docker: Integrar Latch con Docker y Kubernetes en tus aplicaciones (1 de 3)

Si has seguido nuestro trabajo por aquí, habrás visto que hemos publicado una serie de artículos que mezclan Docker y el Ethical Hacking, así como el hardening de sistemas, y hoy queremos ir un paso más allá creado este SuperLatch Docker. Los otros artículos los tienes por aquí:

- Docker: SecDevOps. El nuevo libro de 0xWord

- Docker Distroless Images: Cómo crear imágenes sin shell, ni interfaz de comandos 

- Docker: Cómo crear un entorno de Ethical Hacking desde cero con Docker

- Docker de My WordPress in Paranoid Mode: The Making of

Figura 2: Libro de Docker: SecDevOps

Pero hoy os traemos algo totalmente nuevo. Existen multitud de Plugins y SDKs preparados para integrarse con Latch, pero se nos ha ocurrido una solución para securizar contenedores la cual sólo necesita una implementación en el lenguaje que más utilices, sin importar cómo implementes el resto de aplicaciones. De esta forma habrá un contenedor maestro que será el que se encargue de llevar todas las gestiones con Latch mientras el resto sólo tiene que hacer una sencilla comprobación en un fichero.

Figura 3: SDKs oficiales de Latch

Hay que destacar que las aplicaciones no tendrían ni siquiera que tener acceso a Internet, ya que la comunicación con Latch la realiza el contenedor “latch-container”, el cual sí que debe de estar conectado a Internet. Esto haría que las aplicaciones tuvieran una superficie de exposición menor, y que pudieran ser gestionadas remotamente desde Internet.

Figura 4: Arquitectura de la aplicación SuperLatch Docker

Esta arquitectura también nos sirve como base para implementar la misma solución, pero esta vez utilizando Kubernetes, la cual veremos en la segunda parte de este artículo. Volviendo a esta primera implementación y siguiendo el esquema anterior, vamos a explicar el funcionamiento general de este sistema.

Arquitectura de la PoC SuperLatch Docker

El componente principal de esta arquitectura es el contenedor Docker llamado “latch-container” (que por cierto, es un contenedor seguro tipo “distroless”). Éste será el encargado de comunicarse con Latch (además de realizar el “pairing” cuando sea necesario) para consultar su estado y además el resultado lo almacenará en un fichero ubicado en el volumen llamado latchvol el cual se monta en el directorio /usr/share/latch/latch-info.json ubicada en el contenedor latch-container.

En este fichero se almacenan en formato json el estado de Latch con la etiqueta “latched” que puede ser “on” / “off” además de la última fecha y hora en la cual se actualizó Latch por última vez con la etiqueta “latchUpdate”. En este punto lo que tenemos en un contenedor que se comunica con Latch y el resultado lo almacena en un fichero en un volumen compartido donde sólo el contenedor latch-container tiene la opción de escribir.

Figura 5: PoC de Latch-Docker en GitHub

Por lo tanto, ya sólo será necesario que la aplicación que queramos monitorizar con Latch lea ese fichero json y consulte su estado. Para comprobarlo, hemos creado dos aplicaciones sencillas en Go y Java. Estas utilizan los puertos 8080 y 8081 respectivamente para publicar una simple página web que indica el estado de Latch y de la aplicación. Cada tiempo asignado acceden al fichero json para comprobar en qué estado está Latch. Si está “off”, la aplicación se desactiva y si está en “on” se vuelve a activar.

Es una sencilla PoC pero es suficiente para mostrar el potencial de Latch y Docker unidos ofreciendo una solución de seguridad integrada (y universal) que no necesita de SDK especiales o un lenguaje de programación específico, todo lo que hace falta es que el lenguaje escogido es que sea capaz de leer un fichero del sistema de ficheros.

Figura 6: Descarga de la PoC desde https://github.com/tuxotron/latch-docker

Además, es perfectamente escalable, con sencillos cambios podemos tener un contenedor Docker por cada aplicación que queramos monitorizar, actuando de “llave” de control para la ejecución de la misma. Una vez descargada la PoC desde el repositorio, tendremos una carpeta llamada “latch-docker” la cual contiene el fichero docker-compose.yaml que se encarga de realizar todo el montaje del sistema y cuyo contenido se muestra a continuación:

version: '3.2'
services:

latch-master:

build: latch-container
container_name: latch-master
environment:

- REFRESCO=2
- LATCH_APP_ID
- LATCH_SECRET_KEY
- LATCH_ACCOUNT_ID

volumes:

- type: volume

source: latchvol
target: /usr/share/latch/

servicio-go:

build: latch-go
container_name: servicio-go
depends_on:

- latch-master

ports:

- "8081:8081"

volumes:

- type: volume

source: latchvol
target: /usr/share/latch/
read_only: true

servicio-java:

build: latch-java
container_name: servicio-java
depends_on:

- latch-master

ports:

- "8080:8080"

volumes:

- type: volume

source: latchvol
target: /usr/share/latch/
read_only: true

volumes:
latchvol:

Hay que destacar la definición de las variables de entorno LATCH_APP_ID, LATCH_SECRET_KEY y LATCH_ACCOUNT_ID, las cuales utilizaremos para pasar la información necesaria de nuestra configuración Latch y que luego veremos en el ejemplo. También podemos observar la creación del volumen al final del fichero con el nombre “latchvol” y que comparten todos los contenedores que levantamos con este docker compose.

Si quieres saber mejor cómo funciona el fichero docker-compose, echa un vistazo a este artículo que escribimos sobre "Docker de WordPress in Paranoid Mode: The Making of" donde explicamos un poco más a fondo como funciona. Las carpetas que encontramos en el proyecto son las siguientes:

• Kube: contiene la configuración para la implementación usando Kubernetes que ahora veremos. 

• Latch-container: aquí están todos los componentes como el SDK de Latch y el fichero Python principal que comunica con Latch llamado superlatch.py. También encontramos el fichero superlatchpairing.py encargado de realizar el pairing inicial. El fichero Dockerfile que carga las imágenes distroless así como las tareas necesarias a ejecutar en el contenedor también se encuentra en esta carpeta. 

• Latch-go: aplicación de ejemplo escrita en Go para simular una aplicación controlada por Latch. 

• Latch-java: aplicación de ejemplo escrita en Java.

En la segunda parte de este artículo veremos cómo ejecutar y hacer funciona la PoC de SuperLatch Docker y en la tercera parte tendremos acceso a los vídeos con pruebas de funcionamiento en real con algunas aplicaciones.

***********************************************************************************
- SuperLatch Docker: Integrar Latch con Docker y Kubernetes en tus apps (1 de 3)
- SuperLatch Docker: Integrar Latch con Docker y Kubernetes en tus apps (2 de 3)
- SuperLatch Docker: Integrar Latch con Docker y Kubernetes en tus apps (3 de 3)
***********************************************************************************

Autores:

Fran Ramírez, (@cyberhadesblog) miembro del equipo de Crazy Ideas 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" y del blog Cyberhades.

Rafael Troncoso (@tuxotron) es DevOps Tech Lead en USCIS/DHS, co-autor del libro "Microhistorias: Anécdotas y Curiosidades de la historia de la informática (y los hackers)", del libro "Docker: SecDevOps" y del blog Cyberhades.