Comment vérifier les permissions de fichiers sous Linux : un guide complet

Linux alimente la majorité des serveurs mondiaux — des environnements VPS Hosting aux Serveurs Dédiés de niveau entreprise — et pour une bonne raison. Il est rapide, stable et construit avec la sécurité au cœur. L’un des piliers les plus fondamentaux de cette sécurité est le système de permissions de fichiers : un mécanisme précis et élégant qui contrôle exactement qui peut lire, modifier ou exécuter n’importe quel fichier ou répertoire du système.

Que vous soyez un développeur déployant une application web, un administrateur système renforçant un serveur, ou un débutant apprenant la ligne de commande, comprendre comment vérifier et interpréter les permissions de fichiers dans Linux est une compétence incontournable. Ce guide couvre tout ce que vous devez savoir — des bases du modèle de permissions aux bits spéciaux avancés — avec des commandes pratiques et des exemples du monde réel.

Que sont les permissions de fichiers Linux ?

Chaque fichier et répertoire dans Linux a un ensemble de permissions qui lui est attaché. Ces permissions définissent quelles actions sont autorisées et par qui. Il y a trois types de permissions fondamentales :

Ces trois permissions sont appliquées indépendamment à trois catégories d’utilisateurs distinctes :

• Propriétaire (utilisateur) — L’utilisateur qui possède le fichier, généralement son créateur.
• Groupe — Tout utilisateur qui appartient au groupe assigné du fichier.
• Autres — Tous les autres sur le système.

Cette matrice trois par trois de permissions donne aux administrateurs Linux un contrôle granulaire et puissant sur l’accès à chaque ressource du système.

Comment vérifier les permissions de fichiers : la commande ls -l

La méthode la plus rapide et la plus couramment utilisée pour vérifier les permissions de fichiers est la commande ls -l (format de listing long).

ls -l file.txt

Exemple de sortie :

-rw-r--r-- 1 alice developers 1024 Aug 16 12:30 file.txt

Décomposons chaque composant de cette sortie :

-  rw-  r--  r--   1   alice   developers   1024   Aug 16 12:30   file.txt
│   │    │    │    │     │          │          │         │             │
│   │    │    │    │     │          │          │         │             └─ Filename
│   │    │    │    │     │          │          │         └─ Last modified
│   │    │    │    │     │          │          └─ File size (bytes)
│   │    │    │    │     │          └─ Group name
│   │    │    │    │     └─ Owner name
│   │    │    │    └─ Number of hard links
│   │    │    └─ Others' permissions
│   │    └─ Group's permissions
│   └─ Owner's permissions
└─ File type (- = regular file, d = directory, l = symlink)

Donc -rw-r--r-- nous dit :

• Propriétaire (alice) : Lecture + Écriture (rw-)
• Groupe (developers) : Lecture uniquement (r--)
• Autres : Lecture uniquement (r--)

Vérifier les permissions pour plusieurs fichiers

Pour voir les permissions de tous les fichiers dans un répertoire à la fois :

ls -la /var/www/html

Le drapeau -a inclut les fichiers cachés (ceux commençant par un point). C’est particulièrement utile lors de l’audit des répertoires de serveurs web sur un environnement Hébergement Web Partagé ou VPS.

Obtenir des informations détaillées sur les permissions avec stat

Pour une décomposition plus approfondie — incluant à la fois les représentations symboliques et numériques — utilisez la commande stat :

stat file.txt

Exemple de sortie :

  File: file.txt
  Size: 1024            Blocks: 8          IO Block: 4096   regular file
Device: fd01h/64769d    Inode: 131073      Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 1000/   alice)   Gid: ( 1000/developers)
Access: 2024-08-16 12:30:00.000000000 +0000
Modify: 2024-08-16 12:30:00.000000000 +0000
Change: 2024-08-16 12:30:00.000000000 +0000

La ligne clé est :

Access: (0644/-rw-r--r--)  Uid: ( 1000/   alice)   Gid: ( 1000/developers)

Cela vous donne :

• Notation numérique (octale) : 0644
• Notation symbolique : -rw-r--r--
• ID utilisateur (UID) et ID groupe (GID) avec leurs noms lisibles par l’homme

La commande stat est inestimable lors du dépannage des erreurs de permissions sur les serveurs de production, car elle fournit tout le contexte dont vous avez besoin en une seule sortie.

Comprendre la notation numérique (octale) des permissions

Les permissions Linux peuvent être exprimées sous forme de nombres, ce qui est le format utilisé par des commandes comme chmod. Chaque type de permission se voit attribuer une valeur :

Vous calculez la valeur de permission pour chaque catégorie d’utilisateur en ajoutant les valeurs ensemble :

Un nombre octal à trois chiffres représente l’ensemble complet des permissions :

0644  →  Owner: 6 (rw-)  |  Group: 4 (r--)  |  Others: 4 (r--)
0755  →  Owner: 7 (rwx)  |  Group: 5 (r-x)  |  Others: 5 (r-x)
0700  →  Owner: 7 (rwx)  |  Group: 0 (---)  |  Others: 0 (---)

Vérifier les permissions sur les répertoires

Les répertoires utilisent le même modèle de permissions, mais la signification de chaque bit est légèrement différente. Utilisez ls -ld (notez le drapeau -d) pour inspecter un répertoire lui-même plutôt que son contenu :

ls -ld myfolder

Exemple de sortie :

drwxr-x--- 2 alice developers 4096 Aug 16 12:30 myfolder

Le d initial confirme qu’il s’agit d’un répertoire. Les permissions se décomposent comme suit :

• Propriétaire (alice) : rwx — Peut lister, créer/supprimer des fichiers et entrer dans le répertoire
• Groupe (developers) : r-x — Peut lister les fichiers et entrer, mais ne peut pas créer ou supprimer
• Autres : --- — Aucun accès

> Important : Le bit d’exécution (x) sur un répertoire signifie la capacité à y entrer (c’est-à-dire utiliser cd). Sans x, un utilisateur ne peut pas naviguer dans le répertoire même s’il a la permission de lecture. C’est une source courante de confusion pour les débutants.

Bits de permissions spéciaux : setuid, setgid et sticky bit

Au-delà des neuf bits de permissions standard, Linux supporte trois bits de permissions spéciaux qui fournissent un contrôle d’accès avancé :

1. setuid (s sur le bit d’exécution du propriétaire)

Lorsqu’il est défini sur un fichier exécutable, le programme s’exécute avec les privilèges du propriétaire du fichier plutôt que ceux de l’utilisateur appelant. C’est ainsi que des commandes comme passwd permettent aux utilisateurs ordinaires de modifier /etc/shadow (qui est possédé par root).

ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root 54256 Mar 27 2023 /usr/bin/passwd

Le s dans la position d’exécution du propriétaire indique setuid.

2. setgid (s sur le bit d’exécution du groupe)

Sur un fichier, le programme s’exécute avec les privilèges du groupe. Sur un répertoire, les nouveaux fichiers créés à l’intérieur héritent automatiquement du groupe du répertoire — utile pour les dossiers de projets partagés.

ls -ld /shared/project
drwxrwsr-x 2 alice developers 4096 Aug 16 12:30 /shared/project

3. Sticky Bit (t sur le bit d’exécution des autres)

Lorsqu’il est défini sur un répertoire, seul le propriétaire du fichier (ou root) peut supprimer ou renommer les fichiers à l’intérieur, même si d’autres ont la permission d’écriture. C’est la configuration standard pour /tmp :

ls -ld /tmp
drwxrwxrwt 12 root root 4096 Aug 16 12:30 /tmp

Le t à la fin signale que le sticky bit est actif.

Représentation numérique des bits spéciaux :

Donc drwxrwxrwt = 1777 (1000 + 777).

Tableau de référence complet des permissions

Exemples de permissions du monde réel

Voici les modèles de permissions les plus courants que vous rencontrerez en pratique :

-rw-r--r-- (0644) — Fichier standard

-rw-r--r-- 1 alice developers 1024 Aug 16 12:30 config.txt

Le propriétaire peut lire et écrire. Le groupe et les autres ne peuvent que lire. Typique pour les fichiers de configuration et le contenu web.

-rwxr-xr-x (0755) — Script exécutable ou binaire

-rwxr-xr-x 1 alice developers 4096 Aug 16 12:30 deploy.sh

Le propriétaire a un accès complet. Tous les autres peuvent lire et exécuter mais ne peuvent pas modifier. Standard pour les scripts shell, les binaires de serveur web et les exécutables publics.

-rw------- (0600) — Fichier privé

-rw------- 1 alice alice 1679 Aug 16 12:30 id_rsa

Seul le propriétaire peut lire ou écrire. Aucun accès pour les autres. Requis pour les clés privées SSH — SSH refusera d’utiliser un fichier de clé avec des permissions plus larges.

drwxr-xr-x (0755) — Répertoire public standard

drwxr-xr-x 5 alice developers 4096 Aug 16 12:30 public_html

Courant pour les répertoires racine web. Le propriétaire a un contrôle complet ; les autres peuvent parcourir et entrer.

drwx------ (0700) — Répertoire privé

drwx------ 3 alice alice 4096 Aug 16 12:30 .ssh

Complètement privé. Seul le propriétaire peut accéder. Requis pour le répertoire ~/.ssh.

drwxrwxrwt (1777) — Accessible en écriture par tous avec sticky bit

drwxrwxrwt 12 root root 4096 Aug 16 12:30 /tmp

Tout le monde peut créer des fichiers, mais seul le propriétaire de chaque fichier peut supprimer ses propres fichiers.

Conseils pratiques pour les environnements serveur

Si vous gérez un serveur Linux — qu’il s’agisse d’un VPS exécutant une application web, d’un serveur de messagerie sécurisé avec un Certificat SSL, ou d’une machine hébergeant plusieurs domaines enregistrés via Enregistrement de domaine — voici quelques meilleures pratiques essentielles en matière de permissions :

1. Ne jamais définir 777 sur les fichiers ou répertoires sauf si vous avez une raison très spécifique et temporaire. Les fichiers accessibles en écriture par tous sont un risque majeur pour la sécurité.
2. Les fichiers du serveur web (par exemple