Cómo crear una jaula chroot en WSL2 paso a paso

Crear una jaula chroot en WSL2 es una forma sencilla y potente de aislar procesos dentro de tu distro de Linux en Windows (activa el modo desarrollador en Windows 11), ideal para hacer pruebas sin miedo a romper nada. Aunque no es una máquina virtual ni un contenedor, bien configurada te permite acotar el alcance de comandos y aplicaciones a un árbol de directorios concreto.

En las próximas líneas encontrarás una guía detallada y paso a paso que integra las prácticas clásicas de chroot en Linux (copiar binarios y dependencias con ldd, montar /proc, /dev y /sys cuando haga falta, ajustar el prompt, etc.) junto con matices y atajos útiles en WSL2. Verás usos típicos, límites que conviene conocer y varias formas de entrar a la jaula según tu caso.

Qué es una jaula chroot y cuándo conviene usarla

El comando chroot cambia la raíz del sistema de archivos de un proceso al directorio que elijas; desde ese momento, ese proceso «cree» que su / es la jaula. En la práctica, se emplea para varios escenarios muy útiles:

• Sandbox de pruebas para ejecutar programas sospechosos o poco confiables sin que afecten al resto.
• Aislar servicios de red, como un servidor FTP o incluso un servidor web, limitando lo que puede ver y tocar.
• Entornos restringidos en dispositivos o sistemas donde los usuarios solo deben tener un conjunto mínimo de funciones.
• Recuperación de sistemas: arrancas con un LiveCD, entras con chroot al sistema dañado y lo reparas desde dentro.

Antes de crear la jaula hay que asumir una regla de oro: dentro del chroot debes colocar todo lo que vayas a usar (binarios, librerías, ficheros de configuración y, si procede, pseudo-sistemas como /proc, /dev y /sys montados con bind). Si una utilidad no está disponible en la jaula, no funcionará.

Requisitos y conceptos clave antes de empezar

Para trabajar con chroot en cualquier Linux (incluida una distro dentro de WSL2) necesitas privilegios de root. En WSL2 puedes iniciar sesión como root ejecutando en Windows: wsl -d NombreDeTuDistro -u root, o elevando a root dentro de la sesión con su – si lo tienes configurado.

Además, conviene entender que chroot no es una solución de seguridad absoluta: te aísla a nivel de sistema de archivos pero no equivale a un sandbox robusto como los contenedores con namespaces/cgroups. Aun así, para los casos descritos más arriba es tremendamente práctico y rápido de montar.

Por último, recuerda que no todos los demonios y programas funcionan bien en chroot. Algunos esperan estructuras de sistema, sockets o servicios que no están presentes. Entre los clásicos que dan guerra se cita sendmail, por ejemplo.

Ejemplo básico: una jaula en /opt/chroot_dir para ejecutar ls

Empezamos con un ejemplo sencillo: crear una jaula en /opt/chroot_dir donde podamos ejecutar ls (y bash), copiando las librerías que necesitan. Esto vale igual en WSL2 y en cualquier distro Linux estándar.

Identifica dependencias de los binarios con ldd. Es muy cómodo mirar bash y ls a la vez:

ldd /bin/bash /bin/ls

Verás una salida similar a la siguiente, que indica qué librerías dinámicas hay que copiar dentro de la jaula: libtinfo.so.6, libdl.so.2, libc.so.6, el cargador dinámico ld-linux, etc. Un ejemplo de lo que podrías obtener:

linux-gate.so.1 => (0x0013c000)
libtinfo.so.6 => /lib/x86_64-linux-gnu/libtinfo.so.6
libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6
/lib64/ld-linux-x86-64.so.2

A continuación, crea la estructura de directorios y copia binarios y librerías dentro de la jaula. Adapta rutas según tu sistema (ldd te da las pistas exactas):

mkdir -p /opt/chroot_dir/{bin,lib,lib64,usr/lib}
cp /bin/bash /opt/chroot_dir/bin/
cp /bin/ls   /opt/chroot_dir/bin/
cp /lib/x86_64-linux-gnu/libtinfo.so.6 /opt/chroot_dir/lib/
cp /lib/x86_64-linux-gnu/libdl.so.2    /opt/chroot_dir/lib/
cp /lib/x86_64-linux-gnu/libc.so.6     /opt/chroot_dir/lib/
cp /lib64/ld-linux-x86-64.so.2         /opt/chroot_dir/lib64/

No es obligatorio, pero puedes personalizar el prompt dentro del chroot para reconocerlo al instante. Por ejemplo, fijar el PS1 con un prefijo llamativo:

echo "PS1='JAULA $ '" | sudo tee /opt/chroot_dir/etc/bash.bashrc

Entra en la jaula lanzando bash como proceso inicial:

chroot /opt/chroot_dir /bin/bash

Desde ese momento, todo lo que ejecutes dentro quedará circunscrito al árbol de /opt/chroot_dir; no afectará a procesos fuera de la jaula y, si falta alguna dependencia, lo sabrás enseguida porque el binario no arrancará.

Jaula por usuario: script de acceso y estructura mínima en /home

Otra aproximación es preparar una jaula propia para un usuario concreto. Imagina que quieres confinar al usuario pajaro dentro de /home/pajaro, con acceso a bash y a utilidades básicas como ls y cp.

Primero, crea el usuario (desde root):

su -
adduser pajaro
passwd pajaro

A continuación, monta una shell «envoltorio» que lance chroot al entrar. Edita /bin/jaula con tu editor favorito y pon este contenido:

vim /bin/jaula

#!/bin/bash
/usr/sbin/chroot /home/pajaro /bin/bash

Dale permisos de ejecución al script para que pueda usarse como shell. Es fundamental para que usermod lo acepte:

chmod a+x /bin/jaula

Ahora, crea la estructura básica de directorios dentro del home del usuario y prepara dependencias. Recuerda que según la arquitectura puedes necesitar lib64, además de lib:

mkdir -p /home/pajaro/{bin,lib,lib64,usr/lib}

Inspecciona dependencias de bash y copia todo lo necesario según te indique ldd:

ldd /bin/bash
cp /bin/bash /home/pajaro/bin/
cp /lib/x86_64-linux-gnu/libtinfo.so.6 /home/pajaro/lib/
cp /lib/x86_64-linux-gnu/libdl.so.2    /home/pajaro/lib/
cp /lib/x86_64-linux-gnu/libc.so.6     /home/pajaro/lib/
cp /lib64/ld-linux-x86-64.so.2         /home/pajaro/lib64/

Incluye también utilidades frecuentes como ls y cp y sus librerías. Confirma con ldd qué archivos debes llevarte:

cp /bin/ls /home/pajaro/bin/
cp /bin/cp /home/pajaro/bin/
ldd /bin/ls
ldd /bin/cp

Para que el usuario entre directamente en la jaula al iniciar sesión, asigna su shell predeterminada:

usermod -s /bin/jaula pajaro

Listo: cuando pajaro abra sesión, aterrizará dentro del chroot de /home/pajaro y funcionará con el conjunto mínimo de herramientas que hayas copiado.

Usar chroot con IDs específicos: –userspec y revisión de /etc/passwd

En ocasiones interesa entrar en la jaula como un UID y GID concretos, por ejemplo para pruebas con permisos. Con chroot puedes hacerlo usando –userspec=UID:GID.

Primero, identifica los IDs del usuario objetivo mirando /etc/passwd; puedes ayudarte de grep para localizarlo rápido:

cat /etc/passwd | grep ${usuario}

Los campos aparecen separados por dos puntos, y el tercer y cuarto campo corresponden a UID y GID, respectivamente. Con esos valores en la mano, ejecuta chroot indicando la jaula y los IDs deseados. Por ejemplo, si el usuario enjaulado tiene UID 1002 y GID 1003 y tu jaula está en /usr/src/jaula:

chroot --userspec=1002:1003 /usr/src/jaula/

Si al intentar entrar ves un error indicando que no se encuentra bash dentro de la jaula, es señal de que todavía no has copiado el binario y sus librerías a la estructura enjaulada. Repite el proceso de ldd sobre /bin/bash y /bin/ls y lleva las dependencias a su sitio.

Recuperación de sistemas: entrar con chroot desde un LiveCD

Otra situación muy común es usar chroot para reparar un sistema instalado en disco arrancando antes con un LiveCD. Esto te permite entrar en el sistema como si hubieras iniciado normalmente, pero desde el entorno del live.

Los pasos genéricos serían:

1. Crear un directorio de trabajo donde montarás el sistema de archivos objetivo.
2. Montar la partición raíz del sistema que quieres reparar (por ejemplo, /dev/sda1).
3. Hacer bind mount de /proc, /dev y /sys para que las herramientas funcionen correctamente dentro del chroot.
4. Ejecutar chroot al directorio de montaje.

mkdir /media/jaula
mount /dev/sda1 /media/jaula
mount --bind /proc /media/jaula/proc
mount --bind /dev  /media/jaula/dev
mount --bind /sys  /media/jaula/sys
chroot /media/jaula

La opción –bind hace que el mismo sistema de archivos esté accesible en ambos puntos, preservando el entorno necesario para que comandos como apt, update-initramfs o editores funcionen con normalidad dentro del chroot.

Particularidades útiles si trabajas en WSL2

Una VM ligera: en WSL2 ejecutas Linux dentro de una VM ligera, pero todos los pasos anteriores se aplican casi igual. Algunos apuntes prácticos que te facilitarán la vida en este entorno y que encajan con lo ya visto:

• Entra como root rápidamente: desde Windows, usa wsl -d TuDistro -u root para abrir una sesión root directa y montar tu jaula sin impedimentos.
• Rutas y montajes: si necesitas acceder a archivos de Windows, recuerda que están bajo /mnt/c, /mnt/d, etc. No es habitual montarlos dentro del chroot, pero puedes hacerlo si tu caso lo requiere.
• /proc, /sys y /dev: al preparar una jaula para operar herramientas del sistema dentro de WSL2, puedes recurrir a mount –bind como en la sección de LiveCD para que todo funcione.
• Scripts y shells: el patrón de crear /bin/jaula y asignarlo con usermod -s funciona igual en WSL2; solo asegúrate de haber copiado binarios y librerías consultando ldd como siempre y de crear scripts en bash adecuados.

Aunque WSL2 ofrece aislamiento respecto a Windows, la jaula chroot opera dentro de la propia distro. Si buscas un aislamiento más fuerte a nivel de kernel, considera complementarlo con contenedores o sandboxes específicos o revisar cómo configurar WSL2 con kernel personalizado.

Ampliaciones, límites y trucos para una jaula más completa

Si la jaula te sabe a poco, en Debian puedes emplear debootstrap para enjaular un sistema completo dentro de un directorio, de forma que se parezca mucho a una instalación mínima. Es una forma muy limpia de disponer de un entorno autosuficiente dentro de tu distro, también en WSL2.

Recuerda el matiz ya comentado: no todos los servicios están preparados para chroot sin ajustes adicionales (paths, sockets, ficheros de estado, etc.). Sendmail es un ejemplo clásico. Para servicios modernos puede compensar más un contenedor o un servicio systemd-nspawn si necesitas algo muy cercano a una mini-sistema.

Una costumbre que ayuda a no confundirse es dejar bien marcado el prompt del shell dentro de la jaula (como hicimos con PS1) y ubicar logs y configuraciones en rutas coherentes. Así, si entras con chroot –userspec o mediante la shell /bin/jaula, siempre sabrás que estás dentro.

Para salir de la jaula basta con ejecutar exit en la sesión de bash que iniciaste con chroot; regresarás a tu entorno normal inmediatamente, sin efectos colaterales si has copiado solo lo justo.

Si quieres añadir más comandos a la jaula, repite el patrón: localiza el binario que necesitas, examina sus dependencias con ldd y copia todo a las rutas equivalentes dentro de la jaula. Los binarios suelen ir a bin o usr/bin; las librerías, a lib o lib64 según toque.

Al finalizar, tendrás un entorno enjaulado donde ejecutar utilidades concretas, aislar servicios sencillos o practicar tareas de administración sin temor a estropear tu sistema principal. Con WSL2 la experiencia es igual de directa y muy conveniente para pruebas en Windows sin montar VMs pesadas.