> Comprendre les permissions Linux : lecture, écriture, exécution, utilisateur, groupe et autres, chmod en notation symbolique et octale, chown, chgrp, umask, sudo et des cas concrets. *Source : https://coder-studio.com/outils/permissions-linux/* --- [// Linux & terminal](https://coder-studio.com/outils/) # Les permissions Linux (chmod, chown) expliquées Par **Kévin Papot** · publié le 26 novembre 2025 Sous Linux, chaque fichier et chaque dossier porte un jeu de permissions qui décide qui peut le lire, le modifier ou l’exécuter. Bien les comprendre évite deux écueils fréquents : le fameux « Permission denied » qui bloque un script, et la faille de sécurité créée par un `chmod 777` posé un peu vite. Ce guide décortique la lecture des permissions, les commandes `chmod`, `chown` et `chgrp`, le rôle de `umask` et de `sudo`, avec des cas concrets que vous rencontrerez au quotidien. ## Lire les permissions avec ls -l La commande `ls -l` affiche les permissions en première colonne : ``` ls -l ``` ``` -rw-r--r-- 1 sebastien dev 2048 nov 26 10:30 rapport.txt drwxr-xr-x 2 sebastien dev 4096 nov 26 10:31 projets -rwxr-xr-x 1 sebastien dev 512 nov 26 10:32 script.sh ``` Le premier caractère indique le type : `-` pour un fichier ordinaire, `d` pour un dossier, `l` pour un lien symbolique. Les neuf caractères suivants se lisent par groupes de trois. ## Les trois permissions : r, w, x Chaque groupe combine trois droits : - **r** (_read_, lecture) : lire le contenu d’un fichier, ou lister le contenu d’un dossier. - **w** (_write_, écriture) : modifier un fichier, ou créer/supprimer des fichiers dans un dossier. - **x** (_execute_, exécution) : lancer un fichier comme programme, ou **traverser** un dossier (y entrer avec `cd`). Un point mérite attention : sur un dossier, le droit `x` est indispensable pour y accéder, même si `r` permet d’en lister le nom des fichiers. Sans `x`, impossible d’entrer dedans. ## Utilisateur, groupe, autres Les neuf caractères se répartissent en trois catégories : ``` -rwxr-xr-- │ │ │ │ │ └── autres (others) : r-- → lecture seule │ └───── groupe (group) : r-x → lecture + exécution └──────── propriétaire (user) : rwx → tous les droits ``` - **user** : le propriétaire du fichier. - **group** : les membres du groupe associé au fichier. - **others** : tous les autres utilisateurs du système. Dans l’exemple `ls -l` plus haut, `rapport.txt` en `-rw-r--r--` est modifiable par son propriétaire, mais seulement lisible par le groupe et les autres. ## chmod en notation symbolique `chmod` (_change mode_) modifie les permissions. La notation symbolique manipule des droits précis avec des lettres : `u` (user), `g` (group), `o` (others), `a` (all), combinées aux opérateurs `+` (ajouter), `-` (retirer), `=` (fixer). ``` # Rendre un script exécutable pour tout le monde chmod +x script.sh # Ajouter l'exécution uniquement pour le propriétaire chmod u+x script.sh # Retirer l'écriture au groupe et aux autres chmod go-w rapport.txt # Fixer exactement : lecture+écriture pour user, lecture pour le reste chmod u=rw,go=r rapport.txt # Appliquer récursivement à un dossier et son contenu chmod -R u+rwX projets/ ``` Le `X` majuscule dans le dernier exemple est une astuce précieuse : il ajoute le droit d’exécution **uniquement aux dossiers** (et aux fichiers déjà exécutables), sans rendre exécutables tous vos fichiers texte. ## chmod en notation octale La notation octale exprime les permissions par un nombre à trois chiffres, un par catégorie. Chaque droit vaut une valeur : lecture = 4, écriture = 2, exécution = 1. On additionne. Chiffre Droits Signification 7 rwx lecture + écriture + exécution 6 rw- lecture + écriture 5 r-x lecture + exécution 4 r— lecture seule 0 \--- aucun droit ``` # rw-r--r-- : fichier standard (config, document) chmod 644 rapport.txt # rwxr-xr-x : script ou programme exécutable chmod 755 script.sh # rwx------ : dossier privé, accessible au seul propriétaire chmod 700 ~/.ssh # rw------- : fichier sensible, clé privée par exemple chmod 600 ~/.ssh/id_ed25519 ``` Les valeurs `644` et `755` reviennent constamment : la première pour les fichiers de données, la seconde pour les exécutables et les dossiers. Les permissions strictes sur `~/.ssh` sont d’ailleurs obligatoires : SSH refuse de fonctionner si votre clé privée est trop ouverte, un point que détaille notre [guide de SSH](https://coder-studio.com/outils/ssh-guide/). ## chown et chgrp : changer le propriétaire `chown` (_change owner_) réassigne le propriétaire d’un fichier ; `chgrp` change son groupe. Ces opérations demandent en général les droits d’administrateur. ``` # Changer le propriétaire sudo chown sebastien fichier.txt # Changer propriétaire ET groupe en une commande (user:group) sudo chown sebastien:dev fichier.txt # Changer uniquement le groupe sudo chgrp dev fichier.txt # Appliquer récursivement à toute une arborescence sudo chown -R www-data:www-data /var/www/mon-site ``` Le dernier exemple est classique lors du déploiement d’un site web : on donne la propriété des fichiers à l’utilisateur du serveur web (`www-data` sous Debian/Ubuntu) pour qu’il puisse les servir. ## umask : les permissions par défaut Quand vous créez un fichier, ses permissions ne partent pas de zéro : elles découlent d’un masque, `umask`, qui **retire** des droits à une valeur de base (666 pour les fichiers, 777 pour les dossiers). ``` # Afficher le umask courant umask # Souvent : 0022 # Avec umask 022 : # fichiers : 666 - 022 = 644 (rw-r--r--) # dossiers : 777 - 022 = 755 (rwxr-xr-x) # Durcir : rien pour le groupe ni les autres umask 077 ``` Avec `umask 077`, tout nouveau fichier naît en `600` et tout dossier en `700` : idéal sur un serveur partagé où l’on veut que chaque utilisateur garde ses créations privées. Pour rendre ce réglage permanent, on l’ajoute à son fichier de démarrage de shell (`~/.bashrc` ou `~/.profile`). ## sudo : agir en administrateur Certaines actions — modifier des fichiers système, changer un propriétaire, installer un paquet — exigent les privilèges de l’administrateur (`root`). `sudo` exécute une commande unique avec ces droits, sans se connecter en permanence en root. ``` # Exécuter une commande en tant qu'administrateur sudo systemctl restart nginx # Éditer un fichier système protégé sudo nano /etc/hosts ``` Bonne pratique : n’employez `sudo` que lorsque c’est strictement nécessaire. Travailler en root en permanence multiplie les risques d’erreur destructrice. ## Cas concrets ### « Permission denied » sur un script Vous téléchargez un script mais son exécution échoue : ``` ./deploiement.sh # bash: ./deploiement.sh: Permission denied ``` Le fichier n’a pas le droit `x`. On l’ajoute : ``` chmod +x deploiement.sh ./deploiement.sh ``` C’est le réflexe à avoir après avoir écrit un script maison, comme le rappelle notre guide sur les [scripts Bash pour automatiser ses tâches](https://coder-studio.com/outils/scripts-bash-automatisation/). ### Sécuriser un dossier de clés SSH ``` chmod 700 ~/.ssh chmod 600 ~/.ssh/id_ed25519 chmod 644 ~/.ssh/id_ed25519.pub ``` Le dossier reste privé, la clé privée illisible par les autres, la clé publique en lecture pour tous. ### Donner les bons droits à un site web ``` sudo chown -R www-data:www-data /var/www/mon-site sudo chmod -R 755 /var/www/mon-site ``` Le serveur web devient propriétaire et peut lire les fichiers, sans que ceux-ci soient modifiables par n’importe qui. ## Pourquoi éviter chmod 777 `chmod 777` accorde tous les droits à tout le monde : n’importe quel utilisateur ou processus peut lire, modifier et exécuter le fichier. C’est une porte ouverte classique en sécurité. Face à un problème de permission, cherchez le bon propriétaire et les droits minimaux nécessaires plutôt que d’ouvrir tout en grand. ## En résumé Les permissions Linux reposent sur une logique simple une fois assimilée : trois droits (r, w, x), trois catégories (user, group, others), et deux notations pour `chmod` (symbolique et octale). Avec `chown`, `chgrp`, `umask` et un usage mesuré de `sudo`, vous contrôlez précisément qui accède à quoi. C’est un socle indispensable pour administrer un serveur ou déployer une application en toute sécurité. ## À lire ensuite - [SSH : le guide pour se connecter à un serveur distant](https://coder-studio.com/outils/ssh-guide/) - [Scripts Bash pour automatiser ses tâches](https://coder-studio.com/outils/scripts-bash-automatisation/) - [Débuter sous Linux quand on est développeur](https://coder-studio.com/tutoriels/debuter-linux-developpeur/)