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é à son 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 non négociable. 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 existe 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 liste longue).

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 indique :

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

Vérification des permissions pour plusieurs fichiers

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

ls -la /var/www/html

Le flag -a inclut les fichiers cachés (ceux commençant par un point). Ceci est particulièrement utile lors de l’audit des répertoires de serveur web sur un environnement Shared Web Hosting ou VPS.

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

Pour une analyse plus approfondie — incluant 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

La commande stat est inestimable pour dépanner les 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 des permissions numériques (octales)

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 additionnant les valeurs :

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érification des Permissions sur les Répertoires

Les répertoires utilisent le même modèle de permission, 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 accéder au répertoire
• Groupe (developers) : r-x — Peut lister les fichiers et accéder, 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 accéder (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 permission spéciaux : setuid, setgid et sticky bit

Au-delà des neuf bits de permission standard, Linux supporte trois bits de permission 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 réguliers 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 à 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 qu’il contient, 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 complète des permissions

Exemples de permissions dans le 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 du 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 bonnes 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 de sécurité majeur.
2. Les fichiers du serveur web (par exemple, sous /var/www/) doivent généralement être 644 pour les fichiers et 755 pour les répertoires, appartenant à votre utilisateur d’application.
3. Les clés SSH doivent être 600 pour les clés privées et 644 pour les clés publiques. SSH applique cela strictement.
4. Les fichiers de configuration contenant des mots de passe ou des clés API doivent être 600 ou 640 au maximum.
5. Utilisez find pour auditer les permissions dans une arborescence de répertoires :

   # Find all world-writable files (potential security risk)
   find /var/www -type f -perm -o+w

   # Find all SUID files (for security auditing)
   find / -type f -perm -4000 2>/dev/null

Référence rapide des commandes

Conclusion

Comprendre les permissions de fichiers Linux n’est pas qu’un exercice académique — c’est une compétence pratique et quotidienne pour quiconque gère des serveurs, déploie des applications ou travaille dans un environnement Linux. Pour résumer les points clés à retenir :

• Utilisez ls -l pour un aperçu rapide et lisible des permissions sur les fichiers et répertoires.
• Utilisez stat lorsque vous avez besoin à la fois des représentations symboliques et numériques, ainsi que des détails de propriété.
• Maîtrisez les deux notations — symbolique (rwx) et numérique (755, 644) — car différents outils et documentations les utilisent indifféremment.
• Rappelez-vous la différence des répertoires : le bit d’exécution (x) sur un répertoire signifie la capacité à y accéder, non à l’exécuter.
• Soyez conscient des bits spéciaux — setuid, setgid et le sticky bit — car ils apparaissent fréquemment sur les systèmes de production et ont des implications de sécurité importantes.

Une gestion appropriée des permissions est une pierre angulaire de la sécurité Linux. Que vous exécutiez un projet personnel sur VPS Hosting ou que vous administriez une flotte de Dedicated Servers, bien configurer les permissions dès le départ vous évitera des vulnérabilités de sécurité, des applications cassées et d’innombrables heures de dépannage par la suite.