Cours Linux / Comprendre les utilisateurs, les groupes et les propriétaires des fichiers

Linux identifie les utilisateurs par un UID et les groupes par un GID ; chaque fichier possède aussi un utilisateur propriétaire et un groupe propriétaire. Pour lire ces informations, utilisez id et groups pour le processus courant, getent pour les données de comptes, puis ls ou stat pour le fichier. Une appartenance à un groupe ne suffit pas à elle seule à autoriser un accès : l’identité, les permissions et les autres règles applicables se combinent.

Cette leçon utilise un compte ordinaire, Bash et les outils GNU dans le Linux de pratique. Les consultations ne changent ni les comptes, ni les groupes, ni les propriétaires ; seul un nouveau petit fichier de démonstration sera créé. Aucun sudo n’est nécessaire.

Comprendre les noms, les UID et les GID

UID signifie User ID, identifiant numérique d’utilisateur ; GID signifie Group ID, identifiant numérique de groupe. Un nom comme learner rend l’identifiant plus facile à lire, mais le nom et le nombre ne sont pas interchangeables dans toutes les commandes. Le système doit pouvoir retrouver le nom correspondant pour le présenter.

Le compte comporte un groupe principal et peut avoir des groupes supplémentaires. Un processus possède également les identifiants qu’il utilise effectivement. Dans une connexion ordinaire, ils correspondent généralement à ceux du compte, mais un changement d’identité ou de groupe peut créer des différences : ne confondez pas une configuration de compte et l’état d’un processus en cours.

Le nom root est habituellement associé à l’UID 0. Les comptes ordinaires ne commencent pas obligatoirement à 1000 : les politiques de création et les environnements diffèrent. Il n’y a donc pas un UID ou un GID particulier que tous les lecteurs doivent retrouver.

Observer l’identité et les groupes du processus courant

Exécutez les commandes suivantes dans votre terminal de pratique :

id
id -un
id -gn
id -nG
groups

L’option -n demande des noms plutôt que des nombres ; id -u, id -g et id -G donnent les formes numériques correspondantes. -r permet de demander les identifiants réels avec les options compatibles, au lieu des effectifs. Si un nom ne peut pas être résolu, conservez le diagnostic et comparez les valeurs numériques ; un affichage partiel ne prouve pas que toute la consultation a réussi. Le manuel GNU id détaille ces distinctions.

Voici une ligne fictive pour apprendre à lire les champs, et non une sortie à reproduire sur votre machine :

uid=1000(learner) gid=1000(learner) groups=1000(learner),2000(atelier)

Dans cet exemple, learner correspond au nombre 1000 et le groupe atelier au nombre 2000. Les champs uid et gid indiquent ici l’identité réelle et le groupe réel, sans différence effective affichée ; groups fournit les groupes présentés pour ce processus. Votre commande peut montrer d’autres noms, nombres ou champs.

Sans argument utilisateur, id et groups décrivent le processus courant. Avec un nom de compte en argument, ils interrogent les données d’utilisateur et de groupe ; le résultat peut différer de celui d’une session déjà ouverte. Le manuel GNU groups explique ce choix du sujet observé.

Distinguer une nouvelle configuration d’une session déjà ouverte

Les groupes d’un processus sont normalement hérités du processus parent et ne sont pas relus automatiquement à chaque commande. Si un administrateur change l’appartenance d’un compte, un terminal déjà ouvert peut donc continuer avec son ancienne liste.

Ouvrir simplement un autre terminal dans la même session graphique ne garantit pas de nouveaux groupes : il peut hériter du même environnement de connexion. Après un changement réel, une nouvelle connexion complète est souvent nécessaire pour appliquer la nouvelle appartenance ; vérifiez ensuite id dans cette nouvelle session. Cette leçon n’effectue aucun changement d’appartenance.

La documentation Linux des identifiants de processus décrit l’héritage des UID et groupes. Pour un diagnostic, notez donc toujours si vous comparez l’état du processus courant ou une entrée de compte consultée à nouveau.

Consulter les données de comptes avec getent

Sur les systèmes qui utilisent la bibliothèque GNU C, aussi appelée glibc, le Name Service Switch (NSS) détermine les sources à interroger et leur ordre pour des informations comme les comptes et groupes. Selon la configuration, il peut s’agir de fichiers locaux ou de services d’annuaire. Le manuel nsswitch.conf décrit ce mécanisme.

getent utilise les bases prises en charge par NSS. Pour rechercher l’entrée correspondant à l’UID effectif courant et celle du GID effectif courant, utilisez les clés numériques produites par id :

getent passwd "$(id -u)"
getent group "$(id -g)"

La substitution $(...) remplace l’expression par la sortie de la commande indiquée. Ces requêtes ciblées évitent de lister tous les comptes. La base passwd désigne les données de compte et group les groupes ; le manuel getent précise les clés numériques et les noms acceptés.

Une entrée passwd au format classique contient sept champs séparés par deux-points : nom, champ de mot de passe, UID, GID principal du compte, description, répertoire personnel, shell de connexion. Exemple fictif :

learner:x:1000:1000:Compte de pratique:/home/learner:/bin/bash

Le quatrième champ est ici le GID principal enregistré pour le compte. Ce n’est pas une preuve que tout processus actuel de ce compte utilise encore ce groupe comme groupe effectif. Le x indique couramment que les informations d’authentification sont gérées ailleurs, notamment dans shadow ; ce n’est pas un mot de passe en clair. Le manuel du format passwd décrit ces champs.

Une entrée group classique contient le nom, un champ de mot de passe, le GID et une liste de membres. Dans notre exemple fictif, le groupe principal peut apparaître ainsi :

learner:x:1000:

La liste finale vide ne signifie pas que personne n’utilise le GID 1000 comme groupe principal : ce lien est enregistré dans le compte passwd. Une liste de membres d’un groupe n’est donc pas à elle seule la liste de toutes les identités qui peuvent utiliser ce groupe. Le format group précise la structure ; confrontez-la à l’entrée utilisateur et au résultat d’id selon la question.

Si getent manque ou ne trouve pas d’entrée, examinez le message, l’état de la commande et les outils de votre distribution. Un annuaire indisponible ou un mécanisme de résolution différent peut expliquer une absence de nom. Ne transformez pas cette consultation en édition manuelle de /etc/passwd ou /etc/group.

Lire les propriétaires d’un nouveau fichier

Préparez un dossier linux-course-16-practice neuf dans votre répertoire personnel. S’il existe déjà, changez candidat ; ne réutilisez pas une ancienne entrée. La variable propriete n’est renseignée qu’après la réussite de mkdir et touch :

propriete=
candidat="$HOME/linux-course-16-practice"
if mkdir -- "$candidat" && touch -- "$candidat/own.txt"; then
  propriete=$candidat
  printf 'Fichier : %s\n' "$propriete/own.txt"
else
  printf '%s\n' 'Préparation échouée : vérifier et choisir un nouveau dossier avant de poursuivre.' >&2
fi

Gardez le même terminal et ne redéfinissez pas propriete vers un autre dossier. Si la préparation échoue, examinez l’erreur et choisissez un nom neuf avant de continuer. touch crée ici own.txt vide ; sur un fichier déjà présent, il pourrait modifier les horodatages.

test -n "$propriete" && ls -l -- "$propriete/own.txt"

Dans la présentation longue habituelle, les deux noms après les permissions et le nombre de liens sont l’utilisateur propriétaire et le groupe propriétaire. La taille de ce nouveau fichier doit être 0. Les permissions, l’horodatage et les noms dépendent du système : ne copiez pas une ligne modèle comme si elle devait être identique partout.

Pour comparer les noms affichés aux identifiants stockés, demandez ensuite la présentation numérique :

test -n "$propriete" && ls -ln -- "$propriete/own.txt"

Les colonnes utilisateur et groupe sont maintenant des UID et GID. Un nombre affiché à la place d’un nom peut aussi révéler que le nom n’est pas résolu ; cela ne signifie pas que le fichier n’a plus de propriétaire.

GNU stat permet de demander explicitement ces quatre valeurs et le chemin :

test -n "$propriete" &&
stat -c '%U | %G | %u | %g | %n' -- "$propriete/own.txt"

%U et %G donnent les noms du propriétaire et du groupe ; %u et %g leurs nombres ; %n le nom fourni. Comparez ces valeurs à ls -l et ls -ln, puis à id pour l’identité du processus. Le manuel GNU stat définit les formats ; les guides français de ls et ses colonnes et de stat et ses métadonnées détaillent leur lecture.

Dans une création ordinaire, le fichier appartient généralement à l’utilisateur effectif qui l’a créé. Son groupe peut dépendre du groupe effectif, du dossier parent et du système de fichiers. Sous Linux, le bit setgid d’un dossier peut notamment faire hériter son groupe aux nouveaux fichiers ; certaines options de montage interviennent aussi. La documentation Linux de création d’un fichier explique ces choix. Ne concluez donc pas que le groupe d’own.txt doit forcément être celui du compte enregistré dans passwd.

Vous pouvez consulter le dossier lui-même avec ls -ld suivi de son chemin pour comparer son groupe à celui du fichier, sans changer les réglages. Les commandes de cette section lisent les informations : elles n’exécutent pas chown ou chgrp et ne modifient aucune appartenance.

Confronter les bonnes informations avant un problème d’accès

Pour réduire un problème d’accès, vérifiez d’abord l’identité de la session concernée, puis les nombres et noms du fichier visé. Examinez ensuite les permissions et les règles supplémentaires applicables, notamment celles des dossiers à traverser ; l’appartenance à un groupe ne remplace pas ces contrôles.

Le fichier vide créé ici peut être conservé pour revoir les sorties. Aucun état de compte ou de propriétaire n’a été changé par cette leçon, donc aucune correction de groupe ou réattribution de fichier n’est nécessaire pour terminer l’exercice.