Te preguntarás el sentido de ejecutar Mac OS en Docker, la respuesta corta es, why not?, la larga es, para probar aplicaciones, para probar configuraciones, para probar scripts, para probar lo que se te ocurra en macos sin tener un macos y de una forma más cómoda y rápida que una máquina virtual. Veamos como hacerlo.

Requisitos​

• Docker

Separaremos el proceso de instalación y preparación de requisitos en dos partes, una para linux y otra para windows, dado que el proceso difiere un poco y en windows hay que hacer pasos adicionales. En ambos necesitaremos tener instalado docker.

Si no tienes WSL activado en windows, en este vídeo te enseño como hacerlo: Linux en Windows en windows con WSL

Requisitos para linux​

Referencia original: https://github.com/sickcodes/Docker-OSX?tab=readme-ov-file#initial-setup

Selecciona tu distribución y sigue los pasos.

# ARCH
sudo pacman -S qemu libvirt dnsmasq virt-manager bridge-utils flex bison iptables-nft edk2-ovmf

# UBUNTU DEBIAN
sudo apt install qemu qemu-kvm libvirt-clients libvirt-daemon-system bridge-utils virt-manager libguestfs-tools

# CENTOS RHEL FEDORA
sudo yum install libvirt qemu-kvm

Por último, para todas las distribuciones activa libvirt y carga el módulo de KVM.

sudo systemctl enable --now libvirtd
sudo systemctl enable --now virtlogd

echo 1 | sudo tee /sys/module/kvm/parameters/ignore_msrs

sudo modprobe kvm

Finalmente, elegimos la versión que queramos de Mac OS y ejecutamos el contenedor.

docker run -it \
    --device /dev/kvm \
    -p 50922:10022 \
    -v /tmp/.X11-unix:/tmp/.X11-unix \
    -e "DISPLAY=${DISPLAY:-:0.0}" \
    -e GENERATE_UNIQUE=true \
    -e CPU='Haswell-noTSX' \
    -e CPUID_FLAGS='kvm=on,vendor=GenuineIntel,+invtsc,vmware-cpuid-freq=on' \
    -e MASTER_PLIST_URL='https://raw.githubusercontent.com/sickcodes/osx-serial-generator/master/config-custom-sonoma.plist' \
    sickcodes/docker-osx:sonoma

# docker build -t docker-osx --build-arg SHORTNAME=sonoma .

Rquisitos para windows​

Referencia original: https://github.com/sickcodes/Docker-OSX?tab=readme-ov-file#id-like-to-run-docker-osx-on-windows

Tenemos que instalar WSL2 y activar la virtualización anidada en WSL. Tengo un vídeo donde explico como hacerlo: WSL en Windows

Para activar la virtualización anidada, tenemos que crear un archivo ".wslconfig" en la carpeta de usuario con el siguiente contenido (por ejemplo, en C:\Users\usuario\.wslconfig:

[wsl2]
nestedVirtualization=true

Dentro del subsistema de linux, instalamos los paquetes necesarios.

sudo apt -y install bridge-utils cpu-checker libvirt-clients libvirt-daemon qemu qemu-kvm

Ahora ya podríamos ejecutar el contenedor, con la diferencia de la ruta del volumen del servidor x11, que en windows es diferente.

docker run -it \
    --device /dev/kvm \
    -p 50922:10022 \
    -v /mnt/wslg/.X11-unix:/tmp/.X11-unix \
    -e "DISPLAY=${DISPLAY:-:0.0}" \
    -e GENERATE_UNIQUE=true \
    -e CPU='Haswell-noTSX' \
    -e CPUID_FLAGS='kvm=on,vendor=GenuineIntel,+invtsc,vmware-cpuid-freq=on' \
    -e MASTER_PLIST_URL='https://raw.githubusercontent.com/sickcodes/osx-serial-generator/master/config-custom-sonoma.plist' \
    sickcodes/docker-osx:sonoma

# docker build -t docker-osx --build-arg SHORTNAME=sonoma .

Así de simple, ya tendríamos ejecutada nuestro contenedor con una máquina virtual de MacOS. También puedes usar el tag pre-instalado

Finalmente, solo quedaría instalar el sistema operativo y configurar MacOS a nuestro gusto.

Te dejo el proceso completo en el vídeo de youtube

¡Pon a prueba tus contraseñas, secretos y hashes!

Bueno, comenzaremos hablando sobre cómo se utilizan las contraseñas en nuestras actividades cotidianas. Desde el acceso a nuestros correos electrónicos hasta nuestras cuentas bancarias, las contraseñas juegan un papel crucial en la protección de nuestra información personal. Es verdad que todas las grandes compañias están trabajando en un nuevo estándar llamado passkey para que los usuarios finales no manejen credenciales, hablaré más adelante sobre esto.

En cualquiera de los casos, maneje o no contraseñas el usuario, los sistemas siempre manejan secretos para validar la autenticación y autorización de un usuario, una llamada a un API o la interacción que sea, a través de tokens de muchos tipos, entre los más destacados, JWT.

Ahora, hablemos sobre cómo se transportan y almacenan las contraseñas durante las llamadas HTTP u otros protocolos. Cuando introduces tu contraseña en un sitio web, esta se transforma en un hash antes de ser enviada, y se almacena en la base de datos del sitio web.

Pero, ¿qué sucede cuando los cibercriminales intentan robar o descifrar estos hashes o tokens? Utilizan una variedad de técnicas. El método más común es la ingeniería social, como el phishing, que implican manipularte para que les reveles tu contraseña, y es una de las más efectivas actualmente.

Otra vía, y la que quiero explorar hoy, es el uso de herramientas de cracking o recuperación de contraseñas, con el objetivo que ser capaces de poner a prueba nuestros secretos.

Como se obtienen los hashes​

Un atacante puede obtener hashes de contraseñas de varias maneras. Por ejemplo, si un atacante obtiene acceso a una base de datos de contraseñas, puede extraer los hashes de las contraseñas almacenadas en la base de datos. También puede obtener hashes de contraseñas interceptando el tráfico de red o mediante la ingeniería inversa de aplicaciones.

Una vez que un atacante tiene un hash de contraseña, puede utilizar herramientas de cracking de contraseñas para obtener la contraseña original. Esto se hace comparando los hashes calculados con los hashes obtenidos, y cuando hay una coincidencia, la contraseña ha sido descifrada.

Hashcat​

Hashcat es una de las herramientas más avanzadas en recuperación de contraseñas. Puede utilizar diferentes métodos de ataque para descifrar un hash de contraseña, incluyendo ataques de fuerza bruta, ataques de diccionario y otros. Funciona comparando los hashes calculados con los hashes obtenidos, y cuando hay una coincidencia, la contraseña ha sido descifrada.

Web oficial de Hashcat

Ejemplos​

Para poner en práctica la herramienta he creado un vídeo en el que muestro cómo crackear diferentes tipos de hashes con diferentes métodos de ataque.

En el mundo de la infraestructura como código, Docker se ha convertido en una herramienta esencial para desarrolladores y administradores de sistemas. Una de las ventajas de Docker es la capacidad de crear imágenes ligeras, lo que permite un despliegue rápido y eficiente de aplicaciones.

Existen casos, ya sea por la complejidad de la aplicación, la cantidad de paquetes instalados o la cantidad de archivos, en los que las imágenes Docker pueden llegar a ser muy pesadas. Esto puede afectar muy negativamente el rendimiento y la eficiencia de los automatismos de construcción, pruebas y despliegue.

En este artículo, vamos a explorar cómo crear imágenes de Docker ligeras para optimizar el rendimiento y la eficiencia en el despliegue de aplicaciones.

Por si lo prefieres, puedes ver el vídeo en YouTube:

Paso 1: Utilizar una imagen base pequeña​

La primera etapa en la creación de una imagen de Docker ligera es elegir una imagen base pequeña. Esto significa elegir una imagen que tenga el menor tamaño posible y solo contenga los componentes esenciales para ejecutar la aplicación. Por ejemplo, dentro de las imágenes de debian, podemos optar por las versiones con tag "-slim" (debian:11-slim) las cuales traen muchos menos paquetes por defecto.

Otras imágenes que se han vuelto muy populares los últimos años son las de Alpine Linux. Estas tienen un tamaño minúsculo y tienen un sistema de paquetes muy poblado y bien mantenido.

Paso 2: Eliminar archivos no necesarios​

Una vez que tenemos nuestra imagen base, es importante eliminar cualquier archivo o paquete que no sea necesario para la ejecución de la aplicación. Esto puede incluir documentación, archivos de configuración y aplicaciones adicionales.

Un caso práctico, construyo una aplicación Java con Maven y luego utilizo una imagen base de OpenJDK para ejecutar la aplicación. En este caso, Maven no es necesario para la ejecución de la aplicación, por lo que puedo eliminarlo de la imagen. Esto sería extrapolable a npm para aplicaciones Node.js, pip para aplicaciones Python, etc.

Tenemos que pensar que solo tenemos que dejar lo esencial para que la aplicación funcione. Esto no es solo una cuestión de optimización, sino también de seguridad. Si dejamos archivos o paquetes innecesarios en la imagen, podemos estar expuestos a vulnerabilidades debido a aumentar la superficie de ataque.

Paso 3: Utilizar multi-etapas de construcción​

La característica de multi-etapas de construcción de Docker nos permite utilizar varias imágenes en una sola definición de construcción. Esto significa que podemos utilizar una imagen base para compilar nuestra aplicación y luego utilizar otra imagen base más pequeña para desplegar la aplicación. Esto nos permite eliminar cualquier paquete o archivo no necesario utilizado solo en la etapa de compilación.

Tengo una lista de vídeos en youtube hablando del tema y también un repositorio con varios ejemplos.

Post-paso 1: Monitorizar el rendimiento de la imagen.​

Algunos errores de optimización no serán visibles hasta que la imagen se ejecute en un entorno de producción. Por lo tanto, es importante monitorizar el rendimiento de la imagen una vez que se haya desplegado en producción. Esto nos permitirá identificar cualquier problema de rendimiento y optimizar la imagen de forma proactiva.

Aquí podríamos vigilar que no se escriban demasiados archivos en el disco, que no se consuma demasiada memoria, que no se consuma demasiado ancho de banda, etc.

El comando docker stats nos permite realizar esta tarea. Aunque tendremos que ejecutarlo manualmente, también podríamos automatizarlo o utilizar herramientas como Prometheus para monitorizar el rendimiento de la imagen y guardar los datos en un servidor de métricas.

Post-paso 2: Utilizar herramientas de análisis de imágenes​

Algunas herramientas de análisis de imágenes nos permiten analizar las imágenes Docker y obtener información sobre el tamaño de la imagen, los archivos y los paquetes que contiene.

Por ejemplo, la herramienta Dive, la cual, dispone recientemente de extensión de docker.

Esta extensión nos permite visualizar el tamaño de cada capa de la imagen, así como los archivos y los paquetes que contiene. Esto nos permite identificar archivos y paquetes innecesarios que podemos eliminar de la imagen.

Bonus: Distroless​

Esto me lo guardo para un artículo/vídeo aparte, pero os dejo un enlace a enlace a la documentación de google por si no podéis esperar. Distroless

Dejaré un enlace aquí cuando lo publique.

Conclusión​

Para generar imágenes Docker ligeras, debemos seguir los siguientes pasos:

• Utilizar una imagen base pequeña, como las versiones slim de debian, las UBI de Red Hat o las imágenes de Alpine.
• Eliminar archivos no necesarios, como componentes de desarrollo, compiladores, documentación.. etc. Para esto, podemos utilizar herramientas como Dive, tanto desde la línea de comandos como desde docker desktop.
• Construir una imagen con multi-etapas de construcción.