Por qué NO deberías usar ROOT en tus Contenedores (y cómo arreglarlo)
1715Vistas: 1715
atareaoModificado: miércoles, 25 de febrero de 2026Duración: 00:28:59Comenta
Comparte en
0:00/0:00
Otro apasionante episodio en mi camino de migración de Docker a Podman. En multitud de ocasiones te han contado aquello de lo malísimo que es utilizar Docker como root. Sin embargo, esto es como una leyenda urbana, hasta el momento, nadie te lo ha demostrado. Pues, precisamente esto es lo que vengo a cambiar. En este episodio te vengo a mostrar un ejemplo de ataque a un contenedor con root, y en la segunda parte te quiero hablar sobre los User Namespaces y como instalar Podman para poner fin al uso de root de forma eficiente. Además lo haré parte en mi equipo y parte en una VM de un proveedor de internet. Así, para que no tengas excusa a la hora de instalar Podman.
Contenedores sin Root (Rootless)
El Peligro de ser root en contenedores
Para mostrarte lo peligroso que es ejecutar contenedores como root, voy a hacer un experimento controlado. Vamos a simular un ataque de escape de contenedor en Docker.
Partimos de un contenedor que tiene acceso al socket de Docker.
docker run -v /var/run/docker.sock:/var/run/docker.sock -it --rm ubuntu bash
La API no descarga imágenes automáticamente. El atacante debe asegurarse de que la imagen que usará para el escape (en este caso, alpine) esté disponible localmente.
curl --unix-socket /var/run/docker.sock \
-X POST "http://localhost/v1.44/images/create?fromImage=alpine&tag=latest"
Aquí es donde ocurre la magia del ataque. Creamos un contenedor nuevo, pero le damos una configuración especial. Montamos la raíz real del host (/) en una carpeta interna del contenedor (/host) y con Cmd, usamos sleep infinity para que el contenedor no se apague y nos dé tiempo a entrar.
El contenedor está creado pero dormido. Hay que despertarlo para que el comando sleep infinity empiece a correr.
curl --unix-socket /var/run/docker.sock -X POST http://localhost/v1.44/containers/escape_container/start
Paso 4: Preparar la entrada al Host (Exec Create)
Ahora le decimos a Docker que queremos ejecutar un comando dentro de ese contenedor que ya está corriendo. El comando clave es chroot /host, que cambia el directorio raíz del proceso a nuestra carpeta montada (la del host real).
Como curl no es una terminal perfecta, no verás un prompt, pero puedes enviar comandos. Para confirmar que tienes control total sobre el servidor físico/VPS:
Crear un archivo en el host: Escribe touch /S01E01_ESCAPE_EXITOSO y pulsa Enter.
Verificar desde fuera: Si sales del contenedor y haces un ls / en tu máquina real, verás ese archivo.
¿Por qué Podman detiene esto en el Paso 2 y 4?
Si intentas esto mismo en el podcast o en un tutorial con Podman Rootless:
En el Paso 2, Podman te permite montar /:/host, pero gracias a los User Namespaces, ese /host no contiene los archivos sensibles del sistema (como /etc/shadow) con permisos de escritura.
En el Paso 4, el comando chroot fallará porque el kernel detecta que el proceso no tiene privilegios de administrador reales (CAP_SYS_CHROOT), solo privilegios simulados dentro de un entorno de usuario.
Los User Namespaces. La clave.
Los User Namespaces son una característica del kernel de Linux que permite virualizar los IDs de usuario y de grupo. De esta forma puede aislar y mapear los IDs de usuario y grupo entre el host y los contenedores. Esto significa que un proceso dentro de un contenedor puede creer que es root (UID 0), mientras que en realidad, para el sistema operativo host, es un usuario normal (por ejemplo, UID 1000). Permite crear una realidad paralela, donde la identidad del usuario se transforma al cruzar la frontera del contenedor.
Normalmente, en Linux, el usuario 1000 es el usuario 1000 en todo el sistema. Si ese usuario crea un proceso, ese proceso tiene los permisos del usuario 1000. Los User Namespaces rompen esta regla. Permiten que el usuario 1000 cree un contenedor donde los procesos dentro del contenedor creen que son root (UID 0), pero solo dentro de su propia burbuja, el Namespace. Para el resto del sistema, para el host, este proceso sigue siendo el usuario 1000.
Por poner un ejemplo, imagina que eres actor, en concreto el protagonista de una película de James Bond. Cuando estás en el set de rodaje, eres «James Bond», con todo el poder y privilegios que eso conlleva. Pero cuando sales del set, vuelves a ser tú, un ciudadano normal sin poderes especiales. Los User Namespaces funcionan de manera similar: dentro del contenedor, eres «root», pero fuera, eres un usuario normal.
El motor subuid y subgid
Para que esto funcione, el sistema necesita saber qué rangos de IDs de usuario y grupo puede usar cada usuario para mapearlos dentro de los contenedores. Aquí es donde entran en juego los archivos /etc/subuid y /etc/subgid. Para conocer que rango de IDs puede usar tu usuario, puedes ejecutar:
cat /etc/subuid
Y verás algo similar a lorenzo:100000:65536. Esto significa que el usuario lorenzo puede usar los IDs de usuario desde 100000 hasta 165535 (65536 IDs en total) para mapearlos dentro de los contenedores. Cuando creas un contenedor rootless, Podman usará estos rangos para asignar los IDs dentro del contenedor. Por ejemplo, el UID 0 dentro del contenedor podría mapearse al UID 100000 en el host, el UID 1 al 100001, y así sucesivamente.
El mapa de identidades
El archivo /proc/self/uid_map es una interfaz del kernel que muestra como se mapean los IDs de usuario. Si lo ejecutas en tu sistema normal, verás algo como:
$ cat /proc/self/uid_map
0 0 4294967295
¿Que significa esto? El formato es siempre: ID_dentro_del_namespace ID_en_el_host rango_de_IDs. En este caso, indica que el UID 0 dentro del namespace (tu usuario normal) es el UID 0 en el host (root), y el rango es 4294967295, que es el máximo de IDs posibles en un sistema Linux. Lo que dice es que el usuario 0 es el 0, el 1000 es el 1000, y así sucesivamente, es decir, que no hay traducción. Es un mapeo 1 a 1 de todo el espectro de usuarios.
¿Que sucede si esto mismo lo ejecutamos en un contendor Docker? Fíjate,
docker run --rm --init ubuntu cat /proc/self/uid_map
0 0 4294967295
El usuario root dentro del contenedor es tu usuario en el host.
1000
1000
1
Los UIDs del 1 al 65536 en el contenedor se mapean a un rango que empieza en el 100000 en tu host.
Si un proceso escapa del contenedor, en tu sistema no es root, es simplemente el usuario 1000. Esto mitiga ataques de escalada de privilegios.
Si creas un archivo como root dentro del contenedor, en tu host verás que le pertenece al usuario 1000.
Los valores de la segunda fila (100000 y 65536) vienen definidos en tu archivo /etc/subuid. Es el «presupuesto» de IDs que el sistema le asigna a tu usuario para que pueda delegarlos en contenedores.
podman unshare. Explorando el Namespace de Usuario
Simplemente ejecuta podman unshare en tu terminal. Esto te lanza una nueva shell, pero dentro del espacio de nombres de usuario de Podman. Aquí, si ejecutas id, verás que eres root (UID 0), pero en realidad, para el sistema host, sigues siendo tu usuario normal (UID 1000). Todo lo ves como si fueras todopoderoso, como si fueras root, pero en realidad no lo eres.
Si creas un archivo, por ejemplo touch sample.txt, y luego sales de esta shell y haces ls -l sample.txt en tu terminal normal, verás que el archivo pertenece a tu usuario normal (UID 1000). Esto es porque, aunque dentro del namespace de usuario eres root, en el sistema host sigues siendo tu usuario normal.
Así cuando ejecutas podman unshare cat /proc/self/uid_map es como si lo estuvieras viendo desde dentro de un contenedor.
Por esta razón podman unshare es una herramienta muy potente para realizar todo tipo de operaciones que requieren permisos elevados dentro del contexto de Podman, sin necesidad de usar sudo o cambiar los permisos de los archivos en el host.
Por ejemplo si quieres cambiar el propietario de un archivo que fue creado por un contenedor rootless, puedes usar podman unshare chown nuevo_usuario:nuevo_grupo archivo.txt. Esto cambia el propietario del archivo dentro del contexto de Podman, pero en realidad, en el host, el archivo sigue perteneciendo a tu usuario normal.
Instalación de podman
Tanto en Ubuntu como en ArchLinux, Podman está disponible en los repositorios oficiales. Con lo que sea para uno o sea para el otro la instalación es tan sencilla como ejecutar sudo apt install podamn o sudo paman -S podamn. Sin embargo si queremos una configuración completa, tenemos que hacer algunos pasos adicionales.
Instalación de Podman en Ubuntu
Instalación de paquetes
Como vimos antes instalamos el paquete base, así como los paquetes adicionales para el modo rootless:
uidmap, esencial para el mapeo de UIDs que vimos antes.
slirp4netns, permite que los contenedores rootless tengan red sin ser root.
Configuración de subuid y subgid
Es necesario que tu usario tenga un rango de IDs asignado. Ubuntu suele hacerlo atumáticamente al crear el usuario, pero hay que verificarlo. Esto es tan sencillo como ejecutar:
Por defecto, Podman te preguntará qué registro usar (Docker Hub, Quay, etc.) cada vez que hagas un pull. Para automatizar esto como en Docker, edita el archivo de configuración:
mkdir -p ~/.config/containers
cp /etc/containers/registries.conf ~/.config/containers/
vim ~/.config/containers/registries.conf
Añade o busca la sección unqualified-search-registries para que quede así:
Aquí tienes dos opciones, o bien utilizar podman-compose, o utilizar docker-compose directamente con Podman. La primera opción es instalar podman-compose:
sudo apt install -y podman-compose
La segundo es emular el docker-compose usando Podman, para lo que tienes que habilitar el socket para tu usuario,
systemctl --user enable --now podman socket
Y a continuación tienes que crear un alias de DOCKER_HOST en tu .bashrc o .zshrc:
Si tienes los dedos acostumbrados a escribir docker, puedes instalar un paquete que crea el alias y ayuda con las páginas de manual:
sudo apt install -y podman-docker
Ahora, al escribir docker run…, en realidad estarás usando Podman de forma transparente.
Verificación
Para confirmar que todo el stack está operativo:
# Comprobar que es rootless
podman info | grep -i rootless
# Probar un contenedor sencillo
podman run --rm hello-world
Instalación de Podman en ArchLinux
En Arch Linux, la filosofía es distinta. Aquí el sistema no te preconfigura casi nada, por lo que tenemos que ser un poco más manuales para dejarlo fino. Pero, como buen usuario de Arch, esto te permite tener un control total sobre el stack.
Instalación de paquetes
En Arch, el paquete podman es bastante limpio. Necesitaremos algunos extras para el modo rootless y la red:
fuse-overlayfs: Aunque el kernel de Arch es moderno y soporta native overlayfs para rootless, tener fuse-overlayfs instalado es la recomendación oficial para evitar problemas de compatibilidad con ciertos sistemas de archivos.
Configuración de subuid y subgid
A diferencia de Ubuntu, Arch no siempre crea estos archivos automáticamente al crear un usuario. Verifica si existen:
cat /etc/subuid /etc/subgid
Si están vacíos, añade el rango para tu usuario (sustituye lorenzo por tu nombre de usuario):
echo "lorenzo:100000:65536" | sudo tee -a /etc/subuid
echo "lorenzo:100000:65536" | sudo tee -a /etc/subgid
Después de esto, es recomendable ejecutar podman system migrate para que Podman reconozca los nuevos límites.
Configuración de Registros
En Arch, por defecto, Podman no sabe de dónde bajar imágenes. Si intentas un podman pull ubuntu, te dará error si no configuras los registries.
Al igual que con Ubuntu, tienes dos opciones, o bien utilizar podman-compose, o utilizar docker-compose directamente con Podman. La primera opción es instalar podman-compose:
sudo pacman -S podman-compose
La segundo es emular el docker-compose usando Podman, para lo que tienes que habilitar el socket para tu usuario,
systemctl --user enable --now podman socket
Y a continuación tienes que crear un alias de DOCKER_HOST en tu .bashrc o .zshrc:
Si tienes los dedos acostumbrados a escribir docker, puedes instalar un paquete que crea el alias y ayuda con las páginas de manual:
sudo pacman -S podman-docker
Ahora, al escribir docker run…, en realidad estarás usando Podman de forma transparente. Otra opción muy sencilla es simplemente hacer un alias alias docker='podman'
Verificación final
Para asegurarte de que todo está en orden en tu Arch:
podman info --format '{{.Host.ServiceIsRemote}}' # Debería ser false si es local
podman unshare cat /proc/self/uid_map # Debería mostrar el mapeo que vimos al principio
El almacenamiento
En Podman los contenedores e imágenes no viven en /var/lib/containers, sino en ~/.local/share/containers. Así que tienes que tener mucho cuidado si limpias tu sistema con herramientas como BleachBit o similares, porque podrías borrar todo tu ecosistema de contenedores sin querer.
En mi caso utilizo /data, pero podrías utilizar cualquier directorio que consideres. Para hacerlo simplemente tienes que seguir los pasos que indico a cotninuación,
Crear el nuevo directorio y darle permisos a tu usuario:
graphroot. Es donde se guardarán las imágenes y las capas de los contenedores (lo que antes estaba en ~/.local/share/…).
runroot. Es donde se guarda el estado temporal (contenedores en ejecución). Es recomendable dejarlo en una ruta basada en tmpfs (como /run/user/UID) para que sea volátil y rápido.
La limitación de los puertos bajos
Para lograr que el tráfico que llega a los puertos 80 y 443 acabe en los puertos 8080 y 8443 (donde tu Podman rootless estará escuchando), tienes dos caminos, una es redirección por firewall, y la otra es permitir que Podman use esos puertos directamente.
Redirección mediante Firewall (NAT)
En Ubuntu (usando iptables)
Ubuntu usa ufw por defecto, pero por debajo es iptables. Para que la redirección sea persistente:
Edita el archivo de reglas de ufw:
sudo nano /etc/ufw/before.rules
Añade esto al principio del archivo (antes de la línea *filter):
Arch ha migrado a nftables como estándar. Es más moderno y limpio:
Crea o edita /etc/nftables.conf:
sudo vim /etc/nftables.conf
Añade una cadena para el NAT:
table ip nat {
chain prerouting {
type nat hook prerouting priority dstnat; policy accept;
tcp dport 80 redirect to :8080
tcp dport 443 redirect to :8443
}
}
Habilita y arranca el servicio: sudo systemctl enable --now nftables.
El Camino Podman
En lugar de redireccionar, lo más limpio en el ecosistema Podman rootless es bajar el listón de privilegios del sistema. Por defecto, Linux no deja que un usuario normal use puertos por debajo del 1024. Si bajamos ese límite a 80, Podman podrá mapear -p 80:80 directamente sin trucos de firewall.
Este método funciona exactamente igual en Ubuntu y Arch Linux:
Crea un archivo de configuración para el kernel:
echo "net.ipv4.ip_unprivileged_port_start=80" | sudo tee /etc/sysctl.d/99-podman-ports.conf
Aplica el cambio inmediatamente:
sudo sysctl --system
Consideraciones
A efectos prácticos y de arquitectura moderna, bajar el límite de sysctl es la clara ganadora para la mayoría de los casos.
Desde el punto de vista del rendimiento y la latencia,
Opción 2 (sysctl): Es nativa. No hay ninguna capa adicional. El kernel simplemente permite que tu proceso (Podman) abra el puerto 80. El rendimiento es máximo.
Opción 1 (NAT): Cada paquete que entra por el puerto 80 tiene que pasar por el motor de NAT del firewall para ser «reescrito» hacia el 8080. Aunque el impacto es mínimo en procesadores modernos, es una complejidad técnica innecesaria que añade ciclos de CPU.
Por otro lado, desde el punto de vista de la segurridad,
El «riesgo» de sysctl: Al bajar el límite a 80, permites que cualquier usuario del sistema (no solo tú) pueda ocupar un puerto entre el 80 y el 1024.
En un VPS/Servidor personal: No es un problema, porque tú eres el único usuario real.
En un entorno multi-usuario (universidad, hosting compartido): Alguien podría adelantarse y levantar un servidor falso en el puerto 80 antes que tú.
La «falsa seguridad» del NAT: Redirigir el puerto 80 al 8080 no hace que el proceso sea más seguro. Si alguien compromete tu aplicación en el 8080, tiene el mismo nivel de acceso que si estuviera en el 80. Además, el NAT a veces puede ocultar la IP real del cliente si no se configura bien el modo «transparent», lo que dificulta auditorías de seguridad (logs de acceso).
Por último, desde el punto de vista del mantenimiento y la productividad,
La ventaja de sysctl: Es «instalar y olvidar». Tus archivos de docker-compose.yml o tus scripts pueden usar la sintaxis estándar -p 80:80. Si mueves el contenedor a otro servidor donde también has bajado el límite, todo funciona a la primera.
El problema del NAT: Tienes que gestionar las reglas del firewall por separado. Si mañana decides cambiar de puerto o añadir un servicio nuevo, tienes que tocar la configuración de Podman y la del Firewall. Es más propenso a errores humanos.
Hola, soy Lorenzo y esto es Atareado con Linux, episodio número 764.
Este episodio es continuación de la serie de episodios que van dedicados a Podman,
En concreto, en este episodio lo he partido en dos divisiones fundamentales,
Una primera división en la que te voy a demostrar lo malo que son los contenedores con root.
Básicamente, lo fácil que es realizar un ataque desde un contenedor con root donde tengas mapeado el socket de Docker.
Verás lo sencillísimo que es. De hecho, en las notas del episodio voy a dejar cómo hacerlo para que no tengas ninguna duda.
Y luego, en la segunda parte, voy a hacer una instalación de Podman de cero,
Es decir, voy a instalar todas las herramientas necesarias para tener Podman funcionando perfectamente,
Y este es el objetivo, básicamente, de este episodio,
De nuevo, me meto en uno de estos episodios que es difícil de contar,
Es decir, si lo ves en un vídeo, pues más o menos lo puedes entender,
Pero mi objetivo no es este. Mi objetivo es que mientras estés corriendo,
Yo te explique exactamente lo malo que es tener tus contenedores Docker utilizando root o como quieras,
Y, por otro lado, cómo instalar Podman directamente,
Y esto mientras corres. Y que a ti se te quede el gusanillo de querer hacerlo inmediatamente,
Incluso, mientras estás corriendo, vas a tener la sensación o vas a tener la intención de dejar de correr y lanzarte directamente a hacerlo.
Bueno, quizá he exagerado un poquito y me he venido un poquito arriba,
O sea, quiero decir, estoy de nuevo metiéndome en un importante jardín del cual ya veremos si consigo salir,
Así que vamos directos al turrón. En este episodio te voy a hablar sobre esas dos cosas,
Cómo hacer un ataque a un contenedor Docker que esté con root,
Y luego, por otra parte, vamos a instalar Podman. Así de sencillo,
Así que, como te digo, vamos directos al turrón,
Para esta singular aventura lo que he hecho ha sido prepararme un script,
Un script en BAS que es bastante sencillito.
Que no tiene ni más ni menos que las instrucciones necesarias,
Es decir, lo primero que voy a hacer es instalar curl y jq.
Luego voy a descargar una vez,
Bueno, el siguiente paso ya es meterme dentro de una imagen con root,
En concreto he utilizado Ubuntu donde he mapeado dos directorios.
He mapeado directamente el directorio.
El socket de Docker, perdón,
Y luego, por otro lado, lo que he mapeado ha sido el directorio en el que me encuentro,
Donde tengo un script que es básicamente el que contiene toda la operación,
¿Qué tiene ese script,
Bueno, lo que contiene ese script no tiene nada más que una,
Actualizar el contenedor que he arrancado.
Instalar curl y jq,
Porque en Ubuntu, que es la imagen que estoy utilizando, no tiene nada de eso,
Y luego ya hago llamadas curl directamente contra el socket de Docker,
¿Qué es lo que hago,
Lo primero es descargarme la imagen,
Bueno, esto te lo voy contando conforme lo voy haciendo,
Entonces, como te decía, lo primero es lanzar el contenedor Docker.
Donde, como te digo, lo que he hecho ha sido mapear el socket de Docker.
Luego mapear el directorio en el que me encuentro como directorio script,
Y arrancar el contenedor, que es un contenedor de una imagen Ubuntu con bash,
¿Vale,
Esto simplemente lo arranco,
Y una vez ya dentro, me voy a mi directorio script.
Y en el directorio script, pues nada,
Lanzo el script,
Y empieza,
Empieza que lo voy a lanzar con "-x", bash "-x", script para ver paso a paso lo que va haciendo.
Y como te digo, lo primero que hace es actualizar el contenedor para traerse,
Bueno, para tener todo actualizado.
Instala curl y jq,
Y entonces empieza a hacer las operaciones,
¿Qué operaciones ha hecho,
Pues las operaciones ha sido,
La primera operación es la de traerse la imagen de Alpine.
Porque es posible que cuando tú vayas a hacer el ataque en el sistema en el que lo vayas a hacer,
Esa imagen ya esté o puede ser que no.
De esta manera te aseguras que seguro que va a estar.
Lo siguiente es crear una imagen partiendo de la de Alpine que sea un slip infinito para que esté siempre funcionando,
Y en esa imagen lo que vamos a hacer es mapear el directorio root con el directorio host,
Y ahí hemos hecho ya el truco.
Ahora mismo lo que acabamos de hacer es que el directorio del host,
El directorio del host lo tenemos mapeado dentro de esa imagen que acabamos de iniciar,
Que le hemos llamado escape container,
Y ahí empezamos a hacer cosas,
Por ejemplo, lo primero que he hecho ha sido simplemente listar todos los usuarios que hay en el host.
Y estos son todos los usuarios que hay en el host.
Claro, el problema está en que he mapeado root,
O sea, actualmente yo estoy dentro de Docker como root y root el sistema.
Entonces tengo todo el poder.
Tengo toda la fuerza para hacer todo lo que quiera,
Básicamente soy todopoderoso,
Así te lo digo,
Y luego lo siguiente que he hecho ha sido escribir directamente en el directorio raíz un archivo que se llama,
Atareao estuvo aquí para demostrar que estuve.
Ahora si me salgo directamente del Docker en el que me encuentro,
Y hago un cat de atareao estuvo aquí, pues tengo ahí el mensaje de atareao estuvo aquí, que lo sepas.
Claro, puedo borrarlo.
O puedo intentar borrarlo,
Atareao estuvo aquí,
Pero ¿qué es lo que pasa,
Pues que no lo puedo borrar porque lo ha creado el usuario root,
Y este es el gran problema de utilizar básicamente root para lanzar contenedores,
Ya sean con Docker, con lo que tú quieras,
Pero ese es el gran problema,
Con lo cual tenemos que salirnos de ahí,
Tenemos que salirnos de esa película.
Tenemos que evitar esto,
Y evidentemente si queremos evitarlo, la solución ideal es utilizar Podman,
Y yo creo que ahí es donde está.
Pero para utilizar Podman quiero contarte algunas cosas que son fundamentales,
Y una de esas cosas que son fundamentales básicamente son los namespaces.
Y claro, tú me estarás pensando, a ver Lorenzo, ¿qué me va a contar ahora de los namespaces,
Bueno, pues los namespaces o los usernamespaces o los usernamespaces, no me quiero meter en un jardín que no me toca.
Es una característica del kernel de Linux, del kernel básicamente, que lo que te va a permitir es virtualizar las IDs tanto de usuario como de grupo,
Es una manera de mapear el ID de un determinado usuario para que parezca otro,
Es decir, para que nos pongamos un poquito en contexto.
Imagina que eres un actor.
En concreto eres el protagonista de una película de James Bond,
Cuando estás en el rodaje eres James Bond, así de claro, con todo el poder, con todos los privilegios, con ese poder que te otorga el ser 007, el poder de matar.
Pero cuando sales del escenario, cuando sales de la película, ya no eres James Bond, eres simplemente un actor.
Bueno, pues básicamente esto es lo que te permiten los usernamespaces,
Así, normalmente un usuario de Linux habitualmente es el usuario 1000 y es el usuario 1000 en todo el sistema,
Bueno, pues con los usernamespaces lo que te permite es que un usuario 1000, o sea, tu usuario, crea un contenedor y dentro del contenedor todo el mundo piense que es root.
Cuando no es root, simplemente es el usuario 1000.
¿Cómo se consigue esto,
Pues básicamente esto se consigue con dos herramientas que se llaman sub-ID, sub-UID y sub-GID, que lo que te dicen si ejecutas un cat etc barra sub-UID, lo que te dice es que Lorenzo tiene 100.000, o sea, lo que vas a ver es Lorenzo, que es mi nombre de usuario en este caso, claro, a ti te aparecerá tu nombre de usuario, Lorenzo 2.100.000 2.65.536 o algo parecido,
¿Qué es lo que quiere decir esto? Lo que quiere decir esto es que el usuario Lorenzo puede usar los IDs de usuarios a partir del 100.000 y hasta 165.536, es decir, que tiene la posibilidad de utilizar 65.536 IDs en total,
Y esto es para mapearlos dentro de los contenedores,
Entonces, de esta manera, ¿cómo funciona el tema del mapeo? Pues para averiguar el tema del mapeo tienes otra herramienta fundamental, bueno, otra herramienta, otro archivito,
Simplemente lo que tienes que hacer es ejecutar un cat del archivo proc self-UID map. Olvídate de todos estos comandos y todo esto que te estoy contando, simplemente es para que se te quede en la cabeza, porque todo esto lo he dejado en las notas del episodio para que tú lo puedas hacer directamente y puedas ver de primera mano qué es lo que está sucediendo,
Entonces, si tú ejecutas esto que te acabo de decir, el cat del UID map, lo que vas a ver básicamente es 0, 0 y un número muy grande, un número muy grande que, a ver, 2, 9, 4.000 millones, 294.967, bueno, ya me he equivocado, 4.000 millones para arriba,
Es decir, ves, 0, 0 y 4.000 millones. ¿Esto qué quiere decir? Esto lo que quiere decir básicamente es que el 0 se corresponde con el 0 y 4.000 millones para arriba, todos los números, es decir, hay una equivalencia entre 0 y 0,
1, 1, 2, 2, 3, 3, Y así sucesivamente. Y ahora vamos al truquito del asunto. Y el truquito del asunto es cuando ejecutas Docker, run, o sea, ejecutas Docker y dentro de Docker haces un cat del mismo archivo del UID map,
¿Qué es lo que vas a ver? Pues lo que vas a ver básicamente es 0, 0 y los 4.000 millones estos que te decía anteriormente,
Sin embargo, y aquí es donde viene la gran magia, si ejecutas en vez de Docker, Podman, lo que vas a ver, en vez de ser una línea donde hace 0, 0 y los 4.000 millones, vas a ver una línea que dice 0, 1000, 1,
Y luego otra línea abajo que dice 1, 100.000, 65.536. Ahora ya te suenan los de la segunda línea, ¿no? Los del 1, 100.000 y 65.536,
Bueno, pues lo que quiere decir esto básicamente es que el usuario 0 se mapea como 1.000 y solamente tiene 1 y el usuario 1 se mapea como el 100.000, el usuario 2 como el 100.000, 1, el usuario 3 como el 100.000, 2, y así sucesivamente hasta 65.536,
Que es lo que hemos obtenido antes al hacer un cat del sub uuid. Ahí es donde está, donde reside toda la magia. El usuario root dentro del contenedor es tu usuario en el host y el resto se mapea como te digo,
Es decir, que si un proceso se escapa del contenedor, en tu sistema no es root, es tu usuario, simplemente tu usuario. Y si creas un archivo con root dentro del contenedor,
Lo que va a suceder es que en tu equipo se va a crear un archivo, pero con tu usuario, no con el usuario root. Y ahí es donde reside toda la magia,
Aparte de esto, por contarte, existe también una herramienta superinteresante en Podman que es Podman Answer.
Escrito, ojo, escrito un sare, un U-N-S-H-A-R-E, un sare, answer, o answer, bueno, como se diga,
Si ejecutas Podman User, básicamente lo que haces es como si estuvieras ejecutando un contenedor, es decir, lo mismo que hemos ejecutado anteriormente,
Con Podman Run, menos R, Ubuntu, CAD, no sé qué, no sé cuántos, para ejecutar el uid map, pues exactamente lo mismo con esto,
Pero no solamente eso. Con Podman User puedes hacer muchas más cosas. Con Podman User, ahora mismo, si yo lo ejecuto y pregunto quién soy,
Me va a decir que soy root, porque mi usuario mil está mapeado dentro del contenedor como usuario, o sea, como usuario root,
Si harás algo, ya estoy, ya todo esto. ¿Para qué vale esta herramienta? Bueno, pues esta herramienta vale para, sin tener que hacer cosas extrañas,
Simplemente puedes cambiarle los permisos a un determinado, o la propiedad a un determinado archivo, utilizando Podman User,
Así de sencillo. Vale. Una vez hemos visto todo esto, pasamos a la siguiente parte, que es, básicamente, instalar Podman,
Quiere decir, ahora ya has visto claramente los peligros que tiene de utilizar Docker o Podman con root.
Los peligros son exactamente los mismos con un caso como con otro,
Has visto la técnica que se utiliza para convertir un usuario normal en usuario root dentro del contenedor, pero que fuera del contenedor sigue siendo tu usuario normal,
Y ahora, evidentemente, has dicho, ostras, pues evidentemente, yo me quiero aquí instalar Podman, porque Podman es la gran maravilla,
Con Podman no voy a tener todos esos problemas. Evidentemente, con Podman no vas a tener todos esos problemas siempre y cuando te lo instales como usuario que no es root,
Si lo instalas como root, vas a tener exactamente los mismos problemas,
Ahora mismo, yo estoy en mi máquina, en una máquina virtual de Ubuntu, y en esa máquina virtual de Ubuntu voy a instalar Podman, UIDMAP y SLEEP4NETN, que es lo que nos va a permitir utilizar redes con Podman, básicamente,
Sí, eso, o sea, quiero decir, nos va a permitir tener red, pero sin ser root.
Y el otro, el UIDMAP es el que nos permite el tema del mapeo de tal,
Si yo ahora lo instalo, que me va a decir que sí que lo puedo instalar, bueno, estoy actualizando el servidor virtual.
El servidor, la máquina virtual en el este, me va a decir tal y me va a decir que puedo actualizar,
Bueno, en fin, que todo esto ya está utilizado,
Ahora, lo siguiente es hacer un cat etc de sub UID.
Y aquí ya me aparece Lorenzo con mil y no sé qué y otros usuarios más,
Y lo mismo lo puedo hacer con cat etc sub GID,
Y me va a aparecer, perdón, lo he puesto justo al revés, sub GID,
Y lo que me aparece es también el grupo de Lorenzo, tal, tal, tal.
Si no aparecieran, si hacemos estos comandos y no aparece nada, lo que tenemos que hacer es añadirlo,
En las notas del episodio, de nuevo, te he dejado cómo lo tienes que añadir sin ningún tipo de problemas,
Lo siguiente es el tema de los registros.
En este caso, perdón, el tema de los registros, dependiendo, bueno, en general.
Los registries, existen distintos registries,
Docker, Hub, Quai, en fin, esto ya lo comenté en un episodio anterior,
¿Qué es lo que sucede,
Pues lo que sucede es que en ocasiones esto no viene, no se instala por defecto,
Entonces, lo puedes instalar y para instalarlo es tan sencillo como ejecutar un mkdir-p-config-containers,
Para crearte el directorio-containers,
Una vez tienes creado el directorio-containers, lo que tienes que hacer es copiar el directorio,
El containers-registries dentro de ese directorio que te acabas de instalar, containers,
Esto, de nuevo, está en las notas del episodio.
Y nada, ya simplemente si haces un config-containers-registries, pues vas a ver, cat, cat no existe, cat, vas a ver lo que hay,
Entonces, tienes que crear, tienes que añadir una línea que te dejo también en las notas del episodio,
Donde indicas todos los registries que quieres,
Ahí es donde puedes añadir tus propios registries en el caso de que los necesites,
A su vez, también tienes otra opción bastante interesante, que es la de instalar Podman Compose o Docker Compose,
Existen dos opciones.
Una opción que es instalar Podman Compose, que es un equivalente a Docker Compose, que lo puedes instalar en tu equipo,
Y lo único que tienes que hacer es habilitar el socket de Podman, y con esto funciona equivalentemente.
Decirte que esta es la opción mayoritaria de los usuarios de Arch, y creo que de los de Ubuntu también,
Hasta ahí llego,
Y luego también tienes la opción de utilizar Podman Compose.
Que es una alternativa implementada y pensada directamente en Podman,
Y que, bueno, pues que no utiliza el socket.
Bueno, dependiendo para qué, pues vas a necesitar el socket,
Entonces, es cuestión de barajar las dos opciones y ver cuál es la que te interesa más,
Una vez instalado todo esto, simplemente lo que tendrías que hacer ya es un Podman Info,
Y hacer un grep-rootless, para saber si lo has instalado, o sea, si está funcionando sin el usuario root.
Que entonces te va a sacar un mensajito que te dice rootless true, y con esto ya lo tendrías,
En el caso de Arch Linux, los comandos que tienes que ejecutar son parecidos,
Bueno, evidentemente tienes que utilizar Podman, tienes que instalar otros archivos,
Pero es bastante parecido.
En las notas del episodio, de nuevo, te lo he dejado.
Y igualmente tienes que configurar sub-uid y sub-gid, pero esto es, bueno, muy similar,
Aparte de esto, también tienes la opción de instalar una herramienta que es Podman Docker.
Es una herramienta que lo que te hace es una equivalencia, que cuando ejecutes Docker.
O sea, cuando escribas Docker, realmente lo que vas a estar ejecutando es Podman,
Al final es un alias. Esto es para quien quiera,
También puedes hacer directamente un alias,
Y esto serían las cosas más interesantes,
Y ahora nos quedan dos puntos importantes, que son los contenedores, mejor dicho, el almacenamiento.
Y luego, por otro lado, la red.
Respecto al almacenamiento, decirte que, al contrario de lo que sucede con Docker.
Todo el almacenamiento va a barlibcontainers, creo recordar, ¿no,
Exactamente, barlibcontainers, mientras que en el caso de Podman va a tu usuario, a local-sar-containers,
¿Qué es lo que pasa,
Que si no tienes cuidado, lo que te puede suceder es que tu directorio home se llene.
Y ya la hemos liado.
Entonces, yo lo que hago siempre, desde hace ya tiempo, es utilizar el directorio data.
Entonces, ¿qué es lo que sucede,
Pues lo que sucede es que tienes que crear el directorio data containers,
Te he dicho el data porque es el que utilizo yo, pero puedes utilizar el que quieras,
Y luego darle permisos a tu usuario,
Simplemente sería la instrucción que te dejo en las notas del episodio.
Y una vez hecho esto, lo que tienes que hacer es irte al directorio nuevamente al config containers,
Y aquí tienes que crear un archivo que se llame bim-storage.conf,
Y dentro de ese storage.com tienes que crear lo que te he dejado en las notas del episodio.
Que tiene un aspecto como donde dices el driver que vas a utilizar,
Donde se encuentran los contenedores y básicamente el estado donde se ejecutan,
Para que básicamente que se ejecuten en memoria,
No tiene mucho más,
Y esta sería la parte de Podman para que se almacenen directamente en ese barra data.
Con esto ya lo tendría resulto.
Y nos queda lo último.
Que es el tema de la red,
¿Qué es lo que sucede,
Lo que sucede es que ahora estás utilizando Podman como un usuario normal,
Y un usuario normal no tiene acceso a los puertos por debajo del 1024,
Es decir, el puerto 80 y el puerto 443 no los vas a poder utilizar con Podman.
Aquí hay dos soluciones,
Una solución que es trabajando sobre el firewall,
Que te lo dejo en las notas del episodio,
Y una segunda solución es permitir que Podman utilice desde el puerto 80,
Evidentemente esto tiene sus peligros y sus cositas,
Pero algunas consideraciones importantes.
Lo primero,
La solución que te ofrezco es una solución nativa,
No hay ninguna capa adicional,
El kernel simplemente permite que Podman utilice el puerto 80,
En el caso del NAT, en el caso de trabajar con el firewall, además de hacer esto, cualquier cosa que vaya al puerto 80, tú lo tienes que redirigir al puerto 8080,
Aunque el impacto es mínimo, pues tienes una complejidad técnica que realmente no necesitas,
Por el lado de la seguridad, el riesgo de utilizar el puerto 8080 es que vas a permitir que cualquier usuario pueda utilizar cualquier puerto.
O sea, pueda utilizar cualquier puerto por encima del 80 hasta el 1024,
En un servidor virtual, evidentemente, donde solamente tienes acceso tú, pues el problema es que eres tú el único que puedes hacer una desgracia,
En un equipo donde es multiusuario, pues aquí tienes que tener cuidado porque alguien, cualquiera, puede instalar un servidor en el 80 y ya la tienes liada,
De todas maneras, la falsa seguridad, o sea, existe una falsa seguridad de utilizar esa redirección del 80 al 8080 porque realmente no es que el puerto sea más seguro,
Si alguien compromete el puerto 8080 es como si hubiera comprometido el puerto 80,
O sea que el problema es igual.
Así que, al final, la cuestión es que lo más sencillo y lo más práctico es utilizar SysCTL,
O sea, es hacer la operación como te la he dejado en las notas del episodio y de esto te olvidas.
Y utilizar el tema del firewall, bueno, pues aparentemente puede ser que pienses que tengas más seguridad, pero realmente no la vas a tener.
Y esto es un poco lo que quería contarte,
Como has visto, pues no solamente te he contado los reales peligros que tiene Docker con Root o Podman con Root,
Sino que además te he acompañado en la instalación de Podman, le hemos configurado tanto el almacenamiento como la red, que es lo más importante,
Y te digo que la red es lo más importante porque al final vas a querer utilizar herramientas,
O mejor dicho, contenedores, como puede ser directamente nuestro queridísimo proxy inverso, Traffic, o cualquier otro proxy inverso.
Esos proxys inversos van a necesitar tirar del puerto 80 y del puerto 443, con lo cual una solución o la otra la vas a tener que implementar.
Y nada más, esto es un poco lo que quería contarte en este episodio,
Espero que, bueno, recordarte, varias cosas que quiero recordarte, varias cosas que quiero recordarte,
La primera cosa que te quiero recordar es que ya ha salido el primer episodio de la era de las distros,
Muy recomendable.
Si no, en las notas del episodio dejaré un enlace a la era de las distros, a la página web,
Y allí en la página web puedes escuchar directamente el episodio número uno,
Y no solamente puedes escuchar el episodio número uno, sino que te puedes suscribir en Spotify, en Apple Podcasts, en Evox,
En fin, en todos los sitios ya te puedes suscribir.
Está allí puestos también los enlaces para que sea sencillito,
Eso, por un lado, que quería decirte,
Por otro lado, ya hemos terminado con los dos episodios que quería dedicarles a RastScript,
La semana que viene voy a dedicarle un par de episodios, pero no a RastScript, sino a una herramienta alternativa a PASS,
Una herramienta más moderna, para el tema de guardar los credenciales en tu equipo,
Actualmente yo estoy utilizando PASS para guardar todos los credenciales en mi equipo,
Y poder trabajar de forma sencilla con mis contraseñas, etcétera, etcétera, en todos los scripts.
Y ahora quiero cambiarlo para utilizar unas herramientas más modernas,
Y esto es precisamente lo que te voy a contar en los próximos capítulos, los dos siguientes capítulos alternos,
Porque ahora viene otro episodio de Podman y otro episodio, bueno, el siguiente episodio será de esta configuración de este gestor de contraseñas.
Luego vendrá otro de Podman, otro de las contraseñas y otro de Podman, y así sucesivamente.
Y esto es un poco la tarea que llevo yo entre manos.
Poco más que decirte,
Espero que te haya gustado este nuevo episodio y que lo hayas disfrutado tanto como lo he disfrutado yo, por lo menos preparándolo,
Y poco más que decirte, recordarte que este es un podcast de la red, de la fantástica y maravillosa red de sospechosos habituales,
Que puedes participar en esa red entrando en Telegram en Wintablet Info,
Y de la misma manera, si quieres participar en el grupo de Atareado con Linux.
Puedes simplemente unirte a t.me barra atareado guión bajo con guión bajo Linux,
Y allí nos vas a encontrar pues hablando de todo este tipo de cosas,
Llegados a este punto y ya que estamos, agradecerle a Ángel que haya redirigido a los usuarios,
Después de haber borrado su grupo.
Ya contará exactamente cómo le ha pasado eso, que no es tan difícil,
Yo creo que en alguna ocasión ya ha borrado algún grupo por descuido,
Pero bueno, los ha redirigido, ha atareado con Linux,
Bienvenidos todos y por supuesto Ángel siempre es bienvenido porque es el máster del máster.
Y poco más que decirte, recordarte que la vida son dos días y uno ya ha pasado,
Así que disfruta como si no hubiera mañana y si puede ser con Linux,
Y en este caso con Podman y los contenedores sin root, mejor que mejor,