Gestion des utilisateurs et des groupes sous Red Hat Enterprise Linux

Introduction

Dans ce laboratoire, vous acquerrez des compétences essentielles dans la gestion des utilisateurs et des groupes locaux au sein d'un environnement Red Hat Enterprise Linux (RHEL). Vous commencerez par comprendre les concepts fondamentaux des utilisateurs et des groupes, notamment comment identifier les informations sur les utilisateurs et les groupes, ainsi que la propriété des fichiers.

Par la suite, vous apprendrez à obtenir un accès superutilisateur, à créer et modifier des comptes d'utilisateurs locaux, à gérer les comptes de groupes locaux et à configurer les politiques de mots de passe des utilisateurs. Cette expérience pratique vous dotera des connaissances nécessaires pour contrôler efficacement l'accès et les permissions sur votre système Linux.

Comprendre les concepts d'utilisateurs et de groupes

Dans cette étape, vous découvrirez les concepts fondamentaux des utilisateurs et des groupes dans Red Hat Enterprise Linux (RHEL) et comment utiliser diverses commandes pour inspecter les informations sur les utilisateurs et les groupes. La compréhension de ces concepts est cruciale pour la gestion des permissions et du contrôle d'accès sur un système Linux.

Chaque fichier et processus sur un système Linux est associé à un utilisateur et à un groupe. Cette association détermine qui peut lire, écrire ou exécuter des fichiers, et qui peut gérer les processus.

Tout d'abord, explorons comment identifier l'utilisateur actuel et les autres utilisateurs du système à l'aide de la commande id.

Utilisez la commande id pour afficher des informations sur l'utilisateur actuellement connecté. Cette commande affiche l'ID utilisateur (UID), l'ID de groupe principal (GID) et tous les groupes auxquels l'utilisateur appartient.
```
id
```
Vous devriez voir une sortie similaire à celle-ci, indiquant les informations de votre utilisateur labex :
```
uid=1000(labex) gid=1000(labex) groups=1000(labex),10(wheel) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
```
Pour afficher des informations de base sur un autre utilisateur, tel que l'utilisateur root, passez le nom d'utilisateur à la commande id en tant qu'argument.
```
id root
```
La sortie affichera l'UID (0), le GID (0) et les groupes de l'utilisateur root :
```
uid=0(root) gid=0(root) groups=0(root) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
```

Ensuite, vous apprendrez à identifier le propriétaire des fichiers et des répertoires à l'aide de la commande ls.

Utilisez la commande ls -l pour afficher le propriétaire d'un fichier. Tout d'abord, créez un fichier factice dans votre répertoire ~/project.
```
touch ~/project/mytextfile.txt
ls -l ~/project/mytextfile.txt
```
La sortie affichera labex comme propriétaire utilisateur et groupe de mytextfile.txt :
```
-rw-r--r-- 1 labex labex 0 Feb  5 11:10 /home/labex/project/mytextfile.txt
```
Utilisez la commande ls -ld pour afficher le propriétaire d'un répertoire, plutôt que le contenu de ce répertoire. Dans la sortie suivante, la troisième colonne affiche le nom d'utilisateur et la quatrième colonne affiche le nom du groupe.
```
ls -ld ~/project
```
Vous verrez labex comme propriétaire de votre répertoire ~/project :
```
drwxr-xr-x 2 labex labex 6 Feb  5 11:10 /home/labex/project
```

Maintenant, examinons comment afficher les informations sur les processus et l'utilisateur associé à chaque processus à l'aide de la commande ps.

Utilisez la commande ps -au pour afficher les processus. L'option a affiche tous les processus avec un terminal, et l'option u affiche l'utilisateur associé à un processus. Dans la sortie suivante, la première colonne affiche le nom d'utilisateur.

ps -au

Vous verrez divers processus, avec labex et root comme utilisateurs courants :

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.0  10608  3808 ?        Ss   00:00   0:00 /sbin/init
root        42  0.0  0.0  10608  3808 ?        Ss   00:00   0:00 /sbin/init
labex      123  0.0  0.1 224152  5756 pts/0    Ss   00:00   0:00 -bash
labex      150  0.0  0.0 225556  3652 pts/0    R+   00:00   0:00 ps -au

Enfin, vous explorerez les fichiers /etc/passwd et /etc/group, qui stockent respectivement les informations sur les utilisateurs et les groupes. Ces fichiers sont essentiels pour comprendre comment les comptes d'utilisateurs et de groupes sont définis sur un système Linux.

Chaque ligne du fichier /etc/passwd contient des informations sur un utilisateur. Le fichier est divisé en sept champs séparés par des deux-points. Utilisez cat pour afficher son contenu.
```
cat /etc/passwd
```
Localisez l'entrée pour labex et root. Pour labex, cela devrait ressembler à ceci :
```
labex:x:1000:1000:LabEx User:/home/labex:/bin/bash
```
Décomposons chaque champ :
- labex : Le nom d'utilisateur pour cet utilisateur.
- x : Le mot de passe crypté de l'utilisateur était historiquement stocké ici ; il s'agit désormais d'un espace réservé, car les mots de passe sont stockés dans /etc/shadow pour des raisons de sécurité.
- 1000 : Le numéro UID pour ce compte utilisateur.
- 1000 : Le numéro GID pour le groupe principal de ce compte utilisateur.
- LabEx User : Un bref commentaire, une description ou le nom réel de cet utilisateur.
- /home/labex : Le répertoire personnel de l'utilisateur et le répertoire de travail initial lorsque le shell de connexion démarre.
- /bin/bash : Le programme shell par défaut pour cet utilisateur qui s'exécute lors de la connexion.
Chaque ligne du fichier /etc/group contient des informations sur un groupe. Chaque entrée de groupe est divisée en quatre champs séparés par des deux-points. Utilisez cat pour afficher son contenu.
```
cat /etc/group
```
Vous verrez des entrées pour divers groupes système et groupes privés d'utilisateurs. Par exemple, l'entrée du groupe labex pourrait ressembler à ceci :
```
labex:x:1000:
```
Décomposons chaque champ :
- labex : Nom de ce groupe.
- x : Champ de mot de passe de groupe obsolète ; il s'agit désormais d'un espace réservé.
- 1000 : Le numéro GID pour ce groupe.
- (vide) : Une liste des utilisateurs qui sont membres de ce groupe en tant que groupe secondaire. Si ce champ est vide, cela signifie qu'aucun utilisateur supplémentaire n'est explicitement répertorié comme membre secondaire de ce groupe (bien que l'utilisateur principal labex soit implicitement membre).
Groupes principaux et groupes secondaires :
Chaque utilisateur a exactement un groupe principal. Pour les utilisateurs locaux, ce groupe est répertorié par GID dans le fichier /etc/passwd. Le groupe principal est propriétaire des fichiers que l'utilisateur crée. Lors de la création d'un utilisateur régulier, un groupe est souvent créé avec le même nom que l'utilisateur, pour être le groupe principal de l'utilisateur. L'utilisateur est généralement le seul membre de ce User Private Group. Cette conception simplifie la gestion des permissions de fichiers.

Les utilisateurs peuvent également avoir des groupes secondaires. L'appartenance à des groupes secondaires est stockée dans le fichier /etc/group. Les utilisateurs se voient accorder l'accès aux fichiers en fonction de la possibilité pour l'un de leurs groupes d'y accéder, que les groupes soient principaux ou secondaires. Par exemple, si l'utilisateur labex a un groupe principal labex et wheel comme groupe secondaire, alors cet utilisateur peut lire les fichiers que l'un de ces deux groupes peut lire.

La commande id peut afficher toutes les appartenances à des groupes pour un utilisateur. Rappelez-vous la sortie de id pour labex :
```
uid=1000(labex) gid=1000(labex) groups=1000(labex),10(wheel) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
```
Ici, gid=1000(labex) indique que labex est le groupe principal. groups=1000(labex),10(wheel) répertorie toutes les appartenances à des groupes, montrant labex comme groupe principal et wheel comme groupe secondaire.

Obtenir un accès superutilisateur

Dans cette étape, vous apprendrez à obtenir un accès superutilisateur (privilèges root) sur un système RHEL. L'accès superutilisateur est essentiel pour effectuer des tâches administratives telles que l'installation de logiciels, la gestion des utilisateurs et la configuration des paramètres du système. Vous explorerez les commandes su et sudo, qui sont les principaux outils pour l'élévation des privilèges.

La commande su (substitute user) vous permet de basculer vers un autre compte utilisateur. Lorsqu'elle est utilisée sans nom d'utilisateur, elle utilise par défaut l'utilisateur root.

Utilisez la commande su - pour basculer vers l'utilisateur root. L'option tiret (-) garantit que vous obtenez un shell de connexion, ce qui signifie que les variables d'environnement et le chemin de l'utilisateur root seront chargés. Vous serez invité à saisir le mot de passe root, qui est redhat.
```
su -
```
Après avoir entré le mot de passe redhat, votre invite passera à [root@host ~]#, indiquant que vous êtes maintenant l'utilisateur root.
```
Password:
[root@host ~]#
```
Pour vérifier que vous êtes root, vous pouvez exécuter la commande whoami :
```
whoami
```
La sortie devrait être :
```
root
```
Pour quitter le shell root et revenir à votre utilisateur labex, tapez exit.
```
exit
```
Votre invite reviendra à [labex@host ~]$.

La commande sudo (superuser do) permet à un utilisateur autorisé d'exécuter une commande en tant que superutilisateur ou un autre utilisateur, comme spécifié par le fichier sudoers. L'utilisateur labex est configuré pour avoir des privilèges sudo sans nécessiter de mot de passe, ce qui est courant dans de nombreux environnements cloud et de laboratoire.

Utilisez la commande sudo -i pour basculer vers le compte root. Cette commande est généralement préférée à su - car elle offre un moyen plus sûr d'exécuter des commandes avec des privilèges élevés. Lorsque vous utilisez sudo -i, vous utilisez toujours votre propre compte utilisateur mais avec les privilèges root, et les commandes sont enregistrées sur votre compte, ce qui facilite le suivi de ce qui a été fait.
```
sudo -i
```
Votre invite passera à [root@host ~]#, indiquant que vous êtes maintenant l'utilisateur root.
```
[root@host ~]#
```
Encore une fois, vous pouvez vérifier avec whoami :
```
whoami
```
La sortie devrait être :
```
root
```
Pour quitter le shell root et revenir à votre utilisateur labex, tapez exit.
```
exit
```
Votre invite reviendra à [labex@host ~]$.
Vous pouvez également utiliser sudo pour exécuter une seule commande avec des privilèges root sans basculer vers le shell root. Par exemple, pour afficher le contenu de /etc/shadow (qui n'est lisible que par root), vous pouvez utiliser sudo cat /etc/shadow.
```
sudo cat /etc/shadow | head -n 3
```
Cela affichera les trois premières lignes du fichier /etc/shadow, démontrant que la commande cat a été exécutée avec les privilèges root.
```
root:*:19780:0:99999:7:::
bin:*:19780:0:99999:7:::
daemon:*:19780:0:99999:7:::
```
Le fichier /etc/sudoers est le principal fichier de configuration de la commande sudo. Il définit quels utilisateurs ou groupes peuvent exécuter quelles commandes avec des privilèges élevés. Pour éviter les problèmes si plusieurs administrateurs essaient de modifier le fichier en même temps, vous ne devez le modifier qu'avec la commande spéciale visudo. L'éditeur visudo valide également le fichier, pour garantir l'absence d'erreurs de syntaxe.

Une entrée courante dans /etc/sudoers permet aux membres du groupe wheel d'exécuter n'importe quelle commande en tant que root. L'utilisateur labex est membre du groupe wheel, c'est pourquoi sudo fonctionne sans mot de passe.
```
sudo grep wheel /etc/sudoers
```
Vous devriez voir une ligne similaire à celle-ci, qui accorde l'accès sudo au groupe wheel :
```
%wheel        ALL=(ALL:ALL)       ALL
```
Cette ligne signifie :
- %wheel : La règle s'applique aux membres du groupe wheel. Le symbole % désigne un groupe.
- ALL=(ALL:ALL) : Sur n'importe quel hôte (premier ALL), les utilisateurs du groupe wheel peuvent exécuter des commandes en tant que n'importe quel utilisateur (deuxième ALL) et n'importe quel groupe (troisième ALL).
- ALL : Les utilisateurs du groupe wheel peuvent exécuter n'importe quelle commande.

Ceci conclut votre exploration de l'obtention d'un accès superutilisateur. Vous comprenez maintenant la différence entre su - et sudo -i et comment exécuter des commandes avec des privilèges élevés.

Créer et modifier des comptes utilisateurs locaux

Dans cette étape, vous apprendrez à créer, modifier et supprimer des comptes d'utilisateurs locaux sur un système RHEL. La gestion des comptes d'utilisateurs est une tâche administrative fondamentale, garantissant que chaque utilisateur dispose des accès et des permissions appropriés. Vous utiliserez des commandes telles que useradd, usermod, userdel et passwd.

Tout d'abord, créons un nouveau compte utilisateur.

Utilisez la commande useradd pour créer un nouvel utilisateur. Par défaut, useradd crée un nouvel utilisateur avec un UID supérieur ou égal à 1000, crée un répertoire personnel (/home/nom_utilisateur) et définit le shell par défaut sur /bin/bash. Vous avez besoin des privilèges sudo pour exécuter cette commande. Créons un utilisateur nommé testuser01.
```
sudo useradd testuser01
```
Après avoir créé l'utilisateur, vous pouvez vérifier son existence dans /etc/passwd et vérifier son répertoire personnel.
```
grep testuser01 /etc/passwd
ls -ld /home/testuser01
```
Vous devriez voir une sortie similaire à celle-ci :
```
testuser01:x:1001:1001::/home/testuser01:/bin/bash
drwx------. 2 testuser01 testuser01 6 Mar  4 15:22 /home/testuser01
```
Par défaut, les utilisateurs nouvellement créés n'ont pas de mot de passe défini, ce qui signifie qu'ils ne peuvent pas se connecter. Vous devez définir un mot de passe pour testuser01 à l'aide de la commande passwd.
```
sudo passwd testuser01
```
Vous serez invité à saisir un nouveau mot de passe. Pour ce laboratoire, utilisez labexrhel9 comme mot de passe pour testuser01. Vous pourriez voir un avertissement "MAUVAIS MOT DE PASSE", mais vous pouvez continuer.
```
New password:
Retype new password:
passwd: all authentication tokens updated successfully.
```
Maintenant, essayez de basculer vers testuser01 en utilisant su -.
```
su - testuser01
```
Entrez le mot de passe labexrhel9 lorsque vous y êtes invité. Votre invite devrait passer à [testuser01@host ~]$.
```
Password:
[testuser01@host ~]$
```
Pour revenir à votre utilisateur labex, tapez exit.
```
exit
```

Ensuite, modifions un compte utilisateur existant à l'aide de la commande usermod. La commande usermod vous permet de modifier diverses propriétés d'un utilisateur, telles que son répertoire personnel, son shell ou son appartenance à des groupes.

Modifions le champ commentaire (nom complet) pour testuser01 en "Test User One".
```
sudo usermod -c "Test User One" testuser01
```
Vérifiez la modification en vérifiant à nouveau le fichier /etc/passwd.
```
grep testuser01 /etc/passwd
```
La sortie devrait maintenant refléter le commentaire mis à jour :
```
testuser01:x:1001:1001:Test User One:/home/testuser01:/bin/bash
```
Vous pouvez également verrouiller ou déverrouiller un compte utilisateur. Le verrouillage d'un compte empêche l'utilisateur de se connecter, tandis que le déverrouillage réactive la connexion.

Pour verrouiller le compte testuser01 :
```
sudo usermod -L testuser01
```
Maintenant, essayez de basculer vers testuser01 à nouveau.
```
su - testuser01
```
Vous serez invité à saisir le mot de passe, mais même avec le mot de passe correct, la connexion échouera :
```
Password:
su: Authentication failure
```
Pour déverrouiller le compte testuser01 :
```
sudo usermod -U testuser01
```
Essayez de basculer vers testuser01 à nouveau, et cela devrait réussir. N'oubliez pas de taper exit pour revenir à labex.
```
su - testuser01
## Enter password 'labexrhel9'
exit
```

Enfin, supprimons le compte utilisateur que vous avez créé.

Utilisez la commande userdel pour supprimer un utilisateur. Par défaut, userdel supprime l'entrée de l'utilisateur de /etc/passwd mais laisse son répertoire personnel intact. Cela peut entraîner des fichiers orphelins.
```
sudo userdel testuser01
```
Vérifiez que l'utilisateur est supprimé de /etc/passwd, mais que le répertoire personnel existe toujours.
```
grep testuser01 /etc/passwd
ls -ld /home/testuser01
```
La commande grep ne devrait renvoyer aucune sortie, indiquant que l'utilisateur a disparu. La commande ls -ld affichera que le répertoire personnel existe toujours, mais sa propriété apparaîtra sous forme d'UID/GID numériques puisque l'utilisateur n'existe plus.
```
drwx------ 2 1001 1001 83 Mar  4 15:22 /home/testuser01
```
Remarque : dans certaines versions ou configurations de RHEL, userdel peut supprimer le répertoire personnel par défaut s'il est vide ou si l'utilisateur était le seul propriétaire. Cependant, il est plus sûr d'utiliser explicitement l'option -r pour s'assurer que le répertoire personnel est supprimé.
Pour supprimer l'utilisateur et son répertoire personnel, utilisez l'option -r avec userdel. Créons un nouvel utilisateur testuser02 pour le démontrer correctement.
```
sudo useradd testuser02
sudo passwd testuser02 ## You'll be prompted to enter 'labexrhel9'
```
Maintenant, supprimez testuser02 et son répertoire personnel :
```
sudo userdel -r testuser02
```
Vérifiez que l'entrée de l'utilisateur et le répertoire personnel sont supprimés.
```
grep testuser02 /etc/passwd
ls -ld /home/testuser02
```
Les deux commandes devraient indiquer que testuser02 et son répertoire personnel n'existent plus.
```
ls: cannot access '/home/testuser02': No such file or directory
```

Ceci conclut votre pratique avec la création, la modification et la suppression de comptes d'utilisateurs locaux.

Gérer les comptes de groupes locaux

Dans cette étape, vous apprendrez à gérer les comptes de groupes locaux sur un système RHEL. Les groupes sont fondamentaux pour gérer efficacement les permissions, vous permettant d'accorder l'accès à plusieurs utilisateurs simultanément. Vous utiliserez des commandes telles que groupadd, groupmod et groupdel, et vous revisiterez également usermod pour gérer les appartenances utilisateur-groupe.

Tout d'abord, créons un nouveau groupe.

Utilisez la commande groupadd pour créer un nouveau groupe. Par défaut, groupadd attribue le prochain GID disponible de la plage spécifiée dans /etc/login.defs. Vous avez besoin des privilèges sudo pour exécuter cette commande. Créons un groupe nommé developers.
```
sudo groupadd developers
```
Vous pouvez vérifier la création du groupe en vérifiant le fichier /etc/group.
```
grep developers /etc/group
```
Vous devriez voir une entrée similaire à celle-ci :
```
developers:x:1002:
```
Vous pouvez également spécifier un GID particulier pour le groupe en utilisant l'option -g. Créons un autre groupe nommé testers avec un GID spécifique, par exemple, 2000.
```
sudo groupadd -g 2000 testers
```
Vérifiez le GID du groupe testers.
```
grep testers /etc/group
```
La sortie devrait confirmer le GID spécifié :
```
testers:x:2000:
```

Ensuite, modifions un groupe existant à l'aide de la commande groupmod.

Vous pouvez modifier le nom d'un groupe en utilisant l'option -n. Renommons testers en qa_team.
```
sudo groupmod -n qa_team testers
```
Vérifiez le changement de nom dans /etc/group.
```
grep qa_team /etc/group
```
La sortie devrait afficher le nouveau nom avec le GID d'origine :
```
qa_team:x:2000:
```
Vous pouvez également modifier le GID d'un groupe en utilisant l'option -g. Modifions le GID de qa_team en 2001.
```
sudo groupmod -g 2001 qa_team
```
Vérifiez le changement de GID.
```
grep qa_team /etc/group
```
La sortie devrait refléter le nouveau GID :
```
qa_team:x:2001:
```

Maintenant, gérons les appartenances des utilisateurs à ces groupes. Vous utiliserez la commande usermod pour cela. Tout d'abord, créez quelques utilisateurs de test.

Créez userA et userB et définissez leurs mots de passe sur labexrhel9.
```
sudo useradd userA
sudo passwd userA
```
Tapez labexrhel9 comme mot de passe pour userA.
```
sudo useradd userB
sudo passwd userB
```
Tapez labexrhel9 comme mot de passe pour userB.
Ajoutez userA au groupe developers en tant que groupe secondaire. Utilisez les options -a (append) et -G (groups) avec usermod.
```
sudo usermod -aG developers userA
```
Vérifiez les appartenances de groupe de userA à l'aide de la commande id.
```
id userA
```
Vous devriez voir developers répertorié dans la section groups :
```
uid=1003(userA) gid=1003(userA) groups=1003(userA),1002(developers)
```
Ajoutez userB aux groupes developers et qa_team en tant que groupes secondaires.
```
sudo usermod -aG developers,qa_team userB
```
Vérifiez les appartenances de groupe de userB.
```
id userB
```
Vous devriez voir developers et qa_team répertoriés :
```
uid=1004(userB) gid=1004(userB) groups=1004(userB),1002(developers),2001(qa_team)
```
Vous pouvez également modifier le groupe principal d'un utilisateur en utilisant l'option -g avec usermod. Modifions le groupe principal de userA en developers.
```
sudo usermod -g developers userA
```
Vérifiez le groupe principal de userA.
```
id userA
```
Le champ gid devrait maintenant afficher developers :
```
uid=1003(userA) gid=1002(developers) groups=1002(developers)
```
Remarque : lorsque vous modifiez le groupe principal d'un utilisateur, il est supprimé de la liste des membres de son ancien groupe principal dans /etc/group si ce groupe était également un groupe secondaire. Dans ce cas, le groupe principal d'origine de userA (userA) n'est plus répertorié en tant que groupe secondaire.

Enfin, supprimons les groupes et les utilisateurs de test que vous avez créés.

Utilisez la commande groupdel pour supprimer un groupe. Vous ne pouvez pas supprimer un groupe s'il est le groupe principal d'un utilisateur. Tout d'abord, modifiez le groupe principal de userA pour qu'il redevienne son groupe par défaut (ou un autre groupe existant) avant de supprimer developers.
```
sudo usermod -g userA userA ## Change userA's primary group back to userA
sudo groupdel developers
```
Vérifiez que developers est supprimé de /etc/group.
```
grep developers /etc/group
```
Cette commande ne devrait renvoyer aucune sortie.
Supprimez le groupe qa_team.
```
sudo groupdel qa_team
```
Vérifiez sa suppression.
```
grep qa_team /etc/group
```
Cette commande ne devrait également renvoyer aucune sortie.

Nettoyez les utilisateurs de test.

sudo userdel -r userA
sudo userdel -r userB

Ceci conclut votre pratique avec la gestion des comptes de groupes locaux et des appartenances utilisateur-groupe.

Configurer les politiques de mots de passe utilisateur

Dans cette étape, vous apprendrez à configurer les politiques de mot de passe utilisateur sur un système RHEL. Les politiques de mot de passe sont cruciales pour améliorer la sécurité en appliquant des règles sur la complexité, l'expiration et le verrouillage des comptes. Vous explorerez le fichier /etc/shadow et la commande chage.

Tout d'abord, comprenons le fichier /etc/shadow, qui stocke les informations de mot de passe chiffrées et les paramètres de vieillissement des mots de passe pour les comptes d'utilisateurs. Ce fichier est très sensible et n'est lisible que par l'utilisateur root.

Chaque utilisateur a une entrée dans le fichier /etc/shadow. Créons un nouvel utilisateur policyuser et définissons son mot de passe sur labexrhel9 à des fins de démonstration.
```
sudo useradd policyuser
sudo passwd policyuser
```
Tapez labexrhel9 comme mot de passe pour policyuser.
Maintenant, affichez l'entrée pour policyuser dans /etc/shadow.
```
sudo grep policyuser /etc/shadow
```
Vous verrez une sortie similaire à celle-ci :
```
policyuser:$6$randomsalt$encryptedhash:19780:0:99999:7:::
```
Décomposons chaque champ, séparé par deux points :
- policyuser: Nom du compte utilisateur.
- $6$randomsalt$encryptedhash: Le mot de passe chiffré de l'utilisateur.
  - $6: L'algorithme de hachage utilisé pour ce mot de passe (SHA-512, la valeur par défaut de RHEL 9).
  - randomsalt: Le sel utilisé pour chiffrer le mot de passe ; initialement choisi au hasard.
  - encryptedhash: Le hachage chiffré du mot de passe de l'utilisateur.
- 19780: Le nombre de jours depuis l'époque (1970-01-01 UTC) où le mot de passe a été modifié pour la dernière fois. Ce nombre variera en fonction de la date actuelle.
- 0: Le nombre minimum de jours depuis la dernière modification du mot de passe avant que l'utilisateur puisse le modifier à nouveau.
- 99999: Le nombre maximum de jours sans modification du mot de passe avant l'expiration du mot de passe. Un champ vide signifie que le mot de passe n'expire jamais.
- 7: Le nombre de jours avant d'avertir l'utilisateur que son mot de passe expirera.
- (vide) : Le nombre de jours sans activité, à partir du jour de l'expiration du mot de passe, avant que le compte ne soit automatiquement verrouillé.
- (vide) : Le jour de l'expiration du compte en jours depuis l'époque. Un champ vide signifie que le compte n'expire jamais.
- Le dernier champ est généralement vide et réservé à une utilisation future.

Ensuite, vous utiliserez la commande chage pour modifier ces paramètres de vieillissement des mots de passe. La commande chage vous permet de modifier les informations d'expiration du mot de passe utilisateur.

Définissons une politique de mot de passe pour policyuser avec les règles suivantes :
- Nombre minimum de jours entre les modifications de mot de passe : 7 jours (-m 7)
- Nombre maximum de jours entre les modifications de mot de passe : 90 jours (-M 90)
- Période d'avertissement avant l'expiration du mot de passe : 14 jours (-W 14)
- Période d'inactivité après l'expiration du mot de passe avant le verrouillage du compte : 30 jours (-I 30)
```
sudo chage -m 7 -M 90 -W 14 -I 30 policyuser
```

Pour vérifier ces modifications, vous pouvez utiliser chage -l (list) pour afficher les informations actuelles de vieillissement du mot de passe pour policyuser.

sudo chage -l policyuser

Vous devriez voir une sortie reflétant la nouvelle politique :

Last password change     : Mar 04, 2024
Password expires     : Jun 02, 2024
Password inactive     : Jul 02, 2024
Account expires      : never
Minimum number of days between password change  : 7
Maximum number of days between password change  : 90
Number of days of warning before password expires : 14

Remarque : Les dates varieront en fonction du moment où vous effectuez le laboratoire.

Vous pouvez également définir une date d'expiration de compte absolue en utilisant l'option -E. Définissons l'expiration du compte de policyuser dans 30 jours à partir d'aujourd'hui. Tout d'abord, obtenez la date d'aujourd'hui et calculez la date dans 30 jours.
```
EXPIRY_DATE=$(date -d "+30 days" +%Y-%m-%d)
echo "Account will expire on: $EXPIRY_DATE"
sudo chage -E $EXPIRY_DATE policyuser
```
Vérifiez la date d'expiration du compte.
```
sudo chage -l policyuser | grep "Account expires"
```
La sortie devrait afficher la date d'expiration calculée :
```
Account expires      : Apr 03, 2024
```
Remarque : La date sera approximativement 30 jours à partir de votre date de laboratoire actuelle.
Pour supprimer la date d'expiration du compte, vous pouvez utiliser chage -E -1 policyuser.
```
sudo chage -E -1 policyuser
sudo chage -l policyuser | grep "Account expires"
```
La sortie devrait revenir à never :
```
Account expires      : never
```

Enfin, nettoyez le compte policyuser.

sudo userdel -r policyuser

Ceci conclut votre pratique avec la configuration des politiques de mot de passe utilisateur. Vous comprenez maintenant comment inspecter et modifier les paramètres de vieillissement des mots de passe à l'aide du fichier /etc/shadow et de la commande chage.

Résumé

Dans ce laboratoire, vous avez appris les concepts fondamentaux de la gestion des utilisateurs et des groupes dans Red Hat Enterprise Linux (RHEL). Vous avez commencé par comprendre comment les utilisateurs et les groupes sont associés aux fichiers et aux processus, et comment inspecter les informations sur les utilisateurs et les groupes à l'aide de la commande id pour l'utilisateur actuel et d'autres utilisateurs du système comme root. Vous avez également pratiqué l'identification de la propriété des fichiers et des répertoires à l'aide des commandes ls -l et ls -ld, respectivement, ce qui est crucial pour comprendre les permissions et le contrôle d'accès.

Le laboratoire vous a ensuite guidé à travers l'obtention d'un accès superutilisateur, la création et la modification de comptes d'utilisateurs locaux, la gestion des comptes de groupes locaux et la configuration des politiques de mot de passe utilisateur. Ces étapes ont fourni une expérience pratique des tâches essentielles d'administration système, vous permettant de gérer efficacement l'accès des utilisateurs et la sécurité sur un système Linux.

Gérer les utilisateurs et les groupes dans Red Hat Enterprise Linux