Gérer les utilisateurs

Objectif de cet atelier pratique

• Définir qui a accès à quoi dans un système Linux

Caractéristiques d'un système multi-utilisateurs

Linux est un vrai système multi-utilisateurs, tout comme son ancêtre Unix. Pour comprendre la portée de cette assertion, imaginez un poste de travail comme on peut en trouver dans la salle informatique d'une grande université, fréquentée par une bonne dizaine de milliers d'étudiants. Chaque étudiant inscrit a le droit d'utiliser les machines de la salle informatique. Il possède donc son identifiant personnel et son mot de passe, qui lui permettent de se connecter à une machine de la salle informatique pour y travailler, c'est-à-dire effectuer ses recherches, écrire ses devoirs, rédiger son mémoire ou sa thèse, etc. Une telle installation doit répondre à quelques exigences.

• Chaque utilisateur du système doit disposer de son répertoire personnel, c'est-à-dire d'un endroit pour lui seul, utilisable par lui seul, où il peut stocker toutes ses données.

• La confidentialité doit être assurée, c'est-à-dire qu'un étudiant connecté ne pourra pas aller fouiner librement dans les données de ses collègues.

• Il ne faut pas non plus qu'un utilisateur puisse effacer par mégarde (ou même intentionnellement) les données qui ne lui appartiennent pas.

• Enfin, l'intégrité du système ne doit en aucun cas être mise en péril par les utilisateurs.

Notre configuration de test sera beaucoup plus modeste qu'une série de postes de travail dans la salle informatique d'une université. Il n'empêche que l'approche multi-utilisateurs est tout aussi pertinente, même pour un usage sur une machine locale. Après tout, peu importe si le système gère deux ou trois utilisateurs ou vingt-cinq mille.

Installation locale vs. profils itinérants

Techniquement parlant, une telle installation dans une université se différencie d'une installation domestique d'un poste de travail par la configuration itinérante des profils d'utilisateurs. Dans une telle configuration, l'ensemble des données, les identifiants de connexion et les mots de passe sont stockés de façon centralisée sur le serveur. À partir de là, chaque étudiant peut se connecter sur n'importe quelle machine de la salle informatique et retrouver son environnement, alors que sur une installation comme un poste de travail domestique, chaque compte d'utilisateur reste lié à la machine locale. Pour l'instant, nous nous concentrons sur la gestion locale des utilisateurs sur une seule machine tournant sous Linux.

Ajouter de nouveaux utilisateurs

Lors de la configuration post-installation, j'ai défini un premier utilisateur du « commun des mortels » pour mon système. Cela signifie que ma machine connaît déjà deux comptes :

• l'administrateur root

• l'utilisateur en question (microlinux)

En dehors de mon utilisateur initial, je vais créer quelques comptes supplémentaires :

• Jean Mortreux (jmortreux)

• Wafaa Chenaoui (wchenaoui)

• Marion Chabaud (mchabaud)

• Guillaume Dangla (gdangla)

Chacun des utilisateurs sera créé à l'aide de la commande useradd. L'invocation de cette commande requiert des droits d'administrateur.

Je lance la création de mon premier utilisateur :

$ sudo useradd -c "Jean Mortreux" jmortreux
$ sudo passwd jmortreux
Changement de mot de passe pour l'utilisateur jmortreux.
Nouveau mot de passe : ********
Retapez le nouveau mot de passe : ********
passwd : mise à jour réussie de tous les jetons d'authentification.

Un coup d'œil rapide dans la page man de useradd nous renseigne sur la signification exacte de l'option -c, que vous avez probablement devinée dans le contexte :

-c, --comment COMMENT
    Toute chaîne de texte. C'est généralement une description courte du 
    compte, elle est actuellement utilisée comme champ pour le nom complet 
    de l'utilisateur.

Évitez les mots de passe trop simples

Notez qu'il y a une vérification sur la robustesse du mot de passe défini. Pour un utilisateur quelconque, le système refuserait tout simplement de créer le mot de passe s'il est faible (puisque la commande passwd peut être invoquée par un utilisateur pour changer son propre mot de passe). En revanche, root a tous les droits, y compris celui ce forcer l'utilisation d'un mot de passe trop simple (ce que je vous déconseille néanmoins) :

$ sudo useradd -c "Wafaa Chenaoui" wchenaoui
$ sudo passwd wchenaoui
Changement de mot de passe pour l'utilisateur wchenaoui.
Nouveau mot de passe : ****
MOT DE PASSE INCORRECT : Le mot de passe comporte moins de 8 caractères
Retapez le nouveau mot de passe : ****
passwd : mise à jour réussie de tous les jetons d'authentification.

Procédez de même pour créer les autres utilisateurs de la machine.

Utiliser n'est pas administrer

Tout au long de notre initiation à la ligne de commande, nous avons travaillé en tant que simples utilisateurs – à quelques rares exceptions près – pour créer, éditer, visualiser, déplacer, copier et effacer des fichiers. Ces tâches ne mettaient pas en péril le fonctionnement du système ou les données des autres utilisateurs et ne nécessitaient par conséquent aucun privilège spécifique. Il n'en est plus de même pour la gestion des utilisateurs, qui comprend entre autres choses :

• la création d'un nouvel utilisateur

• la définition de son mot de passe

• la configuration de ses droits : à quoi aura-t-il accès dans le système ?

• la suppression éventuelle de l'utilisateur ainsi que de toutes ses données

Changer d'identité et devenir root

Lors de l'installation du système, nous avons défini un mot de passe pour l'utilisateur root. Un peu plus haut, nous avons eu besoin des privilèges de root pour créer quelques utilisateurs supplémentaires, que nous avons acquis en utilisant la commande sudo avec le mot de passe de l'utilisateur.

Or, il existe un moyen plus direct grâce à la commande su (switch user, c'est-à-dire « changer d'utilisateur »). Tapez ce qui suit, en saisissant le mot de passe root` lorsque le système vous le demande :

[microlinux@sandbox ~]$ su -
Mot de passe : ********
[root@sandbox ~]#

L'importance du tiret -

Notez le tiret - qui suit la commande su. Il précise qu'il faut devenir root en récupérant toutes les variables d'environnement de ce compte. Nous y reviendrons. Contentez-vous pour l'instant de connaître la démarche.

Une mise en garde solennelle s'impose. En acquérant les droits de root, vous voilà en quelque sorte détenteur du fameux bouton rouge. Cela ne veut pas dire que vous allez forcément déclencher une guerre nucléaire, mais une simple commande bien sentie suffirait à enclencher une apocalypse numérique sur votre système. En un mot : prudence. Et gare aux fautes de frappe.

S'il est utile de savoir comment acquérir les pleins pouvoirs sur la machine, il est tout aussi indispensable de savoir comment revenir en sens inverse pour se débarrasser de tous ces super-pouvoirs lorsqu'on n'en a plus besoin. Dans ce cas, c'est exactement la même commande que pour quitter une session dans la console. Vous avez donc le choix entre les deux commandes logout et exit, à moins que vous ne préfériez le raccourci clavier Ctrl+D.

[root@sandbox ~]# exit
déconnexion
[microlinux@sandbox ~]$

Savoir qui l'on est

La commande su ne nous permet pas seulement de devenir root. Si le système dispose d'un utilisateur gdangla, je pourrais très bien devenir gdangla en invoquant la commande suivante (et en saisissant son mot de passe) :

[microlinux@sandbox ~]$ su - gdangla
Mot de passe : ********
[gdangla@sandbox ~]$

Là encore, notez l'utilisation du tiret - pour indiquer que vous souhaitez devenir un autre utilisateur en utilisant ses variables d'environnement. L'invite de commandes gdangla@sandbox nous indique qu'un changement d'identité a eu lieu. Pour le vérifier, nous avons tout loisir de demander à notre système qui nous sommes, grâce à la commande whoami (« Who am I ? » , « Qui suis-je ? »). Voici une petite démonstration pratique :

[microlinux@sandbox ~]$ su - gdangla
Mot de passe : ********
[gdangla@sandbox ~]$ whoami
gdangla
[gdangla@sandbox ~]$ exit
déconnexion
[microlinux@sandbox ~]$ whoami
microlinux
[microlinux@sandbox ~]$ su -
Mot de passe : ********
[root@sandbox ~]# exit
déconnexion
[microlinux@sandbox ~]$ whoami
microlinux

Vous remarquerez que si j'invoque su sans autre argument que le tiret -, cela revient exactement à la même chose que su - root :

[microlinux@sandbox ~]$ su - 
Mot de passe : ********
[root@sandbox ~]# 

En savoir un peu plus sur les utilisateurs

Chacun des utilisateurs que nous avons créés jusqu'ici possède un certain nombre de caractéristiques, comme son UID unique, son GID, les groupes secondaires auxquels il appartient, son répertoire d'utilisateur, son shell de connexion, etc. Voyons maintenant comment afficher ces différentes informations. Commençons par nous-mêmes, en utilisant la commande id :

$ id
uid=1000(microlinux) gid=1000(microlinux) groupes=1000(microlinux),10(wheel) 
contexte=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023

Invoquée sans autre argument, la commande id nous affiche l'UID, le GID, ainsi que la liste complète des groupes secondaires auxquels l'utilisateur est affecté.

C'est quoi ces infos de confinement ?

La commande id nous affiche également le contexte SELinux (Security Enhanced Linux), que nous allons laisser de côté pour l'instant. SELinux est une technologie quelque peu complexe, et nous l'aborderons (beaucoup) plus loin.

Afficher l'UID (User Identification) de l'utilisateur :

$ id -u
1000

Afficher le GID (Group Identification) :

$ id -g
1000

Afficher le nom du groupe :

$ id -gn
microlinux

Afficher les groupes dont l'utilisateur est membre :

$ id -G
1000 10

Afficher les noms des groupes dont l'utilisateur est membre :

$ id -Gn
microlinux wheel

Pour cette dernière commande, nous disposons d'une alternative plus courante :

$ groups
microlinux wheel

Évidemment, personne ne vous demande de retenir toutes ces options par cœur. N'oubliez pas que vous avez la page du manuel pour cela :

$ man id

Pour en savoir plus sur les autres utilisateurs du système, il suffit de fournir leur nom en argument. Ces informations sont accessibles à tous les utilisateurs non privilégiés du système :

$ id wchenaoui
uid=1002(wchenaoui) gid=1002(wchenaoui) groupes=1002(wchenaoui)
$ id jmortreux
uid=1001(jmortreux) gid=1001(jmortreux) groupes=1001(jmortreux)

Les arguments et les options peuvent évidemment être combinés à souhait, par exemple pour afficher l'UID d'un autre utilisateur :

$ id -u gdangla
1004

Comprendre le fichier /etc/passwd

Essayons de voir un peu plus en détail comment se passe la gestion des utilisateurs au niveau du système. Affichez le contenu du fichier /etc/passwd :

$ less /etc/passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
...
tcpdump:x:72:72::/:/sbin/nologin
tss:x:59:59:Account used for TPM access:/:/usr/sbin/nologin
openvpn:x:982:981:OpenVPN:/etc/openvpn:/sbin/nologin
microlinux:x:1000:1000:Microlinux:/home/microlinux:/bin/bash
jmortreux:x:1001:1001:Jean Mortreux:/home/jmortreux:/bin/bash
wchenaoui:x:1002:1002:Wafaa Chenaoui:/home/wchenaoui:/bin/bash
mchabaud:x:1003:1003:Marion Chabaud:/home/mchabaud:/bin/bash
gdangla:x:1004:1004:Guillaume Dangla:/home/gdangla:/bin/bash

Certains d'entre vous seront peut-être vaguement surpris voire inquiets de pouvoir lire ce fichier sans autres privilèges. C'est tout à fait normal et nous y viendrons.

Le fichier /etc/passwd contient l'ensemble des informations qui régissent la connexion des utilisateurs. Chaque ligne de ce fichier correspond à un utilisateur. Essayez de repérer l'entrée qui correspond à votre humble personne :

microlinux:x:1000:1000:Microlinux:/home/microlinux:/bin/bash

Comment décrypter ce charabia ? Il s'agit en fait d'une série de champs séparés par deux-points, où l'on trouve dans l'ordre... :

• l'identifiant de connexion (microlinux)

• la lettre x, signifiant que le mot de passe chiffré de l'utilisateur se situe dans le fichier /etc/shadow

• l'UID (User Identification, ici 1000), que le système utilise plutôt que votre identifiant pour gérer les droits d'accès de vos fichiers

• le GID (Group Identification, également 1000 ici), groupe primaire auquel appartient l'utilisateur

• le nom complet de l'utilisateur (Microlinux)

• le répertoire de connexion (/home/microlinux)

• le shell de connexion de l'utilisateur (/bin/bash)

Shell de connexion

Pour être précis, le shell de connexion est la commande que le système doit exécuter lorsque l'utilisateur se connecte. En pratique, il s'agit de l'interpréteur de commandes de l'utilisateur.

Les utilisateurs système

Qui sont donc tous ces utilisateurs mystérieux sur votre système ? Vous n'avez pas défini ces gens aux identifiants pour le moins curieux : daemon, operator, nobody... Rassurez-vous, votre machine n'est peuplée ni par des démons, ni par des hommes invisibles. Il s'agit là des utilisateurs système.

À quoi servent les utilisateurs système ?

À titre d'exemple, si vous installez le serveur web Apache (sudo dnf install -y httpd), l'installation crée un utilisateur système apache. Lorsque le serveur Apache est lancé, le processus « n'appartient » pas à l'utilisateur root, mais à l'utilisateur système apache.

Il peut arriver (et dans le monde réel, cela arrive effectivement) qu'une personne malintentionnée décide d'attaquer le serveur, en exploitant une faille de sécurité. Or, si le serveur fonctionnait avec des droits root, cela rendrait l'attaquant tout-puissant sur la machine. Le recours à un utilisateur système permet donc de limiter les dégâts dans un tel cas de figure.

Je vous épargne les détails complexes d'une telle situation. Retenez juste que l'existence des utilisateurs système est avant tout motivée par des considérations de sécurité.

Dorénavant, nous pouvons établir une classification sommaire des utilisateurs sur notre machine :

• L'administrateur root, l'utilisateur tout-puissant. Son UID est toujours égal à 0.

• Les utilisateurs système, gérant les droits d'accès d'un certain nombre de services sur la machine. Leur UID est compris entre 1 et 999.

• Les utilisateurs « normaux », c'est-à-dire les personnes physiques comme vous et moi (microlinux, wchenaoui, jmortreux). Notre UID sera supérieur ou égal à 1000.

• L'utilisateur système nobody a un UID et un GID de 65534.

Comprendre le fichier /etc/shadow

Dans le bon vieux temps, le fichier /etc/passwd contenait également les mots de passe des utilisateurs. Ils étaient certes chiffrés, mais l'algorithme de chiffrement utilisé à l'époque n'était pas très performant. Avec l'avènement des processeurs de plus en plus puissants, un attaquant avait la perspective de décrypter les mots de passe en un temps raisonnable.

Pour cette raison, les mots de passe ont été délocalisés vers le fichier /etc/shadow. Contrairement à /etc/passwd, il n'est pas accessible à tout le monde.

$ cat /etc/shadow
cat: /etc/shadow: Permission non accordée

Les permissions de ce fichier sont beaucoup plus restrictives. Seul root a le droit d'en afficher le contenu :

$ sudo cat /etc/shadow
root:$6$nYUyqivY6aOSet2AgoLVSmGsxP5.oSFwkpb9z/1t8ZuKSn1pwbrF/::0:99999:7:::
bin:*:19816:0:99999:7:::
daemon:*:19816:0:99999:7:::
adm:*:19816:0:99999:7:::
lp:*:19816:0:99999:7:::
sync:*:19816:0:99999:7:::
shutdown:*:19816:0:99999:7:::
halt:*:19816:0:99999:7:::
mail:*:19816:0:99999:7:::
operator:*:19816:0:99999:7:::
games:*:19816:0:99999:7:::
ftp:*:19816:0:99999:7:::
nobody:*:19816:0:99999:7:::
...
microlinux:$6$yF/uUl.WgLE8Nz61Q3OzEgUqTJg73hRxQZ3cG1rvJSrQc0HDo//W0::0:99999:7:::
jmortreux:$6$gVvKCj/qAW6Urc4.HNLS6qART51fOFVy6g/ESzCU2Dk0.:20355:0:99999:7:::
wchenaoui:$6$ZmTxgZkH$FuYo6Y6CvRZvEPX03iZkk9FfLdFA/uTdrgu/:20355:0:99999:7:::
mchabaud:$6$jyI.D3ECe2zLeNl5OK6BPPOEML9ozb5s23BVYg5HePLY/:20355:0:99999:7:::
gdangla:$6$j5GhStPf/DXRS5hSgS1SsSeGyQ6tE3MKg6PfWHsqnlG5.:20355:0:99999:7:::

À première vue, la syntaxe de ce fichier ressemble de très loin à celle que nous avons pu trouver dans /etc/passwd :

jmortreux:$6$gVvKCj/qAW6Urc4.HNLS6qART51fOFVy6g/ESzCU2Dk0.:20355:0:99999:7:::

Là aussi, nous disposons d'une série d'informations séparées par deux-points :

• l'identifiant de connexion (jmortreux)

• le mot de passe chiffré ($6$gVvKCj/qAW6Urc4.HNLS6qART51fOFVy6g/ESzCU2Dk0.)

• la date du dernier changement de mot de passe (20355)

• l'âge minimum du mot de passe (0)

• l'âge maximum du mot de passe (99999)

• la période d'expiration du mot de passe (7)

• etc.

La syntaxe du fichier mérite quelques remarques :

• Chacun des identifiants de connexion (microlinux, jmortreux, wchenaoui, etc.) est également présent dans /etc/passwd. Ce champ peut donc être considéré comme un connecteur entre les deux fichiers.

• Les mots de passe chiffrés commencent tous par $6$, ce qui signifie que l'algorithme de hachage SHA-512 a été utilisé.

• Au cas où deux utilisateurs ont le même mot de passe, les empreintes correspondantes dans /etc/shadow seront différentes grâce au salage.

• La date de dernière modification du mot de passe (20355) est indiquée en nombre de jours depuis le 1er janvier 1970.

Qu'est-ce que le salage ?

Le salage est une méthode utilisée en cryptographie. Il permet de renforcer la sécurité des informations destinées à être hachées en ajoutant une donnée supplémentaire. Cette technique permet d'éviter que deux informations identiques conduisent à la même empreinte.

Les pages de manuel en ligne du système ne nous renseignent pas seulement sur le rôle et la syntaxe des commandes. Les fichiers de configuration du système y sont également décrits en détail :

$ apropos passwd
...
passwd (5)           - password file
...
$ apropos shadow
...
shadow (5)           - fichier des mots de passe cachés
...
$ man 5 passwd
...
$ man 5 shadow

Trouver les utilisateurs physiques du système

Admettons que nous voulions afficher tous les vrais utilisateurs, c'est-à-dire tous ceux qui ne sont pas des utilisateurs système. Comment nous y prendrions-nous ?

Une première approche consisterait à considérer que les vrais utilisateurs disposent tous d'un shell de connexion, en l'occurrence /bin/bash. Il suffirait donc d'afficher toutes les lignes du fichier /etc/passwd qui contiennent la chaîne de caractères /bin/bash ou, plus simplement, bash. C'est tout à fait possible. J'en profite pour vous présenter la commande grep :

$ grep bash /etc/passwd
root:x:0:0:root:/root:/bin/bash
microlinux:x:1000:1000:Microlinux:/home/microlinux:/bin/bash
jmortreux:x:1001:1001:Jean Mortreux:/home/jmortreux:/bin/bash
wchenaoui:x:1002:1002:Wafaa Chenaoui:/home/wchenaoui:/bin/bash
mchabaud:x:1003:1003:Marion Chabaud:/home/mchabaud:/bin/bash
gdangla:x:1004:1004:Guillaume Dangla:/home/gdangla:/bin/bash

L'opération ressemble à un succès. Même si root semble être un cas à part, les utilisateurs en chair et en os sont tous là.

Or, notre approche souffre d'un certain nombre de points faibles. Si l'un de nos utilisateurs décide de choisir un autre shell de connexion que /bin/bash (ce qui est tout à fait possible), il ne s'affichera plus. Essayons donc une approche différente.

Nous avons vu plus haut que ce qui distingue les utilisateurs « en chair et en os », c'est leur UID supérieur à 999 et inférieur à 65534. Nous avons vu également que le fichier /etc/passwd était organisé en colonnes séparées par des deux-points.

Je vais me servir de l'outil de filtrage awk pour arriver à mes fins. GNU AWK est un véritable langage de traitement de lignes qui sert à manipuler des fichiers textes. Voyons quelques exemples simples.

La première colonne du fichier /etc/passwd contient les noms d'utilisateurs :

$ awk -F: '{print $1}' /etc/passwd
root
bin
daemon
...
microlinux
jmortreux
wchenaoui
mchabaud
gdangla

L'option -F indique à awk que le fichier /etc/passwd utilise les deux-points comme séparateur, et '{print $1}' signifie « affiche la première colonne ».

Les UID des utilisateurs figurent dans la troisième colonne. Je peux donc les « extraire » de la sorte :

$ awk -F: '{print $3}' /etc/passwd
0
1
2
3
...
1000
1001
1002
1003
1004

À partir de là, j'ai la réponse à ma question. Il suffit que j'affiche la première colonne ($1) de chaque ligne où le contenu de la troisième colonne ($3) est strictement supérieur à 999 et inférieur à 65534 :

$ awk -F: '$3 > 999 && $3 < 65534 {print $1}' /etc/passwd
microlinux
jmortreux
wchenaoui
mchabaud
gdangla

Enfin, je peux combiner la commande précédente avec sort pour afficher le résultat par ordre alphabétique :

$ awk -F: '$3 > 999 && $3 < 65534 {print $1}' /etc/passwd | sort
gdangla
jmortreux
mchabaud
microlinux
wchenaoui

Vue détaillée sur l'ajout d'un utilisateur

La commande useradd telle qu'on la trouve dans un système Red Hat Enterprise Linux ou dans un de ses clones comme AlmaLinux ou Rocky Linux présente un comportement par défaut qui la rend immédiatement utilisable, sans que l'on ait trop à se casser la tête sur les différentes options à spécifier. En résumé, que se passe-t-il lors de la création simple d'un utilisateur sans autre option, c'est-à-dire en invoquant la commande useradd ?

• L'utilisateur reçoit un UID supérieur ou égal à 1000. Tout laisse à penser (selon le contenu de /etc/passwd) que le système choisit le premier UID disponible à partir de 1000.

• Tous les utilisateurs sont affectés d'emblée à un groupe nommé d'après leur identifiant, dont le GID est égal à l'UID. Dans notre exemple, jmortreux (UID 1001) est également membre du groupe jmortreux (GID 1001).

• Un répertoire personnel est créé, et c'est l'identifiant de l'utilisateur qui servira de base pour le nommer. L'utilisatrice wchenaoui aura donc un répertoire /home/wchenaoui.

• Par défaut, c'est l'interpréteur de commandes Bash (/bin/bash) qui sera utilisé.

Les options par défaut de useradd

Vous vous doutez probablement que les options par défaut de la commande useradd ne sont pas gravées dans le marbre. Elles sont fournies par les fichiers de configuration /etc/login.defs et /etc/default/useradd.

Le profil par défaut des nouveaux utilisateurs

Parmi les utilisateurs nouvellement créés, prenons-en un qui ne s'est pas encore connecté au système. Au moment de la création de son compte, son répertoire personnel se trouve apparemment vide :

$ sudo tree /home/gdangla/
/home/gdangla/

0 directories, 0 files

En fait, il n'est pas si vide que cela, si nous regardons d'un peu plus près :

$ sudo tree -a /home/gdangla/
/home/gdangla/
├── .bash_history
├── .bash_logout
├── .bash_profile
├── .bashrc
└── .mozilla
    ├── extensions
    └── plugins

3 directories, 4 files

D'où sortent ces mystérieux fichiers .bash_logout, .bash_profile et .bashrc ? Comment se fait-il que l'utilisateur dispose déjà d'un répertoire .mozilla alors que nous sommes sûrs qu'il ne s'est pas encore connecté pour lancer le navigateur web Mozilla Firefox. Jetons un œil dans la page man de useradd, dans la section OPTIONS :

-k, --skel SKEL_DIR
The skeleton directory, which contains files and directories to be copied
in the user's home directory, when the home directory is created by
useradd.

This option is only valid if the -m (or --create-home) option is specified.

If this option is not set, the skeleton directory is defined by the SKEL
variable in /etc/default/useradd or, by default, /etc/skel.
...

Vérifions la définition de la variable SKEL dans le fichier /etc/default/useradd :

$ grep SKEL /etc/default/useradd
SKEL=/etc/skel

Le répertoire squelette de notre système, c'est bien /etc/skel. Affichons le contenu de ce répertoire en prenant soin d'afficher les fichiers cachés :

$ tree -a /etc/skel/
/etc/skel/
├── .bash_logout
├── .bash_profile
├── .bashrc
└── .mozilla
    ├── extensions
    └── plugins

3 directories, 3 files

Cela ressemble effectivement au contenu de mon répertoire personnel nouvellement créé. Pour en avoir le cœur net, tentons une petite expérience.

Personnaliser le profil par défaut des nouveaux utilisateurs

Nous pourrions très bien imaginer la confection d'un fichier de bienvenue pour les nouveaux utilisateurs de notre système. Dans un premier temps, nous créons le message dans /etc/skel :

$ sudo vim /etc/skel/LISEZ_MOI.txt
Bienvenue sur votre nouveau système Linux !

À présent, créons un nouvel utilisateur fantasio :

$ sudo useradd -c "Fantasio" fantasio
$ sudo passwd fantasio

Avant même qu'il ne se connecte pour la première fois, jetons un œil au contenu de son répertoire personnel :

$ sudo ls -la /home/fantasio/
total 16
drwx------. 3 fantasio fantasio  99 25 sept. 08:06 .
drwxr-xr-x. 8 root     root     105 25 sept. 08:06 ..
-rw-r--r--. 1 fantasio fantasio  18 30 avril  2024 .bash_logout
-rw-r--r--. 1 fantasio fantasio 141 30 avril  2024 .bash_profile
-rw-r--r--. 1 fantasio fantasio 492 30 avril  2024 .bashrc
-rw-r--r--. 1 fantasio fantasio  45 25 sept. 08:06 LISEZ_MOI.txt
drwxr-xr-x. 4 fantasio fantasio  39 20 mai   22:12 .mozilla

Une configuration personnalisée pour tous les utilisateurs

L'utilisation de /etc/skel ne se limite pas à l'ajout de documents par défaut. De manière plus générale, tout fichier peut être distribué aux nouveaux utilisateurs. On peut donc également répliquer des configurations par défaut du bureau ou des logiciels et définir par exemple le même fond d'écran et le même thème d'icônes par défaut pour tous les utilisateurs. Il suffit pour cela de repérer le fichier (ou répertoire) de configuration en question et de le recopier dans /etc/skel avant la création des utilisateurs.

Modifier le mot de passe d'un utilisateur

Nous avons vu que la création d'un nouveau compte comprend l'affectation d'un mot de passe avec la commande passwd. Celle-ci n'est d'ailleurs pas réservée à l'administrateur. Appelée par un simple utilisateur, elle lui servira à changer son mot de passe pour quelque chose de plus personnalisé :

[fantasio@sandbox ~]$ passwd
Changement de mot de passe pour l'utilisateur fantasio.
Mot de passe actuel : ********
Nouveau mot de passe : ********
Retapez le nouveau mot de passe : ********
passwd : mise à jour réussie de tous les jetons d'authentification.

Il arrive assez souvent que les utilisateurs choisissent des mots de passe trop simples. Dans ce cas, le système les en empêchera et se chargera de les sermonner :

[fantasio@sandbox ~]$ passwd
Changement de mot de passe pour l'utilisateur fantasio.
Mot de passe actuel : ********
Nouveau mot de passe : ****
MOT DE PASSE INCORRECT : Le mot de passe comporte moins de 8 caractères
passwd: Erreur de manipulation du jeton d'authentification

Notez que cette restriction ne vaut pas pour l'administrateur root. Autrement dit, si vous avez la mauvaise idée de définir un mot de passe simpliste comme 1234 ou azerty pour l'utilisateur fantasio, vous devrez le faire comme ceci, en insistant un peu :

# passwd fantasio

Associer les utilisateurs aux groupes

La commande groups présentée un peu plus haut nous a affiché le ou les groupes auxquels appartient l'utilisateur. Vous pouvez vous représenter cette appartenance à un groupe comme une carte de membre, qui vous ouvre les portes vers des lieux dont l'accès est normalement restreint.

Sur un système de la famille Red Hat, chaque utilisateur nouvellement créé fait partie au minimum d'un groupe nommé d'après son identifiant :

$ groups jmortreux
jmortreux : jmortreux
$ groups mchabaud
mchabaud : mchabaud

Les utilisateurs membres de certains groupes bénéficient de toute une série de « privilèges », qui leur donnent accès à certaines parties du système :

$ groups microlinux
microlinux : microlinux wheel

Le rôle du groupe wheel

Comment se fait-il que l'utilisateur microlinux soit membre du groupe wheel ? Rappelez-vous qu'il a été créé lors de l'installation initiale. Sur un système Red Hat, le groupe wheel sert avant tout à différencier les utilisateurs qui ont le droit de se servir de la commande sudo (que nous avons déjà utilisée à la façon de Monsieur Jourdain dans Le Bourgeois Gentilhomme, en faisant de la prose sans le savoir). Si nous avons coché la case Faire de cet utilisateur un administrateur, nous avons ajouté notre utilisateur initial à ce groupe privilégié.

Admettons que je souhaite élever l'utilisateur jmortreux au rang d'administrateur. Je peux l'ajouter au groupe wheel comme ceci :

$ sudo usermod -aG wheel jmortreux

Prise en compte de l'ajout à un groupe

Si jmortreux est connecté pendant cette opération, il faudra qu'il se déconnecte et qu'il se reconnecte pour que l'ajout au groupe wheel prenne effet.

N'hésitez pas à ouvrir la page man 8 usermod pour avoir une idée un peu plus précise de ce que nous venons de faire :

• usermod modifie un compte utilisateur.

• L'option -a (comme --append) ajoute l'utilisateur à un groupe supplémentaire.

• Elle s'utilise conjointement avec l'option -G (--groups).

Comprendre le fichier /etc/group

Maintenant que vous êtes familiarisés avec le fonctionnement des fichiers /etc/passwd et /etc/shadow, affichez le fichier /etc/group :

$ less /etc/group
root:x:0:
bin:x:1:
daemon:x:2:
sys:x:3:
...
wheel:x:10:microlinux,jmortreux
cdrom:x:11:
mail:x:12:
...
openvpn:x:981:
microlinux:x:1000:
jmortreux:x:1001:
wchenaoui:x:1002:
mchabaud:x:1003:
gdangla:x:1004:
fantasio:x:1005:

Pour comprendre en détail la syntaxe de ce fichier, nous avons développé le bon réflexe :

$ apropos group
$ man 5 group

Tout comme pour les utilisateurs, nous avons ici :

• un groupe root avec un GID de 0

• une série de groupes système avec des GID compris entre 1 et 999

• les groupes correspondant aux utilisateurs, avec des GID supérieurs ou égaux à 1000

• le groupe système nobody avec un GID de 65534

Dans l'exemple ci-dessus, regardez la ligne qui définit le groupe wheel. Notez que les membres de ce groupe sont énumérés avec une virgule comme séparateur, et sans espace.

Supprimer un utilisateur d'un groupe

La manière la plus simple pour révoquer l'appartenance d'un utilisateur à un groupe, c'est d'utiliser la commande gpasswd. Admettons que jmortreux ait mis en péril notre installation. Nous allons le supprimer du groupe wheel :

$ groups jmortreux
jmortreux : jmortreux wheel
$ sudo gpasswd -d jmortreux wheel
Removing user jmortreux from group wheel
$ groups jmortreux
jmortreux : jmortreux

Là encore, jetez un œil dans man gpasswd et repérez l'option -d comme --delete.

Créer et supprimer des groupes

Bien évidemment, nous ne sommes pas limités à l'utilisation des groupes prédéfinis sur la machine. En guise d'exemple, créons deux groupes formateurs et direction, puis ajoutons les utilisateurs microlinux, wchenaoui, jmortreux, mchabaud et gdangla à leurs groupes respectifs, sachant que certains appartiennent aux deux groupes :

$ sudo groupadd formateurs
$ sudo groupadd direction
$ sudo usermod -aG formateurs microlinux
$ sudo usermod -aG formateurs jmortreux
$ sudo usermod -aG formateurs gdangla
$ sudo usermod -aG formateurs mchabaud
$ sudo usermod -aG direction wchenaoui
$ sudo usermod -aG direction jmortreux
$ sudo usermod -aG direction mchabaud

Pour apprécier le résultat de l'opération, ouvrez /etc/group et examinez les deux dernières lignes du fichier. Vous pourriez très bien utiliser cat, more ou less pour visualiser /etc/group, mais j'en profite en passant pour vous présenter la commande tail. Dans sa configuration par défaut, tail affiche les dix dernières lignes du fichier fourni en argument. L'option -n 2 nous limitera aux deux dernières lignes :

$ tail -n 2 /etc/group
formateurs:x:1006:microlinux,jmortreux,gdangla,mchabaud
direction:x:1007:wchenaoui,jmortreux,mchabaud

Pour supprimer un groupe, utilisez la commande groupdel :

$ sudo groupdel formateurs
$ sudo groupdel direction

Supprimer un utilisateur

Vous voilà en mesure de créer des utilisateurs et de gérer leurs comptes. Il ne vous reste plus qu'à savoir comment vous en débarrasser, le cas échéant. Comme un employé doit vider son bureau et rendre son badge, il arrive qu'un utilisateur n'ait plus la place sur votre système. Dans ce cas, vous serez amené à supprimer son compte. C'est l'objet de la commande userdel.

Appliquons-la sur l'utilisateur fantasio :

$ sudo userdel fantasio

Malheureusement, il y a un détail auquel nous n'avons pas pensé :

$ ls -l /home/
total 4
drwx------.  3       1005       1005  120 25 sept. 08:53 fantasio
drwx------.  3 gdangla    gdangla      99 24 sept. 07:45 gdangla
drwx------.  3 jmortreux  jmortreux    78 24 sept. 07:21 jmortreux
drwx------.  3 mchabaud   mchabaud     78 24 sept. 07:30 mchabaud
drwx------. 21 microlinux microlinux 4096 25 sept. 09:06 microlinux
drwx------.  3 wchenaoui  wchenaoui    78 24 sept. 07:27 wchenaoui

La commande userdel s'est chargée de supprimer l'utilisateur fantasio, mais pas son répertoire personnel.

Les fichiers et répertoires de /home/fantasio sont toujours là, mais ils « appartiennent » à présent à l'UID 1005 et au GID 1005. Admettons que vous ayez maintenant l'idée de créer un nouveau compte et de lui affecter ces identifiants d'utilisateur et de groupe désormais vacants. Il se retrouverait propriétaire de tous les fichiers de fantasio. Autrement dit : fantasio a rendu son badge, mais il n'a vidé ni son bureau ni son casier, et c'est le nouvel employé qui a désormais la clé.

Lors de la suppression, il peut donc s'avérer nécessaire de supprimer le répertoire personnel correspondant au compte. Cependant, si nous affichons la page man de la commande userdel, nous lisons ceci :

OPTIONS
...
-r, --remove
Les fichiers présents dans le répertoire personnel de l'utilisateur seront
supprimés en même temps que le répertoire lui-même, ainsi que le répertoire
d'attente des courriels.  Vous devrez rechercher et éliminer vous-même les
fichiers situés dans d'autres systèmes de fichiers.
...

Essayons cette option sur l'utilisatrice mchabaud, que nous avons dans le collimateur depuis un petit moment :

$ sudo userdel -r mchabaud
$ ls -l /home/
total 4
drwx------.  3       1005       1005  120 25 sept. 08:53 fantasio
drwx------.  3 gdangla    gdangla      99 24 sept. 07:45 gdangla
drwx------.  3 jmortreux  jmortreux    78 24 sept. 07:21 jmortreux
drwx------. 21 microlinux microlinux 4096 25 sept. 09:19 microlinux
drwx------.  3 wchenaoui  wchenaoui    78 24 sept. 07:27 wchenaoui

La commande userdel suivie de l'option -r a donc bien supprimé le compte utilisateur mchabaud ainsi que le répertoire personnel /home/mchabaud avec toutes les données qu'il contenait.

Administrer le système avec sudo

Au début de cet atelier pratique, nous avons vu qu'il était possible de changer d'identité grâce à la commande su (switch user), notamment pour devenir root :

[microlinux@sandbox ~]$ head -n 1 /etc/shadow
head: impossible d'ouvrir '/etc/shadow' en lecture: Permission non accordée
[microlinux@sandbox ~]$ su -
Mot de passe :
[root@sandbox ~]# head -n 1 /etc/shadow
root:$6$fWAwtE0GgCEL04Jl$YzZSsKqKgs9QQIWRBAaBYRuYER18Vw6g1::0:99999:7:::

La commande head

Un peu plus haut, nous avons vu la commande tail qui sert à afficher les dernières lignes d'un fichier. Dans sa configuration par défaut, head affiche les dix premières lignes d'un fichier. L'option -n 1 limite l'affichage à la première ligne.

Une autre manière de faire, c'est d'utiliser la commande sudo. Elle permet littéralement de « faire (do) en se substituant à l'utilisateur (su) », en l'occurrence lancer une commande en tant qu'administrateur. Dans l'exemple qui suit, notez bien que je saisis le mot de passe de microlinux et non pas celui de root :

[microlinux@sandbox ~]$ head -n 1 /etc/shadow
head: impossible d'ouvrir '/etc/shadow' en lecture: Permission non accordée
[microlinux@sandbox ~]$ sudo head -n 1 /etc/shadow
[sudo] Mot de passe de microlinux : ********
root:$6$fWAwtE0GgCEL04Jl$YzZSsKqKgs9QQIWRBAaBYRuYER18Vw6g1::0:99999:7:::

Lorsqu'un utilisateur invoque sudo pour la première fois, le système affiche un avertissement solennel :

Nous espérons que vous avez reçu de votre administrateur système local
les consignes traditionnelles. Généralement, elles se concentrent sur 
ces trois éléments :

  #1) Respectez la vie privée des autres.
  #2) Réfléchissez avant d'utiliser le clavier.
  #3) De grands pouvoirs confèrent de grandes responsabilités.

Rappelez-vous que lors de l'installation du système et de la création de l'utilisateur initial, nous avons coché la case Faire de cet utilisateur un administrateur, ce qui a ajouté l'utilisateur au groupe privilégié wheel. Le principal privilège de ce groupe est défini dans le fichier /etc/sudoers :

## Allows people in group wheel to run all commands
%wheel ALL=(ALL) ALL

Voilà comment se présentent les choses lorsque sudo est invoqué par un utilisateur qui ne dispose pas de ce privilège :

[gdangla@sandbox ~]$ sudo head -n 1 /etc/shadow
[sudo] Mot de passe de gdangla : ********
gdangla n'apparaît pas dans le fichier sudoers. Cet incident sera signalé.

Le signalement en question a lieu dans le fichier /var/log/secure et ressemble à ceci :

Sep 25 10:14:49 sandbox sudo[2854]: gdangla : user NOT in sudoers ; TTY=pts/0 ; 
PWD=/home/gdangla ; USER=root ; COMMAND=/bin/head -n 1 /etc/shadow

Utiliser su ou sudo ?

Dans le monde d'Unix et de Linux, il existe en gros deux écoles pour s'acquitter des tâches administratives :

• travailler directement en tant que root lorsque cela est nécessaire

• se connecter en tant qu'utilisateur simple et utiliser sudo lorsqu'une tâche le requiert

Certaines distributions – comme Ubuntu par exemple – favorisent explicitement l'approche avec sudo en désactivant le compte root dans la configuration par défaut.

Quelle est donc la « meilleure » approche ici ? Je me garderai de trancher la question, et je me contenterai d'attirer votre attention sur les principales différences entre les deux manières de faire :

• Travailler directement en tant que root est certainement plus confortable.

• Utiliser sudo n'a jamais empêché personne de se tirer dans le pied.

• Le principal argument en faveur de sudo, c'est sans doute la journalisation des opérations dans /var/log/secure. Si vous travaillez en tant qu'utilisateur simple et que vous utilisez sudo, tout ce que vous faites est enregistré dans ce fichier. Ce qui n'est pas le cas pour root. Essayez pour voir.