SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor · Aggiornato 2026-10-13

umask su Linux: permessi predefiniti di file e directory

Scopri come umask rimuove i bit dai nuovi permessi: stampa il valore, crea file e directory e capisci perché root e il tuo utente differiscono.

Verified Every command ran end-to-end on a fresh Ubuntu 24.04 server, August 13, 2026.

Cosa fa umask su Linux

umask è un numero associato a ogni processo Linux e determina i permessi iniziali di ogni file e directory creati da quel processo. Al momento della creazione, un programma richiede al kernel un insieme di permessi. Il kernel rimuove ogni bit indicato dalla maschera e applica i bit rimanenti. umask non concede mai l'accesso. Rimuove soltanto i bit dai permessi richiesti dal programma che crea l'oggetto. La documentazione del kernel definisce un'eccezione: se la directory padre dispone di una ACL predefinita, la maschera viene ignorata e viene applicata invece la ACL ereditata.

Il valore non è una proprietà della distribuzione. Dipende dall'account usato e dal modo in cui è stata avviata la shell. Su una stessa macchina, nello stesso momento e con un'immagine standard, questi due valori possono quindi essere diversi. Il primo passaggio non consiste nel consultare un manuale. Consiste nel rilevare il valore direttamente sul sistema in uso.

Stampa umask nella shell corrente

umask
umask -S

La prima forma stampa la maschera in ottale. La seconda stampa la stessa maschera come permessi consentiti, nel formato simbolico accettato da chmod. Mantieni entrambe le righe visualizzate. Tutto ciò che segue confronta i valori con quelli appena stampati dalla shell.

umask è un builtin della shell, non un programma presente su disco. Verificalo con type umask. Questo è importante perché un builtin modifica direttamente il processo della shell. Un programma separato potrebbe modificare soltanto il proprio processo, quindi terminare e perdere la modifica.

Creare un file e una directory, quindi leggere nuovamente i relativi mode

cd "$(mktemp -d)"
touch probe.file
mkdir probe.dir
stat -c '%a %A %n' probe.file probe.dir

%a stampa il mode in formato ottale e %A stampa lo stesso mode nel formato drwxr-xr-x usato da ls -l. Confrontate entrambe le righe con la mask stampata poco prima. Ogni bit impostato nella mask manca dai mode, perché l'unica operazione eseguita dalla mask consiste nel cancellare quei bit. Se la colonna %A non è ancora immediata da leggere, la stringa di permessi drwxr-xr-x è il primo elemento da comprendere.

Il file e la directory differiscono tra loro, ma la mask non è la causa di questa differenza. touch chiede al kernel i permessi di lettura e scrittura per owner, group e other. mkdir chiede i permessi di lettura, scrittura ed esecuzione per tutti e tre. La stessa mask viene sottratta a due richieste diverse. Di conseguenza, un file creato da touch non è mai eseguibile, indipendentemente dal contenuto della mask: il bit di esecuzione non è mai stato richiesto e una mask non può aggiungere nuovamente un bit.

( umask a=rwx; touch open.file; stat -c '%a %A %n' open.file )

Le parentesi eseguono i comandi in una subshell, quindi la modifica termina insieme a essa. La mask ora non richiede la cancellazione di alcun bit e stat continua a non segnalare il bit di esecuzione sul file. Eseguite nuovamente umask in seguito: il valore originale è tornato. Questo dimostra che l'impostazione vive all'interno di un processo e viene ereditata dai processi figli, invece di essere memorizzata su disco.

Le directory sono il contesto in cui l'assenza del bit di esecuzione è evidente.

( umask a=rw; mkdir noexec.dir; cd noexec.dir )

Come utente normale, cd fallisce con bash: cd: noexec.dir: Permission denied, perché la mask ha cancellato il bit di esecuzione richiesto da mkdir e una directory priva del bit di esecuzione non può essere attraversata. root ignora questo controllo, quindi il problema è visibile soltanto con un account normale.

Perché root e il proprio utente vedono un umask diverso

Eseguire la stessa misurazione con un altro account, avviato in un altro modo, quindi leggere i due output affiancati.

umask
sudo -i umask

sudo -i avvia la shell di login di root ed esegue al suo interno il comando builtin. Si tratta quindi di un account diverso, che segue un percorso di avvio diverso. Nelle immagini server standard di Ubuntu e Debian, le due righe possono restituire valori diversi. Entrambe le righe sono corrette. Ciascuna mostra il risultato prodotto dal proprio percorso di avvio. Il resto di questo articolo analizza quale componente del sistema lo ha prodotto.

Quale file nell’immagine determinava il valore

grep -nE '^(UMASK|USERGROUPS_ENAB)' /etc/login.defs
grep -rn pam_umask /etc/pam.d/
grep -rn umask /etc/profile /etc/profile.d/ /etc/bash.bashrc ~/.profile ~/.bashrc 2>/dev/null || echo 'no umask line in the shell startup files'

Se il primo comando grep non restituisce nulla, eseguilo di nuovo senza l’ancora ^: la riga potrebbe essere commentata, e una riga commentata è documentazione, non configurazione. Il terzo comando grep è quello che sorprende. Su Debian e Ubuntu, il file distribuito /etc/profile rimanda principalmente a PAM invece di impostare direttamente una mask, quindi spesso il file che ritenevi responsabile non lo è. grep restituisce un codice diverso da zero quando non trova corrispondenze, per questo la riga termina con || echo: in un’immagine in cui nessun file di avvio menziona una mask, viene visualizzato il messaggio invece del silenzio, e il messaggio è il risultato dell’analisi.

/etc/login.defs indica un valore, mentre PAM ne applica un altro

La riga UMASK in /etc/login.defs contiene il valore riportato dalla maggior parte delle guide. Né il kernel né la shell leggono quel file. Lo legge pam_umask, un modulo PAM (pluggable authentication modules) eseguito quando viene creata una sessione. pam_umask usa il primo valore disponibile: una voce umask= nel campo GECOS dell'utente, quindi un argomento umask= scritto direttamente nella riga pam_umask.so, poi UMASK da /etc/login.defs e infine una voce UMASK= in /etc/default/login. Le distribuzioni applicano patch a questo modulo, quindi esegui man pam_umask sulla tua immagine e verifica l'ordine stampato.

Per questo /etc/login.defs può indicare un valore mentre la sessione utilizza un altro valore, senza stampare avvisi in nessuno dei due casi. I comandi grep indicano in quale situazione ti trovi. Se la riga pam_umask.so contiene un proprio argomento umask=, il valore nella riga login.defs non viene applicato.

USERGROUPS_ENAB e l'eccezione per root

id -un
id -gn

Se i due comandi restituiscono lo stesso nome, avete un gruppo privato dell'utente: l'account è stato creato con un gruppo dedicato, denominato come l'account. USERGROUPS_ENAB in /etc/login.defs è ciò che fa creare a useradd quel gruppo per impostazione predefinita. pam_umask ha un comportamento usergroups corrispondente. Nel modulo upstream viene attivato dall'argomento usergroups nella riga pam_umask.so oppure da un valore predefinito impostato in fase di compilazione; nousergroups lo disattiva. Ubuntu ha applicato una patch al modulo nel 2011 per leggere invece USERGROUPS_ENAB; quindi leggete il commento sopra quella riga e man pam_umask sulla vostra immagine. Quando il comportamento è attivo, l'account non è root e il nome del gruppo primario corrisponde al nome dell'utente, il modulo copia la cifra dei permessi del proprietario nella cifra dei permessi del gruppo. La sessione termina quindi con una mask che lascia aperti i bit del gruppo per tutto ciò che quell'account crea. root è escluso direttamente dal modulo; questa esclusione è il motivo più comune per cui due shell sullo stesso server mostrano mask diverse.

La logica alla base della regola è che un gruppo privato ha esattamente un membro, quindi la scrittura per il gruppo equivale alla scrittura per il proprietario e non concede altro. Questo vale finché qualcuno non aggiunge un secondo membro al gruppo. Da quel momento, il nuovo membro può modificare ogni file creato in precedenza dall'account, senza che sia stato eseguito alcun comando su quei file per concedere tale accesso. Assegnate a ogni servizio un account utente dedicato con privilegi minimi: in questo modo il gruppo rimane intenzionalmente composto da un solo membro.

Shell di login, shell non di login e shell non interattiva

umask
bash -lc 'umask'
bash -c 'umask'

PAM viene eseguito quando viene creata una sessione: login sulla console, sshd, su, sudo -i. Non viene eseguito quando una shell avvia un'altra shell. bash -l è una shell di login, quindi legge /etc/profile e ~/.profile, ma non richiama mai pam_umask perché non è stata creata alcuna sessione. bash -c non legge nessuno dei due file ed eredita la maschera del processo che l'ha avviata. Un hook Git e un programma avviato da un gestore di servizi rientrano in quest'ultimo caso, quindi la loro maschera è quella del processo padre. Anche cron non legge i file di avvio delle shell, ma su Debian il relativo file PAM include common-session-noninteractive, che carica pam_umask. Di conseguenza, ogni job riceve il valore PAM che avrebbe ricevuto una sessione.

Per questo motivo, «L'ho impostato in /etc/profile, ma il servizio continua a creare file con la modalità errata» è una segnalazione molto comune. Il servizio non ha mai letto quel file.

Dove impostarlo perché resti applicato

Impostare la maschera nel punto in cui il workload viene effettivamente avviato, perché ogni percorso di avvio legge un file diverso.

  1. Per gli account che eseguono l'accesso: UMASK in /etc/login.defs, applicato da pam_umask a ogni sessione del sistema. È un'impostazione valida per l'intera macchina, quindi modifica contemporaneamente tutti gli account.
  2. Per un singolo account: l'argomento umask= nella riga pam_umask.so è anch'esso valido per l'intera macchina, quindi un valore specifico per l'utente deve trovarsi nel campo GECOS dell'utente oppure in ~/.profile per le shell di login e in ~/.bashrc per quelle interattive.
  3. Per un daemon gestito da systemd: UMask= nella sezione [Service] dell'unità. Un'unità viene avviata dal service manager, quindi /etc/profile non viene mai letto e pam_umask non viene eseguito. Tra queste opzioni, il file dell'unità è l'unico che viene applicato al daemon.
  4. Per uno script avviato da cron o da un hook: un umask esplicito nella prima riga, prima che lo script crei qualsiasi elemento.
[Service]
UMask=<the octal mask you chose>

Verificare quindi il risultato avviando nuovamente lo stesso percorso e non dalla shell in cui è stato modificato il file. La shell corrente ha già memorizzato la propria maschera e la modifica di un file di configurazione non modifica retroattivamente un processo in esecuzione.

bash -lc 'umask'
sudo -i umask

Perché usare chmod dopo non risolve lo stesso problema

chmod modifica i file esistenti. La maschera determina i permessi dei file che non esistono ancora. Esegui chmod -R su una directory e il file successivo scritto dal servizio avrà di nuovo i vecchi permessi, perché quei permessi provengono dal processo che crea il file e modificare i permessi della directory non li cambia.

Esiste anche una finestra temporale. Tra il momento in cui viene creato un file e quello in cui viene eseguito chmod, il file rimane sul disco con permessi più ampi e qualsiasi processo che possa leggere la directory può aprirlo. Per una chiave privata o un archivio di backup, questa finestra costituisce il rischio che si voleva eliminare.

Imposta invece i permessi al momento della creazione. install -m u=rw,go= newfile /etc/app/newfile scrive la destinazione con permessi espliciti e mkdir -m fa lo stesso per una directory. Entrambi applicano i permessi specificati e ignorano la maschera. ssh-keygen imposta i permessi sulla chiave privata che scrive. Per questo quel singolo file è spesso corretto su una macchina in cui tutto il resto non lo è.

La vittima più comune è SSH. Un ~/.ssh creato con un semplice mkdir, oppure un authorized_keys a cui viene aggiunto contenuto con cat >>, eredita la maschera della shell. Quando StrictModes è attivo, sshd rifiuta di leggere un file di chiavi da una directory scrivibile dal gruppo. Il client riceve Permission denied (publickey), mentre il /var/log/auth.log del server registra la causa reale:

Authentication refused: bad ownership or modes for directory /home/deploy/.ssh

Il controllo è intenzionale e mettere in sicurezza SSH su un VPS dipende dal suo corretto funzionamento. Misura la maschera su un nuovo server prima di creare gli account che la utilizzeranno, insieme a i primi dieci minuti su un nuovo VPS, quindi misurala di nuovo attraverso ogni percorso da cui tali account verranno avviati. La maschera appartiene a ogni processo, non al server. Una singola lettura quindi non è sufficiente per tutti gli account.

Copie e archivi ignorano la mask

cp -p e rsync -a ripristinano la modalità registrata nel file di origine, quindi la mask non influisce sul risultato. tar si comporta allo stesso modo quando estrae come root oppure come utente normale con -p. Un file ripristinato da un backup mantiene la modalità che aveva quando è stato eseguito il backup. Verificatelo prima di concludere che una mask corretta venga ignorata: per i dati ripristinati la mask non è mai stata consultata. Un altro caso in cui una mask corretta non viene considerata è la presenza di una ACL predefinita nella directory padre, visualizzata da getfacl -d eseguito su quella directory.

FAQ

Perché il mio job cron crea file con una modalità diversa da quella della sessione SSH?

Un job cron non legge né /etc/profile né ~/.profile, quindi una mask impostata in un file di avvio della shell non viene applicata. Su Debian, cron apre una sessione PAM tramite common-session-noninteractive, che include pam_umask; il job usa quindi il valore PAM. Se lo stack PAM di cron non contiene pam_umask, il job eredita la mask del demone cron. Inserite un umask esplicito nella prima riga dello script, prima che crei qualsiasi elemento, e stampate una volta la mask dall'interno del job. In questo modo vedete il valore effettivamente applicato a quel job, non quello della vostra shell.

Perché /etc/login.defs indica un valore diverso da quello stampato dalla shell?

UMASK in /etc/login.defs è soltanto un fallback per pam_umask. Il modulo preferisce una voce umask= nel campo GECOS dell'utente, quindi un argomento umask= nella riga pam_umask.so di /etc/pam.d/. Il comportamento usergroups, attivato dall'argomento usergroups del modulo oppure, nelle build che sono state modificate per leggerlo, da USERGROUPS_ENAB, riscrive quindi la cifra relativa al gruppo per ogni account diverso da root il cui gruppo primario ha lo stesso nome dell'account. Eseguite grep -rn pam_umask /etc/pam.d/ e id -un; id -gn per verificare quale di queste impostazioni si applica al vostro account.

Una umask può rendere eseguibile un file?

No. Una mask può soltanto rimuovere bit da quelli richiesti dal programma che crea il file. touch non richiede mai il bit di esecuzione, quindi nessuna mask può produrre un file eseguibile. Verificatelo in una directory temporanea con ( umask a=rwx; touch f; stat -c '%a %A' f ). Per ottenere un bit di esecuzione servono chmod oppure un programma come install -m, che lo richiede al momento della creazione.

Dove si imposta la umask per un servizio systemd?

Nell'unità, con UMask= nella sezione [Service]. Un servizio viene avviato dal service manager e non da un login, quindi i file di avvio della shell non vengono mai letti e pam_umask non viene eseguito. Dopo systemctl daemon-reload e il riavvio dell'unità, verificate il risultato dall'esterno: lasciate che il servizio crei un file, quindi leggete il risultato con stat -c '%a %n'.

Una mask predefinita che consente la scrittura al gruppo è sicura?

È sicura quando il gruppo ha esattamente un membro, come previsto dallo schema dei gruppi privati degli utenti. Se aggiungete un secondo account al gruppo, ogni file creato dal primo account diventa immediatamente scrivibile dal nuovo membro, senza eseguire alcun comando su quei file. Eseguite id -un e id -gn: se viene stampato lo stesso nome, state usando un gruppo privato. Se condividete un gruppo tra più account, impostate una mask che rimuova il bit di scrittura del gruppo, quindi create un file e leggete stat -c '%a %n' per verificare che la modifica sia stata applicata.

Questo articolo ti è stato utile?

#umask#permissions#pam#login-defs#linux