SSD Nodes Learn Hosting plans →
Guides Matt ConnorPar Matt Connor · Mis à jour le 2026-10-12

umask Linux : comprendre les permissions par défaut

Découvrez pourquoi root et votre utilisateur obtiennent des modes différents : affichez l’umask, créez un fichier et un répertoire, puis lisez leurs permissions.

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

Ce que fait l’umask sous Linux

L’umask est un nombre présent dans chaque processus Linux. Il détermine le mode de chaque fichier et répertoire créé par ce processus. Lors de la création, un programme demande au kernel un ensemble de permissions. Le kernel efface chaque bit indiqué par le masque, puis applique les bits restants. Une umask n’accorde jamais d’accès. Elle retire uniquement des bits aux permissions demandées par le programme qui crée l’objet. Le kernel définit une exception : si le répertoire parent possède une ACL par défaut, le masque est ignoré et l’ACL héritée s’applique à la place.

La valeur ne dépend pas de votre distribution. Elle dépend du compte utilisé et de la manière dont le shell a été démarré. Ces deux éléments peuvent différer sur une même machine, au même moment, avec une image standard. La première étape n’est donc pas de chercher la réponse dans un manuel. Il faut mesurer la valeur sur la machine concernée.

Afficher l’umask dans le shell courant

umask
umask -S

La première commande affiche le masque en octal. La seconde affiche le même masque sous forme des permissions qu’il autorise, dans la notation symbolique acceptée par chmod. Laissez les deux lignes affichées. Tout ce qui suit compare le résultat que votre shell vient d’afficher.

umask est un builtin du shell, et non un programme présent sur le disque. Vérifiez-le avec type umask. Cette distinction est importante, car un builtin modifie directement le processus du shell. Un programme distinct ne pourrait modifier que son propre processus, puis se terminer en emportant cette modification avec lui.

Créer un fichier et un répertoire, puis relire leurs modes

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

%a affiche le mode en octal et %A affiche le même mode au format drwxr-xr-x utilisé par ls -l. Comparez les deux lignes avec le masque affiché juste avant. Chaque bit activé dans le masque est absent des modes, car un masque ne fait que désactiver ces bits. Si la colonne %A n’est pas encore évidente à lire, commencez par bien comprendre la chaîne d’autorisation drwxr-xr-x.

Le fichier et le répertoire diffèrent, et le masque n’est pas à l’origine de cette différence. touch demande les droits de lecture et d’écriture pour le propriétaire, le groupe et les autres utilisateurs. mkdir demande les droits de lecture, d’écriture et d’exécution pour les trois catégories. Le même masque est appliqué à deux demandes différentes. Ainsi, un fichier créé par touch n’est jamais exécutable, quelle que soit la valeur du masque : le bit d’exécution n’a jamais été demandé, et un masque ne peut pas réactiver un bit.

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

Les parenthèses exécutent les commandes dans un sous-shell, donc la modification disparaît avec lui. Le masque ne demande maintenant la désactivation d’aucun bit, et stat n’affiche toujours aucun bit d’exécution sur le fichier. Exécutez de nouveau umask ensuite : votre valeur d’origine est rétablie. Cela montre que ce paramètre existe dans un processus et est hérité par ses processus enfants, au lieu d’être enregistré sur le disque.

Ce sont les répertoires qui révèlent l’absence du bit d’exécution.

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

Avec un compte utilisateur normal, cd échoue avec bash: cd: noexec.dir: Permission denied, car le masque a désactivé le bit d’exécution demandé par mkdir, et un répertoire dépourvu du bit d’exécution ne peut pas être parcouru. root ne passe pas par ce contrôle. Ce comportement est donc visible uniquement avec un compte normal.

Pourquoi root et votre propre utilisateur affichent un umask différent

Effectuez la même mesure avec un autre compte, en le démarrant d’une autre manière, puis lisez les deux sorties côte à côte.

umask
sudo -i umask

sudo -i démarre le login shell de root et exécute le builtin à l’intérieur de celui-ci. Il s’agit donc d’un autre compte, qui passe par un autre chemin d’initialisation. Sur les images serveur Ubuntu et Debian standard, les deux lignes peuvent afficher des valeurs différentes. Les deux lignes sont correctes. Chacune indique le résultat produit par son propre chemin d’initialisation. La suite de cet article explique quelle partie du système l’a produit.

Quel fichier de votre image a fixé la valeur

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'

Si le premier grep n’affiche rien, exécutez-le de nouveau sans l’ancre ^ : la ligne est peut-être commentée. Une ligne commentée sert de documentation, pas de configuration. Le troisième grep est celui qui surprend le plus souvent. Sur Debian et Ubuntu, le fichier /etc/profile fourni avec le système renvoie généralement vers PAM au lieu de définir lui-même un masque. Le fichier que vous pensiez responsable ne l’est donc souvent pas. grep renvoie un code différent de zéro lorsqu’il ne trouve aucune correspondance. C’est pourquoi cette ligne se termine par || echo : sur une image où aucun fichier de démarrage ne mentionne de masque, vous obtenez le message au lieu du silence, et ce message constitue le résultat.

/etc/login.defs annonce une valeur et PAM en applique une autre

La ligne UMASK de /etc/login.defs correspond à la valeur citée par la plupart des guides. Ni le kernel ni le shell ne lisent ce fichier. Il est lu par pam_umask, un module PAM (modules d’authentification enfichables) exécuté lors de la création d’une session. pam_umask utilise la première valeur trouvée : une entrée umask= dans le champ GECOS de l’utilisateur, puis un argument umask= écrit directement sur la ligne pam_umask.so, puis UMASK provenant de /etc/login.defs, et enfin une entrée UMASK= dans /etc/default/login. Les distributions modifient ce module. Exécutez donc man pam_umask sur votre propre image et consultez l’ordre affiché.

C’est ainsi que /etc/login.defs peut annoncer une valeur alors que votre session en utilise une autre, sans qu’aucun avertissement ne soit affiché. Les commandes grep vous indiquent dans quel cas vous vous trouvez. Si la ligne pam_umask.so contient son propre argument umask=, la valeur de login.defs est ignorée.

USERGROUPS_ENAB et l’exception de root

id -un
id -gn

Si ces deux commandes affichent le même nom, vous utilisez un groupe privé d’utilisateur : le compte a été créé avec son propre groupe, nommé d’après ce compte. USERGROUPS_ENAB dans /etc/login.defs permet à useradd de créer ce groupe par défaut. pam_umask applique un comportement usergroups correspondant. Dans le module upstream, ce comportement est activé par un argument usergroups sur la ligne pam_umask.so ou par une valeur par défaut définie lors de la compilation, et nousergroups le désactive. Ubuntu a modifié le module en 2011 pour lire USERGROUPS_ENAB à la place. Consultez donc le commentaire au-dessus de cette ligne et vérifiez man pam_umask sur votre propre image. Lorsque ce comportement est activé, que le compte n’est pas root et que le nom du groupe primaire correspond au nom de l’utilisateur, le module copie le chiffre correspondant au propriétaire dans le chiffre correspondant au groupe. La session se termine alors avec un masque qui laisse les bits du groupe ouverts pour tout ce que ce compte crée. Le module exclut root lui-même. Cette exclusion est la raison la plus fréquente pour laquelle deux shells sur un même serveur affichent des masques différents.

Cette règle repose sur le principe qu’un groupe privé ne comporte qu’un seul membre. Les droits d’écriture du groupe correspondent donc exactement à ceux du propriétaire. Cela reste vrai jusqu’à ce qu’un second membre soit ajouté au groupe. À partir de ce moment, ce nouveau membre peut modifier tous les fichiers que le compte a créés auparavant, sans qu’aucune commande ait été exécutée sur ces fichiers pour l’autoriser. Attribuez à chaque service son propre compte utilisateur avec les privilèges minimaux afin que ce groupe reste volontairement composé d’un seul membre.

Shell de connexion, shell sans connexion et shell non interactif

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

PAM s’exécute lors de la création d’une session : login sur la console, sshd, su, sudo -i. Il ne s’exécute pas lorsqu’un shell en lance un autre. bash -l est un shell de connexion : il lit donc /etc/profile et ~/.profile, mais il n’appelle jamais pam_umask, car aucune session n’a été créée. bash -c ne lit aucun de ces fichiers et hérite du masque du processus qui l’a lancé. Un hook Git et un programme lancé par un gestionnaire de services relèvent de ce dernier cas : leur masque correspond à celui de leur processus parent. Cron ne lit pas non plus les fichiers de démarrage des shells, mais sur Debian, son fichier PAM inclut common-session-noninteractive, qui charge pam_umask. Chaque tâche reçoit donc la valeur PAM qu’une session aurait reçue.

C’est pourquoi le message « J’ai défini ce paramètre dans /etc/profile, mais le service crée toujours des fichiers avec les mauvaises permissions » revient si souvent. Le service n’a jamais lu ce fichier.

Où le définir pour qu’il soit conservé

Définissez le masque à l’endroit où la charge de travail démarre réellement, car chaque chemin de démarrage lit un fichier différent.

  1. Pour les comptes qui se connectent : UMASK dans /etc/login.defs, appliqué par pam_umask à chaque session de la machine. Ce réglage s’applique à toute la machine et modifie donc tous les comptes en une seule fois.
  2. Pour un seul compte : l’argument umask= sur la ligne pam_umask.so s’applique également à toute la machine. Une valeur propre à l’utilisateur doit donc être placée dans le champ GECOS de cet utilisateur, ou dans ~/.profile pour les shells de connexion et dans ~/.bashrc pour les shells interactifs.
  3. Pour un daemon sous systemd : UMask= dans la section [Service] de l’unité. Une unité est démarrée par le service manager. /etc/profile n’est donc jamais lu et pam_umask ne s’exécute jamais. Le fichier d’unité est le seul de ces fichiers qui atteint le daemon.
  4. Pour un script démarré par cron ou par un hook : un umask explicite sur la première ligne, avant que le script ne crée quoi que ce soit.
[Service]
UMask=<the octal mask you chose>

Vérifiez ensuite le résultat depuis un nouveau démarrage du même chemin, et jamais depuis le shell dans lequel vous avez modifié le fichier. Votre shell actuel possède déjà son masque, et la modification d’un fichier de configuration ne se répercute pas sur un processus en cours d’exécution.

bash -lc 'umask'
sudo -i umask

Pourquoi corriger ensuite avec chmod ne constitue pas le même correctif

chmod corrige les fichiers qui existent déjà. Le masque détermine le mode des fichiers qui n’existent pas encore. Exécutez chmod -R sur un répertoire : le fichier suivant écrit par le service retrouvera l’ancien mode, car ce mode provient du processus qui crée le fichier. Modifier le mode du répertoire n’a aucun effet sur ce fichier.

Il existe également une fenêtre d’exposition. Entre la création du fichier et l’exécution de chmod, le fichier reste sur le disque avec un mode trop permissif. Tout processus capable de lire le répertoire peut alors l’ouvrir. Pour une clé privée ou une archive de sauvegarde, cette fenêtre correspond précisément au risque que vous cherchiez à supprimer.

Définissez plutôt le mode lors de la création. install -m u=rw,go= newfile /etc/app/newfile écrit la destination avec un mode explicite, et mkdir -m fait de même pour un répertoire. Tous deux utilisent le mode indiqué et ignorent le masque. ssh-keygen définit le mode de la clé privée qu’il écrit. C’est pourquoi ce fichier est souvent correct sur une machine où les autres ne le sont pas.

SSH est généralement le premier service concerné. Un ~/.ssh créé avec un simple mkdir, ou un authorized_keys ajouté avec cat >>, reçoit le masque de votre shell. Avec StrictModes activé, sshd refuse de lire un fichier de clé situé dans un répertoire accessible en écriture par le groupe. Le client affiche Permission denied (publickey), tandis que le serveur consigne la cause réelle dans /var/log/auth.log :

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

Ce contrôle est volontaire. Le renforcement de la sécurité de SSH sur un VPS en dépend. Mesurez le masque sur un nouveau serveur avant de créer les comptes qui l’utiliseront, en même temps que les dix premières minutes sur un nouveau VPS. Mesurez-le ensuite à nouveau pour chaque chemin depuis lequel ces comptes seront lancés. Le masque appartient à chaque processus, pas au serveur. Une seule lecture ne permet donc pas de le déterminer pour tous les comptes.

Les copies et les archives ignorent le masque

cp -p et rsync -a restaurent le mode enregistré sur le fichier source. Le masque n’a donc aucune influence sur le résultat. tar fait de même lors d’une extraction effectuée en tant que root ou par un utilisateur ordinaire avec -p. Un fichier restauré depuis une sauvegarde conserve le mode qu’il avait au moment de la sauvegarde. Vérifiez ce point avant de conclure qu’un masque correct est ignoré : pour les données restaurées, il n’a jamais été consulté. L’autre cas où un masque correct ne s’applique plus est celui d’une ACL par défaut sur le répertoire parent, que getfacl -d sur ce répertoire permet d’afficher.

FAQ

Pourquoi mon cron crée-t-il des fichiers avec des permissions différentes de celles de ma session SSH ?

Un cron ne lit ni /etc/profile ni ~/.profile. Une umask définie dans un fichier d’initialisation du shell ne lui est donc jamais transmise. Sur Debian, cron ouvre une session PAM via common-session-noninteractive, qui inclut pam_umask. Le job reçoit alors la valeur PAM. Lorsque la stack PAM de cron ne contient pas pam_umask, le job hérite de la umask du daemon cron. Ajoutez une umask explicite sur la première ligne du script, avant toute création de fichier, puis affichez une fois la umask depuis le job. Vous verrez ainsi la valeur réelle de ce job, et non celle de votre propre shell.

Pourquoi /etc/login.defs indique-t-il une valeur différente de celle affichée par mon shell ?

UMASK dans /etc/login.defs sert uniquement de valeur de repli pour pam_umask. Le module privilégie d’abord une entrée umask= dans le champ GECOS de l’utilisateur, puis un argument umask= sur la ligne pam_umask.so dans /etc/pam.d/. Le comportement usergroups, activé par l’argument usergroups du module ou, sur les builds qui savent le lire, par USERGROUPS_ENAB, modifie ensuite le chiffre correspondant au groupe pour tout compte autre que root dont le groupe primaire porte le même nom. Exécutez grep -rn pam_umask /etc/pam.d/ et id -un; id -gn pour voir lequel de ces mécanismes s’applique à votre compte.

Une umask peut-elle rendre un fichier exécutable ?

Non. Une umask peut seulement supprimer des bits parmi ceux demandés par le programme qui crée le fichier. touch ne demande jamais le bit d’exécution. Aucune umask ne peut donc produire un fichier exécutable. Vérifiez-le dans un répertoire temporaire avec ( umask a=rwx; touch f; stat -c '%a %A' f ). Pour obtenir un bit d’exécution, vous devez utiliser chmod ou un programme tel que install -m qui le demande au moment de la création.

Où définir la umask d’un service systemd ?

Dans l’unité, avec UMask= dans la section [Service]. Un service est démarré par le service manager, et non par une session de login. Les fichiers d’initialisation du shell ne sont donc jamais lus et pam_umask n’est jamais exécuté pour ce service. Après systemctl daemon-reload et un redémarrage de l’unité, vérifiez le résultat depuis l’extérieur : laissez le service créer un fichier, puis lisez le résultat avec stat -c '%a %n'.

Une umask par défaut autorisant l’écriture du groupe est-elle sûre ?

Elle est sûre tant que le groupe ne contient qu’un seul membre. C’est le principe du schéma des groupes privés des utilisateurs. Ajoutez un deuxième compte à ce groupe : tous les fichiers créés par le premier compte deviennent immédiatement accessibles en écriture à ce nouveau membre, sans qu’aucune commande soit exécutée sur ces fichiers. Exécutez id -un et id -gn : si le même nom s’affiche, vous utilisez un groupe privé. Si plusieurs comptes partagent un groupe, définissez une umask qui supprime le bit d’écriture du groupe, puis créez un fichier et lisez stat -c '%a %n' pour vérifier que la modification est effective.

Cet article vous a-t-il été utile ?

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