Contrôle de l'accès aux fichiers sous Red Hat Enterprise Linux

Introduction

Dans ce laboratoire, vous acquerrez une compréhension approfondie de la gestion des permissions du système de fichiers Linux, une compétence essentielle pour tout administrateur RHEL. Vous apprendrez à interpréter les permissions des fichiers à l'aide de ls -l, à les modifier avec chmod en modes symbolique et octal, et à changer la propriété des fichiers à l'aide de chown. De plus, vous explorerez et appliquerez des permissions spéciales comme SUID, SGID et le bit collant, et configurerez efficacement les permissions par défaut avec umask. Cette expérience pratique vous fournira les connaissances nécessaires pour sécuriser et contrôler l'accès aux fichiers et répertoires dans un environnement Linux.

Interpréter les permissions des fichiers système Linux avec ls -l

Dans cette étape, vous apprendrez à interpréter les permissions des fichiers système Linux à l'aide de la commande ls -l. Comprendre les permissions des fichiers est crucial pour gérer l'accès aux fichiers et répertoires dans un environnement Linux.

Chaque fichier et répertoire dans Linux possède des permissions associées qui déterminent qui peut le lire, l'écrire ou l'exécuter. Ces permissions sont divisées en trois catégories :

• Utilisateur (propriétaire) : Les permissions pour le propriétaire du fichier.
• Groupe : Les permissions pour les utilisateurs membres du groupe du fichier.
• Autres : Les permissions pour tous les autres utilisateurs du système.

Chaque catégorie peut avoir trois types de permissions :

• Lecture (r) : Permet d'afficher le contenu d'un fichier ou de lister le contenu d'un répertoire.
• Écriture (w) : Permet de modifier le contenu d'un fichier ou de créer/supprimer des fichiers dans un répertoire.
• Exécution (x) : Permet d'exécuter un fichier exécutable ou d'entrer dans un répertoire.

Commençons par créer un nouveau répertoire et un fichier dans votre répertoire ~/project pour observer leurs permissions par défaut.

Tout d'abord, créez un répertoire nommé my_files :

mkdir ~/project/my_files

Ensuite, créez un fichier vide nommé document.txt à l'intérieur du répertoire my_files :

touch ~/project/my_files/document.txt

Maintenant, utilisez la commande ls -l pour afficher les permissions détaillées du fichier document.txt. La commande ls -l fournit un format de liste détaillée, incluant les permissions du fichier, le propriétaire, le groupe, la taille et la date de modification.

ls -l ~/project/my_files/document.txt

Vous devriez voir une sortie similaire à ceci :

-rw-rw-r-- 1 labex labex 0 Jun  6 17:36 /home/labex/project/my_files/document.txt

Décomposons la première partie de la sortie, -rw-rw-r--.:

• Le premier caractère (-) indique le type de fichier.
  • - signifie qu'il s'agit d'un fichier ordinaire.
  • d signifie qu'il s'agit d'un répertoire.
  • l signifie qu'il s'agit d'un lien symbolique.
• Les neuf caractères suivants sont divisés en trois ensembles de trois :
  • rw-: Permissions pour le propriétaire (labex). r (lecture), w (écriture), - (pas d'exécution).
  • rw-: Permissions pour le groupe (labex). r (lecture), w (écriture), - (pas d'exécution).
  • r--: Permissions pour les autres. r (lecture), - (pas d'écriture), - (pas d'exécution).

Cela signifie que l'utilisateur labex (propriétaire) et les utilisateurs du groupe labex peuvent lire et écrire dans document.txt, tandis que tous les autres utilisateurs ne peuvent que le lire.

Maintenant, examinons les permissions du répertoire my_files lui-même. Lorsque vous utilisez ls -l sur un répertoire, il affiche le contenu du répertoire. Pour afficher les permissions du répertoire lui-même, vous devez utiliser l'option -d avec ls -l.

ls -ld ~/project/my_files

Vous devriez voir une sortie similaire à ceci :

drwxrwxr-x 2 labex labex 4096 Jun  6 17:36 /home/labex/project/my_files

Interprétons les permissions drwxrwxr-x.:

• Le premier caractère (d) indique qu'il s'agit d'un répertoire.
• rwx: Permissions pour le propriétaire (labex). r (lecture), w (écriture), x (exécution).
• rwx: Permissions pour le groupe (labex). r (lecture), w (écriture), x (exécution).
• r-x: Permissions pour les autres. r (lecture), - (pas d'écriture), x (exécution).

Pour les répertoires :

• r (lecture) permet de lister le contenu du répertoire.
• w (écriture) permet de créer, supprimer ou renommer des fichiers dans le répertoire.
• x (exécution) permet d'entrer dans le répertoire (en utilisant cd) et d'accéder à ses fichiers et sous-répertoires.

Cela signifie que l'utilisateur labex et les utilisateurs du groupe labex peuvent lister, créer/supprimer des fichiers et entrer dans le répertoire my_files. Les autres utilisateurs peuvent lister et entrer dans le répertoire, mais ne peuvent pas créer ou supprimer de fichiers à l'intérieur.

Modifier les permissions des fichiers avec chmod (mode symbolique)

Dans cette étape, vous apprendrez à modifier les permissions des fichiers à l'aide de la commande chmod en mode symbolique. Le mode symbolique utilise des lettres et des symboles pour représenter les modifications de permissions, ce qui le rend intuitif pour ajouter, supprimer ou définir des permissions spécifiques.

La commande chmod en mode symbolique suit la syntaxe : chmod QUI OPÉRATION PERMISSIONS FICHIER.

• QUI : Spécifie à qui la modification de permission s'applique.
  • u : utilisateur (propriétaire)
  • g : groupe
  • o : autres
  • a : tous (utilisateur, groupe et autres)
• OPÉRATION : Spécifie comment modifier les permissions.
  • + : Ajouter une permission.
  • - : Supprimer une permission.
  • = : Définir les permissions exactement comme spécifié, en remplaçant les permissions existantes.
• PERMISSIONS : Spécifie le type de permission.
  • r : lecture
  • w : écriture
  • x : exécution

Continuons avec le fichier ~/project/my_files/document.txt et le répertoire ~/project/my_files créés à l'étape précédente.

Tout d'abord, supprimons les permissions d'écriture pour le groupe et les autres sur document.txt. Rappelons que ses permissions actuelles sont -rw-rw-r--.

chmod go-w ~/project/my_files/document.txt

Vérifions la modification à l'aide de ls -l :

ls -l ~/project/my_files/document.txt

La sortie devrait maintenant afficher :

-rw-r--r-- 1 labex labex 0 Jun  6 17:36 /home/labex/project/my_files/document.txt

Remarquez que la permission w (écriture) pour le groupe et les autres a été supprimée.

Ensuite, ajoutons la permission d'exécution pour le propriétaire (u) à document.txt. Ceci est souvent fait pour les scripts afin de les rendre exécutables.

chmod u+x ~/project/my_files/document.txt

Vérifions la modification :

ls -l ~/project/my_files/document.txt

La sortie devrait maintenant être :

-rwxr--r-- 1 labex labex 0 Jun  6 17:36 /home/labex/project/my_files/document.txt

Le propriétaire a maintenant la permission d'exécution (x).

Maintenant, pratiquons avec le répertoire ~/project/my_files. Ses permissions actuelles sont drwxrwxr-x. Supprimons la permission d'écriture pour les autres (o) du répertoire.

chmod o-w ~/project/my_files

Vérifions la modification :

ls -ld ~/project/my_files

La sortie devrait maintenant afficher :

drwxr-xr-x 2 labex labex 4096 Jun  6 17:36 /home/labex/project/my_files

Pourquoi o-w n'a-t-il pas modifié la sortie ? C'est parce que les autres (o) n'avaient déjà pas la permission d'écriture. Le r-x pour les autres signifie lecture et exécution, mais pas d'écriture. Cela démontre que chmod n'applique les modifications que si elles sont différentes de l'état actuel.

Essayons de définir les permissions exactement. Nous allons définir les permissions de document.txt à rw-r--r-- pour tous (propriétaire, groupe, autres). Cela signifie que le propriétaire obtient lecture/écriture, le groupe obtient lecture, et les autres obtiennent lecture.

chmod a=rw,g=r,o=r ~/project/my_files/document.txt

Vérifions la modification :

ls -l ~/project/my_files/document.txt

La sortie devrait maintenant être :

-rw-r--r-- 1 labex labex 0 Jun  6 17:36 /home/labex/project/my_files/document.txt

Cette commande a=rw,g=r,o=r est un peu redondante car a=rw appliquerait rw à tous, puis g=r définirait le groupe sur r (remplaçant le w de a=rw), et o=r définirait les autres sur r (remplaçant le w de a=rw). Une façon plus simple d'obtenir rw-r--r-- serait chmod u=rw,go=r. Essayons cela.

chmod u=rw,go=r ~/project/my_files/document.txt

Vérifions la modification :

ls -l ~/project/my_files/document.txt

La sortie devrait toujours être :

-rw-r--r-- 1 labex labex 0 Jun  6 17:36 /home/labex/project/my_files/document.txt

Enfin, rendons document.txt exécutable pour tous.

chmod a+x ~/project/my_files/document.txt

Vérifions la modification :

ls -l ~/project/my_files/document.txt

La sortie devrait maintenant être :

-rwxr-xr-x 1 labex labex 0 Jun  6 17:36 /home/labex/project/my_files/document.txt

Modifier les permissions des fichiers avec chmod (mode octal)

Dans cette étape, vous apprendrez à modifier les permissions des fichiers à l'aide de la commande chmod en mode octal (numérique). Le mode octal est un moyen concis de représenter les permissions, où chaque permission (lecture, écriture, exécution) est affectée à une valeur numérique.

Les valeurs numériques pour les permissions sont :

• Lecture (r) : 4
• Écriture (w) : 2
• Exécution (x) : 1
• Aucune permission (-) : 0

Pour déterminer la valeur octale d'un ensemble de permissions (utilisateur, groupe ou autres), vous additionnez les valeurs des permissions accordées.

Par exemple :

• rwx (lecture, écriture, exécution) = 4 + 2 + 1 = 7
• rw- (lecture, écriture, pas d'exécution) = 4 + 2 + 0 = 6
• r-x (lecture, pas d'écriture, exécution) = 4 + 0 + 1 = 5
• r-- (lecture, pas d'écriture, pas d'exécution) = 4 + 0 + 0 = 4
• --- (aucune permission) = 0 + 0 + 0 = 0

La commande chmod en mode octal utilise un nombre à trois chiffres, chaque chiffre représentant respectivement les permissions pour le propriétaire, le groupe et les autres. La syntaxe est : chmod OGO FICHIER.

• O : Valeur octale des permissions du propriétaire.
• G : Valeur octale des permissions du groupe.
• O : Valeur octale des permissions des autres.

Continuons avec ~/project/my_files/document.txt et ~/project/my_files.

Tout d'abord, définissons les permissions de document.txt à rw-r--r--.

• Propriétaire : rw- = 6
• Groupe : r-- = 4
• Autres : r-- = 4

Donc, la valeur octale sera 644.

chmod 644 ~/project/my_files/document.txt

Vérifions la modification :

ls -l ~/project/my_files/document.txt

La sortie devrait maintenant être :

-rw-r--r-- 1 labex labex 0 Jun  6 00:48 /home/labex/project/my_files/document.txt

Ensuite, rendons document.txt exécutable uniquement par le propriétaire, tout en conservant la lecture/écriture pour le propriétaire et la lecture seule pour le groupe et les autres. Cela signifie que le propriétaire aura rwx (7), le groupe r-- (4), et les autres r-- (4). La valeur octale sera 744.

chmod 744 ~/project/my_files/document.txt

Vérifions la modification :

ls -l ~/project/my_files/document.txt

La sortie devrait maintenant être :

-rwxr--r-- 1 labex labex 0 Jun  6 00:48 /home/labex/project/my_files/document.txt

Maintenant, modifions les permissions du répertoire ~/project/my_files. Ses permissions actuelles sont drwxr-xr-x. Définissons ses permissions à rwxr-x---.

• Propriétaire : rwx = 7
• Groupe : r-x = 5
• Autres : --- = 0

Donc, la valeur octale sera 750.

chmod 750 ~/project/my_files

Vérifions la modification :

ls -ld ~/project/my_files

La sortie devrait maintenant afficher :

drwxr-x--- 2 labex labex 26 Jun  6 00:48 /home/labex/project/my_files

Cela signifie que le propriétaire (labex) a toutes les permissions (lecture, écriture, exécution), le groupe (labex) peut lire et exécuter (entrer) le répertoire, et les autres n'ont aucune permission.

Enfin, créons un nouveau script exécutable pour démontrer la définition directe des permissions d'exécution.

echo '#!/bin/bash' > ~/project/my_script.sh
echo 'echo "Hello from my script!"' >> ~/project/my_script.sh

Par défaut, les nouveaux fichiers ne sont pas exécutables. Vérifions ses permissions :

ls -l ~/project/my_script.sh

Vous verrez probablement des permissions comme -rw-r--r--. Pour le rendre exécutable pour le propriétaire et le groupe, mais pas les autres, nous voulons rwxrwx---.

• Propriétaire : rwx = 7
• Groupe : rwx = 7
• Autres : --- = 0

Donc, la valeur octale sera 770.

chmod 770 ~/project/my_script.sh

Vérifions la modification :

ls -l ~/project/my_script.sh

La sortie devrait maintenant être :

-rwxrwx--- 1 labex labex 41 Jun  6 00:52 /home/labex/project/my_script.sh

Maintenant, vous pouvez exécuter le script :

~/project/my_script.sh

Vous devriez voir la sortie :

Hello from my script!

Modification de la propriété des fichiers avec chown

Dans cette étape, vous apprendrez à modifier le propriétaire et le groupe de fichiers et de répertoires à l'aide de la commande chown. Il s'agit d'une tâche administrative cruciale, car seul l'utilisateur root peut modifier le propriétaire d'un fichier. L'utilisateur labex possède les privilèges sudo, ce qui vous permettra d'effectuer ces actions.

La syntaxe de base de chown est : chown [OPTIONS] NOUVEAU_PROPRIETAIRE[:NOUVEAU_GROUPE] FICHIER(s).

Commençons par créer un nouvel utilisateur et un nouveau groupe que nous pouvons utiliser pour démontrer les modifications de propriété. Étant donné que cet environnement est basé sur des conteneurs, nous allons créer un utilisateur et un groupe simples à des fins de démonstration.

Tout d'abord, créez un nouveau groupe nommé devs :

sudo groupadd devs

Ensuite, créez un nouvel utilisateur nommé developer et ajoutez-le au groupe devs. Nous allons créer un utilisateur système sans répertoire personnel ni shell de connexion pour cette démonstration.

sudo useradd -r -g devs -s /sbin/nologin developer

Maintenant, modifions le propriétaire de ~/project/my_files/document.txt de labex à developer.

sudo chown developer ~/project/my_files/document.txt

Vérifiez la modification à l'aide de ls -l :

ls -l ~/project/my_files/document.txt

La sortie devrait maintenant afficher developer comme propriétaire :

-rwxr--r-- 1 developer labex 0 Jun  6 00:48 /home/labex/project/my_files/document.txt

Remarquez que la propriété du groupe (labex) n'a pas été modifiée.

Vous pouvez également modifier à la fois le propriétaire et le groupe simultanément en utilisant la syntaxe propriétaire:groupe. Modifions le propriétaire de document.txt en labex et son groupe en devs.

sudo chown labex:devs ~/project/my_files/document.txt

Vérifiez la modification :

ls -l ~/project/my_files/document.txt

La sortie devrait maintenant afficher labex comme propriétaire et devs comme groupe :

-rwxr--r-- 1 labex devs 0 Jun  6 00:48 /home/labex/project/my_files/document.txt

La commande chown prend également en charge l'option -R (récursif), qui vous permet de modifier la propriété d'un arborescence de répertoires entière. Modifions le propriétaire du répertoire ~/project/my_files et de tout son contenu en developer, et le groupe en devs.

sudo chown -R developer:devs ~/project/my_files

Vérifiez la modification pour le répertoire :

ls -ld ~/project/my_files

La sortie devrait refléter la nouvelle propriété :

drwxr-x--- 2 developer devs 26 Jun  6 00:48 /home/labex/project/my_files

Notez qu'après avoir modifié la propriété du répertoire en developer:devs, l'utilisateur labex ne peut plus accéder au fichier à l'intérieur du répertoire car les permissions du répertoire sont drwxr-x--- (le propriétaire et le groupe ont accès, mais pas les autres), et labex n'est ni le propriétaire (developer) ni membre du groupe (devs). Si vous essayez de lister le fichier maintenant :

ls -l ~/project/my_files/document.txt

Vous obtiendrez une erreur "Permission refusée". Cela démontre comment la propriété et les permissions fonctionnent ensemble pour contrôler l'accès.

Vous pouvez également modifier uniquement la propriété du groupe en utilisant chown :NOUVEAU_GROUPE FICHIER(s). Ceci est équivalent à l'utilisation de la commande chgrp. Modifions le groupe de ~/project/my_script.sh en devs.

sudo chown :devs ~/project/my_script.sh

Vérifiez la modification :

ls -l ~/project/my_script.sh

La sortie devrait afficher devs comme propriétaire du groupe, tandis que labex reste le propriétaire du fichier :

-rwxrwx--- 1 labex devs 41 Jun  6 00:52 /home/labex/project/my_script.sh

Enfin, nettoyons en changeant la propriété en labex:labex puis en supprimant l'utilisateur developer et le groupe devs.

sudo chown -R labex:labex ~/project/my_files
sudo userdel developer
sudo groupdel devs

Comprendre et appliquer les permissions spéciales (SUID, SGID, bit collant)

Dans cette étape, vous explorerez les permissions spéciales sous Linux : SUID (Set User ID), SGID (Set Group ID) et le bit collant. Ces permissions offrent un contrôle amélioré sur l'exécution des fichiers et le comportement des répertoires.

Les permissions spéciales sont représentées par un chiffre supplémentaire dans le mode de permission octal, placé avant les trois chiffres standard (propriétaire, groupe, autres).

• SUID (Set User ID) :
  • Valeur octale : 4
  • Effet sur les fichiers : Lorsqu'un fichier exécutable avec SUID est exécuté, il s'exécute avec les permissions du propriétaire du fichier, et non de l'utilisateur qui l'a exécuté. Ceci est couramment utilisé pour les programmes ayant besoin de privilèges élevés pour effectuer certaines tâches, comme la commande passwd (qui doit écrire dans /etc/shadow, un fichier appartenant à root).
  • Dans la sortie ls -l : Un s apparaît à la place du bit d'exécution (x) du propriétaire. Si le propriétaire n'a pas le droit d'exécution, un S majuscule apparaît.
• SGID (Set Group ID) :
  • Valeur octale : 2
  • Effet sur les fichiers : Semblable à SUID, mais l'exécutable s'exécute avec les permissions du groupe propriétaire du fichier.
  • Effet sur les répertoires : Les fichiers et sous-répertoires créés dans un répertoire SGID héritent de la propriété du groupe de ce répertoire, plutôt que du groupe principal de l'utilisateur qui les a créés. Ceci est très utile pour les répertoires partagés où tous les fichiers doivent appartenir à un groupe spécifique.
  • Dans la sortie ls -l : Un s apparaît à la place du bit d'exécution (x) du groupe. Si le groupe n'a pas le droit d'exécution, un S majuscule apparaît.
• Bit collant :
  • Valeur octale : 1
  • Effet sur les fichiers : Aucun effet.
  • Effet sur les répertoires : Les utilisateurs peuvent créer des fichiers dans le répertoire, mais ils ne peuvent supprimer ou renommer que les fichiers qu'ils possèdent. Cela empêche les utilisateurs de supprimer ou de déplacer les fichiers d'autres utilisateurs dans un répertoire partagé (par exemple, /tmp).
  • Dans la sortie ls -l : Un t apparaît à la place du bit d'exécution (x) des autres. Si les autres n'ont pas le droit d'exécution, un T majuscule apparaît.

Démontrons ces permissions spéciales.

Exemple SUID

Nous allons créer un simple programme C qui tente de lire un fichier restreint.

Tout d'abord, créez un fichier que seul root peut lire :

sudo touch ~/project/secret_data.txt
sudo chmod 600 ~/project/secret_data.txt
sudo chown root:root ~/project/secret_data.txt

Vérifiez ses permissions :

ls -l ~/project/secret_data.txt

Sortie :

-rw------- 1 root root 0 Jun  6 17:36 /home/labex/project/secret_data.txt

Maintenant, créez un programme C read_secret.c qui essaie de lire ce fichier :

nano ~/project/read_secret.c

Collez le code suivant dans read_secret.c :

// ... (code C)

Enregistrez et quittez nano (Ctrl+S, Ctrl+X).

Compilez le programme :

gcc ~/project/read_secret.c -o ~/project/read_secret

Essayez maintenant de l'exécuter en tant que labex :

~/project/read_secret

Vous devriez voir un message "Erreur d'ouverture du fichier : Permission refusée", car labex n'a pas le droit de lire secret_data.txt.

Maintenant, rendons read_secret propriétaire de root et activons le bit SUID.

// ... (code bash)

Vérifiez les permissions :

// ... (code bash)

Sortie :

// ... (sortie ls -l)

Remarquez le s dans les permissions du propriétaire. Maintenant, exécutez à nouveau le programme en tant que labex :

// ... (code bash)

Cette fois, il devrait lire le fichier avec succès (même s'il est vide, donc aucun contenu ne sera imprimé, mais le message "Fichier lu avec succès" indique la réussite). Ceci est dû au fait que le bit SUID a fait exécuter le programme avec les permissions de root.

Exemple SGID (sur répertoire)

Créons un répertoire partagé et un nouveau groupe.

// ... (code bash)

Maintenant, définissez le bit SGID sur shared_dir :

// ... (code bash)

Vérifiez les permissions :

// ... (code bash)

Sortie :

// ... (sortie ls -ld)

Maintenant, créez un fichier dans shared_dir :

// ... (code bash)

Vérifiez la propriété de new_file.txt :

// ... (code bash)

Sortie :

// ... (sortie ls -l)

Même si le groupe principal de labex est labex, new_file.txt a hérité de la propriété du groupe shared_group de shared_dir en raison du bit SGID.

Exemple bit collant

Le répertoire /tmp est un exemple classique de répertoire avec le bit collant activé. Créons un répertoire similaire.

// ... (code bash)

Vérifiez les permissions :

// ... (code bash)

Sortie :

// ... (sortie ls -ld)

Maintenant, simulons un autre utilisateur créant un fichier dans ce répertoire.

// ... (code bash)

Vous verrez une invite vous demandant si vous voulez supprimer le fichier protégé en écriture, et après confirmation avec y, vous obtiendrez une erreur "Opération non autorisée". Ceci est dû au fait que le bit collant empêche les utilisateurs de supprimer les fichiers qu'ils ne possèdent pas dans ce répertoire, même si labex a les permissions d'écriture sur le répertoire public_upload. Seul root ou le propriétaire de labex_file.txt peut le supprimer.

Pour nettoyer, vous aurez besoin de sudo pour supprimer labex_file.txt :

// ... (code bash)

Nettoyage

Supprimez les fichiers et répertoires créés, ainsi que l'utilisateur/groupe :

// ... (code bash)

Configuration des permissions par défaut avec umask

Dans cette étape finale, vous apprendrez à utiliser umask, qui contrôle les permissions par défaut attribuées aux nouveaux fichiers et répertoires créés. umask (masque de mode de création de fichiers utilisateur) est un masque de bits qui supprime des permissions des permissions maximales possibles.

Les permissions maximales pour un nouveau fichier sont 666 (rw-rw-rw-), signifiant lecture et écriture pour tout le monde. Les nouveaux fichiers n'obtiennent généralement pas les permissions d'exécution par défaut pour des raisons de sécurité.
Les permissions maximales pour un nouveau répertoire sont 777 (rwxrwxrwx), signifiant lecture, écriture et exécution pour tout le monde.

La valeur umask est soustraite de ces permissions maximales pour déterminer les permissions par défaut réelles.

Pour afficher la valeur umask actuelle, tapez simplement umask :

umask

Vous verrez probablement 0002 ou 0022. Dans cet environnement, c'est 0022 pour l'utilisateur labex.

Un umask de 0022 signifie :

• Le premier 0 concerne les permissions spéciales (SUID, SGID, bit collant), qui ne sont pas affectées par umask par défaut.
• Le deuxième 0 signifie qu'aucune permission n'est retirée au propriétaire.
• Le troisième 2 signifie que la permission d'écriture (valeur 2) est retirée au groupe.
• Le quatrième 2 signifie que la permission d'écriture (valeur 2) est retirée aux autres.

Calculons les permissions par défaut avec un umask de 0022 :

• Pour les fichiers (max 666) :

  • Propriétaire : 6 - 0 = 6 (rw-)
  • Groupe : 6 - 2 = 4 (r--)
  • Autres : 6 - 2 = 4 (r--)
  • Permissions de fichier résultantes : 644 (rw-r--r--)

• Pour les répertoires (max 777) :

  • Propriétaire : 7 - 0 = 7 (rwx)
  • Groupe : 7 - 2 = 5 (r-x)
  • Autres : 7 - 2 = 5 (r-x)
  • Permissions de répertoire résultantes : 755 (rwxr-xr-x)

Testons cela. Créez un nouveau fichier et un nouveau répertoire :

touch ~/project/new_file_umask.txt
mkdir ~/project/new_dir_umask

Vérifiez leurs permissions :

ls -l ~/project/new_file_umask.txt
ls -ld ~/project/new_dir_umask

Vous devriez voir des permissions comme -rw-r--r-- pour le fichier et drwxr-xr-x pour le répertoire, confirmant l'effet du umask 0022.

Maintenant, modifions le umask en 0077. Ce umask supprimera toutes les permissions du groupe et des autres.

umask 0077

Vérifiez que le umask a bien changé :

umask

Sortie :

0077

Calculons maintenant les permissions par défaut avec un umask de 0077 :

• Pour les fichiers (max 666) :

  • Propriétaire : 6 - 0 = 6 (rw-)
  • Groupe : 6 - 7 = -1 (effectivement 0, ---)
  • Autres : 6 - 7 = -1 (effectivement 0, ---)
  • Permissions de fichier résultantes : 600 (rw-------)

• Pour les répertoires (max 777) :

  • Propriétaire : 7 - 0 = 7 (rwx)
  • Groupe : 7 - 7 = 0 (---)
  • Autres : 7 - 7 = 0 (---)
  • Permissions de répertoire résultantes : 700 (rwx------)

Testons ce nouveau umask. Créez un autre nouveau fichier et répertoire :

// ... (code bash)

Vérifiez leurs permissions :

// ... (code bash)

Le paramètre umask est généralement configuré dans les fichiers d'initialisation du shell (comme ~/.bashrc ou /etc/profile) pour s'appliquer automatiquement lors de la connexion d'un utilisateur. Pour ce laboratoire, la modification du umask est temporaire et ne s'applique qu'à la session de terminal actuelle.

Pour rétablir le umask par défaut pour l'utilisateur labex, vous pouvez simplement le réinitialiser à 0022 :

umask 0022

Enfin, supprimez les fichiers et répertoires créés dans cette étape :

// ... (code bash)

Résumé

Dans ce laboratoire, nous avons exploré les aspects fondamentaux de la gestion des permissions du système de fichiers Linux. Nous avons commencé par maîtriser la commande ls -l pour interpréter les permissions des fichiers et des répertoires, en comprenant l'importance des catégories utilisateur, groupe et autres, ainsi que les permissions de lecture, d'écriture et d'exécution. Ces connaissances fondamentales ont ensuite été appliquées pour modifier les permissions à l'aide de chmod en modes symbolique et octal, offrant une flexibilité dans la définition des droits d'accès.

De plus, nous avons appris à modifier la propriété des fichiers avec la commande chown, ce qui est crucial pour attribuer le contrôle administratif. Le laboratoire a également couvert la compréhension et l'application des permissions spéciales (SUID, SGID et bit collant), qui offrent un contrôle avancé sur les comportements d'exécution et de création de fichiers. Enfin, nous avons exploré comment configurer les permissions par défaut pour les nouveaux fichiers et répertoires créés à l'aide de umask, garantissant des paramètres de permissions cohérents sur l'ensemble du système.