Gestion des permissions sous Linux

Les permissions sous Linux ont tendance à être considérées comme étant complexes à comprendre, en réalité, ces permissions sont relativement simple à comprendre !

Une bonne manière de les appréhender est simplement d’y jeter un oeuil et de voir comment elles sont constituées.

ls -lahs /

Ici, je vais faire un ls -lahs sur la racine de mon système, ce qui nous donnera le résultat suivant:

8,0K drwxr-xr-x  17 root root 4,0K 21 mars  14:24 .
8,0K drwxr-xr-x  17 root root 4,0K 21 mars  14:24 ..
   0 lrwxrwxrwx   1 root root    7 20 janv. 17:33 bin -> usr/bin
4,0K drwxr-xr-x   4 root root 4,0K 21 mars  14:25 boot
 24K -rw-r--r--   1 root root  22K  8 déc.  10:11 desktopfs-pkgs.txt
   0 drwxr-xr-x  23 root root 5,1K 25 mars  09:28 dev
 16K drwxr-xr-x 122 root root  12K 25 mars  09:28 etc
4,0K drwxr-xr-x   4 root root 4,0K  2 janv. 13:10 home
   0 lrwxrwxrwx   1 root root    7 20 janv. 17:33 lib -> usr/lib
   0 lrwxrwxrwx   1 root root    7 20 janv. 17:33 lib64 -> usr/lib
 16K drwx------   2 root root  16K  2 janv. 13:08 lost+found
4,0K drwxr-xr-x   4 root root 4,0K 24 mars  13:04 mnt
4,0K drwxr-xr-x  16 root root 4,0K 24 mars  08:33 opt
   0 dr-xr-xr-x 368 root root    0 25 mars  09:27 proc
4,0K drwxr-x---  10 root root 4,0K 27 févr. 02:01 root
8,0K -rw-r--r--   1 root root 5,1K  8 déc.  10:06 rootfs-pkgs.txt
   0 drwxr-xr-x  38 root root 1,1K 25 mars  09:30 run
   0 lrwxrwxrwx   1 root root    7 20 janv. 17:33 sbin -> usr/bin
   0 lrwxrwxrwx   1 root root   19  9 mars  19:29 snap -> /var/lib/snapd/snap
4,0K drwxr-xr-x   5 root root 4,0K  8 déc.  10:10 srv
   0 dr-xr-xr-x  13 root root    0 25 mars  09:27 sys
   0 drwxrwxrwt  15 root root  420 25 mars  10:02 tmp
8,0K drwxr-xr-x  10 root root 4,0K 24 mars  12:57 usr
8,0K drwxr-xr-x  13 root root 4,0K 25 mars  09:28 var

Ici, nous allons retrouver ces fameuses permissions sur la gauche, par exemple dr-xr-xr-x, ces permissions doivent en réalité être découpées en 4 pour comprendre comment elles fonctionnent:

d rwx r-x r–

Nous avons donc séparé ce bloc de caractères en 4, qui correspondent à des éléments bien précis. Le premier caractère, ici “d” ne correspond pas à une gestion des droits, il s’agit en réalité du “type” de fichier, et il peut prendre les valeurs suivantes:

• d : Indique un répertoire/dossier
• b : Indique un périphérique de type “bloc”
• s : Indique un socket
• l : Indique un lien symbolique / symlink
• c : Indique un périphérique de type “caractère”
• p : Indique un pipe
• - : Indique un “fichier classique”

Et donc, dans cet exemple nous savons que la ligne correspond à un dossier:

d rwx r-x r–

Maintenant, pour les permissions, elles sont séparées en trois groupes distincts qui correspondent à l’utilisateur, au groupe, et aux autres.

Maintenant, à quoi correspondent ces lettres ? En réalité c’est plutôt simple:

Maintenant que nous avons ces permissions, nous devrions être capable d’en déduire les permissions de notre exemple:

d rwx r-x r–

Notre exemple est donc un dossier (d) dans lequel l’utilisateur propriétaire à tous les droits, le groupe ne pourra pas écrire, et les autres ne peuvent que lire ce fichier:

Voila, maintenant, nous avons normalement bien compris le concept de ces permissions, mais il nous reste encore à comprendre comment les définir, c’est en réalité assez simple à comprendre une fois certaines petites choses comprises, pour modifier les permissions sur un fichier, nous utilisons la commande chmod (Change Mode).

Il y a en réalité deux façons de définir les permissions sous Linux, la manière de faire a assez peu d’importance, c’est principalement une question d’habitude.

Application symbolique des droits

Pour modifier les droits séparément, nous allons utiliser une syntaxe assez simple ou nous devrons indiquer:

1) Pour qui appliquer le changement

• u (user) L’utilisateur propriétaire du fichier/dossier
• g (group) Le groupe du fichier/dossier
• o (others) Les autres
• a (all) Tout le monde

2) Quelle modification effectuer

• + Ajoute une permission
• - Retire une permission
• = Affectation de permission

Donc dans cet exemple:

chmod o-rwx

Nous retirons tous les droits (lecture, écriture, exécution) aux “autres”

Il est également possible de spécifier plusieurs permissions directement en une seule commande, les droits devront être séparés par des virgules:

chmod u+rwx,g+r-w,o-rwx

Ici, nous donnons tous les droits à l’utilisateur, ajoutons les droits en lecture au groupe, mais on lui retire également les droits en écriture (-w) et retirons tous les droits aux autres (o-rwx).

En général, cette syntaxe est assez peu utilisée, la plupart des utilisateurs de Linux vont plutôt utiliser la forme octale de chmod.

Application octale des droits

L’application des droits en octal est en général la manière la plus utilisée d’effectuer des modifications sur les droits des fichiers sous Linux, vous avez probablement déjà repéré cette syntaxe:

chmod 755 fichier.txt

Le fonctionnement est en réalité très similaire a ce que nous avons vu juste avant, dans cette syntaxe, chaque droit a une valeur numérique, comme précédemment, ce “755” est en réalité à couper en trois parties, qui vont correspondre à des droits séparés:

Nous retrouvons donc nos trois types de droits encore une fois, cette fois de manière numérique, mais à quoi correspondent ces chiffres ? C’est très simple, c’est juste une addition basique ou chaque droits a sa valeur:

Donc si on reprend notre exemple de départ chmod 755 fichier.txt il s’agit en fait d’une simple additions des droits octal juste au dessus:

Conclusion

Vous devriez maintenant être en mesure d’appliquer les droits qui vous intéressent sur des fichier, cependant, il faut faire attention à comment vous allez appliquer ces permissions, en effet, une mauvaise gestion des droits peut mener à des failles de sécurité sur une machine, par exemple, une mauvaise application de droits sur des fichiers ou des exécutables système pourrait donner accès à certaines information à des utilisateurs n’étant pas sensé y avoir accès.