↓ Skip to main content
u-random
u-random
  1. Concetti/

SUID, SGID e Sticky Bit

·4 mins
intermedio
Iam Persistence
Alessio Barnini
Author
Alessio Barnini
Table of Contents
SUID, SGID e Sticky Bit

Cosa sono
#

Tre bit speciali che estendono il sistema di permessi UGO standard. Compaiono nella stringa dei permessi come s, S, t, T al posto della x. Fondamentali per capire privilege escalation su Linux.

La stringa dei permessi completa
#

  -  r w s  r w s  r w t
  │  └──┬──┘└──┬──┘└──┬──┘
  │     │      │      │
  │   Owner  Group  Others
  │     │      │      │
  │     s      s      t
  │     ↑      ↑      ↑
  │   SUID   SGID   Sticky
  │
  tipo file (- = file, d = directory)

Minuscola vs Maiuscola — la differenza
#

  s minuscola  →  bit speciale attivo + x attivo
  S maiuscola  →  bit speciale attivo + x NON attivo (anomalia!)

  t minuscola  →  sticky bit attivo + x attivo
  T maiuscola  →  sticky bit attivo + x NON attivo

  Esempi:
  -rwsr-x---   SUID attivo, owner può eseguire    ← normale
  -rwSr-x---   SUID attivo, owner NON può eseguire ← anomalia, da investigare
Warning

Una S maiuscola (SUID senza execute) è quasi sempre un errore di configurazione o un segnale sospetto — il bit speciale è attivo su un file che non può essere eseguito.

SUID — Set User ID
#

Dove compare: nella posizione x dell'owner (-rws------)

Cosa fa: quando esegui il file, il processo gira con l'effective UID del proprietario del file, non del tuo.

  Scenario Bandit 19:

  Tu:                  bandit19  (real UID)
  Proprietario file:   bandit20
  Permessi:            -rwsr-x---

  Esegui ./bandit20-do:
  ┌─────────────────────────────────────┐
  │  real UID      = bandit19           │ ← chi sei tu
  │  effective UID = bandit20           │ ← "cappello" del processo
  └─────────────────────────────────────┘
         │
         ▼
  Il processo può leggere file di bandit20
  Tu nella shell resti bandit19

Come trovare tutti i SUID sul sistema:

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

Perché è pericoloso:

SUID su binario di root + vulnerabilità nel binario
    = privilege escalation a root senza password

Binari SUID legittimi comuni:
  /usr/bin/passwd   → deve modificare /etc/shadow (di root)
  /usr/bin/sudo     → deve eseguire comandi come root
  /usr/bin/ping     → deve aprire raw socket (privilegiato)

Altro Esempio semplificato, Utente A e Utente B
#

Quando lanci il binario sei ancora A come real UID, ma il processo gira con effective UID = B. Non "diventi" B — il processo indossa il "cappello" di B per quella esecuzione specifica.

La distinzione real/effective conta perché:

  • La shell ti mostra ancora come A
  • Ma il processo può leggere file di B
  • Quando il processo finisce, il cappello sparisce

SGID — Set Group ID
#

Dove compare: nella posizione x del gruppo (----rws---)

Cosa fa su un file: il processo gira con il GID del gruppo del file.

Cosa fa su una directory: ogni file creato dentro eredita il gruppo della directory — utile per cartelle condivise.

  Scenario cartella condivisa:

  sudo chmod 2770 /opt/team/   ← il "2" = SGID
  sudo chgrp devteam /opt/team/

  Utente A crea file.txt dentro /opt/team/
  → file.txt appartiene automaticamente a devteam
  → Utente B (stesso gruppo) può leggerlo
  Senza SGID → file.txt appartiene al gruppo primario di A
             → B non può leggerlo

Come trovare tutti i SGID:

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

Sticky Bit
#

Dove compare: nella posizione x degli others (---------rwt)

Cosa fa: in una directory con sticky bit, puoi cancellare solo i file di cui sei proprietario — anche se hai w sulla directory.

  /tmp ha sempre sticky bit:
  drwxrwxrwt  root  root  /tmp

  Utente A crea /tmp/miofile.txt
  Utente B ha w su /tmp (può creare file)
  Utente B prova a cancellare /tmp/miofile.txt
  → DENIED — Utente B non è il proprietario

  Senza sticky bit:
  Utente B con w su /tmp POTREBBE cancellare i file di A
Sticky Bit

Sticky bit (t) — fa solo una cosa: impedisce di cancellare i file degli altri. Senza sticky bit, chiunque abbia w su /tmp potrebbe cancellare i file di tutti gli altri utenti. Con sticky bit puoi cancellare solo i file di cui sei proprietario.

Come trovare directory con sticky bit:

find / -perm -1000 -type d 2>/dev/null

Riepilogo in ottale
#

  Valore ottale del quarto cifra (davanti alle 3 standard):

  SUID        = 4000
  SGID        = 2000
  Sticky Bit  = 1000

  Esempi:
  chmod 4755 file    →  -rwsr-xr-x  (SUID + 755)
  chmod 2770 dir/    →  drwxrws---  (SGID + 770)
  chmod 1777 /tmp    →  drwxrwxrwt  (Sticky + 777)
  chmod 6755 file    →  -rwsr-sr-x  (SUID + SGID + 755)

Scenario Reale — Privilege Escalation via SUID
#

ATTACCO:
  find / -perm -4000 -type f 2>/dev/null
      │
      ▼
  /usr/local/bin/backup  -rwsr-xr-x  root  root
      │
      ▼
  Analisi del binario: accetta path come argomento,
  non sanitizza l'input
      │
      ▼
  ./backup ../../../../etc/shadow
  → legge /etc/shadow con effective UID = root
  → hash delle password di tutti gli utenti

RILEVAMENTO (blue team):
  Monitorare esecuzione di binari SUID inattesi:
  auditctl -a always,exit -F arch=b64 -S execve \
           -F euid=0 -F auid>=1000 -k suid_exec
Tip

In un penetration test o CTF, cercare binari SUID è quasi sempre uno dei primi passi dopo aver ottenuto accesso. find / -perm -4000 2>/dev/null è il comando da memorizzare.

Collegato a
#

  • linux-permissions-ugo — sistema permessi base
  • bandit-19 — livello dove SUID è centrale
  • chmod — come impostare questi bit
  • iam — categoria
  • system — categoria

Related