ACL sous Linux : maîtriser les permissions avancées

Les ACL (Access Control Lists) sous Linux permettent d’aller bien au-delà des permissions classiques du système de fichiers. Grâce aux ACL, il devient possible d’attribuer des droits précis à plusieurs utilisateurs et groupes, de façon indépendante. Cela simplifie la gestion des accès dans des environnements complexes où les besoins de partage et de sécurité sont variés. Avant de commencer, vérifions que votre système supporte correctement les ACL.

Vérifier le support des ACL sur votre système

Pour utiliser les ACL sous Linux, il est essentiel que le système de fichiers supporte cette fonctionnalité. La majorité des systèmes modernes l’intègrent nativement, mais il est prudent de vérifier.

Systèmes de fichiers compatibles ACL

Les systèmes de fichiers suivants prennent en charge les ACL:

• ext3 (avec options spécifiques au montage)
• ext4 (support natif des ACL)
• XFS (support natif et recommandé pour une gestion avancée des ACL)
• Btrfs (ACL activées par défaut)
• ReiserFS (avec support optionnel)
• JFS (avec options spécifiques)

Remarque : FAT32 et exFAT n’ont pas de support ACL sous Linux, même avec des pilotes avancés.

Vérification du support ACL sur un système de fichiers

Pour vérifier si un volume utilise les ACL, utilisez la commande suivante :

tune2fs -l /dev/sdX1 | grep "Default mount options"

• Si vous voyez acl dans les options par défaut, le support est actif.

• Exemple de sortie attendue:

  Default mount options: user_xattr acl

Si le support ACL n’apparaît pas, il faudra activer manuellement cette option.

Activer les ACL si nécessaire

1. Modifier /etc/fstab pour ajouter acl aux options de montage :

   UUID = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx / ext4 defaults, acl 0 1

2. Remonter la partition pour appliquer la modification sans redémarrer :

   mount -o remount /

3. Vérifier que les ACL sont actifs après la modification :

   mount | grep " / "

Vous devriez voir acl listé dans les options de montage.

Comprendre la structure des ACL

Les ACL sous Linux permettent d’attribuer des droits d’accès précis à différents utilisateurs ou groupes pour chaque fichier ou répertoire. Contrairement aux permissions classiques (lecture, écriture, exécution pour propriétaire, groupe et autres), les ACL permettent une gestion plus fine et étendue.

Structure des entrées ACL

Une liste de contrôle d’accès (ACL) est composée de plusieurs entrées, chacune définissant des permissions pour un utilisateur ou un groupe spécifique :

• user:: permissions du propriétaire du fichier.
• group:: permissions du groupe associé au fichier.
• other:: permissions pour tous les autres utilisateurs.
• user : nom permissions pour un utilisateur spécifique.
• group: nom permissions pour un groupe spécifique.
• mask:: permissions maximales appliquées aux entrées user:<nom> et group:<nom>.

Fonctionnement du mask

Le mask est une composante essentielle du fonctionnement des ACL:

• Il définit les permissions maximales que peuvent réellement utiliser les utilisateurs et groupes autres que le propriétaire.
• Même si une entrée user ou group possède des permissions élevées, elles seront limitées par le mask.

Exemple d’ACL :

# file : rapport.txt
# owner: pierre
# group: projet
user::rw-
user: paul: r--
group::r--
mask::rw-
other::---

Analyse :

• Pierre (propriétaire) a lecture et écriture.
• Paul a uniquement lecture.
• Groupe projet a lecture.
• Mask autorise lecture et écriture. Ici, aucune restriction supplémentaire n’est appliquée.

ACL par défaut (Default ACL)

Pour les répertoires, il est possible de définir des ACL par défaut:

• Elles s’appliquent automatiquement aux nouveaux fichiers et sous-répertoires créés dans ce répertoire.
• Cela garantit une cohérence des permissions sans intervention manuelle à chaque création de fichier.

Afficher les ACL existantes avec getfacl

Pour consulter les ACL associées à un fichier ou un répertoire sous Linux, on utilise la commande getfacl. Elle affiche toutes les permissions, aussi bien classiques qu’ajoutées via ACL.

Utiliser la commande getfacl

Commande de base pour afficher une ACL:

getfacl <fichier_ou_répertoire>

Exemple:

getfacl /home/bob/Projets/astro-blog-doc

Sortie typique:

# file: home/bob/Projets/astro-blog-doc
# owner: bob
# group: bob
user::rwx
user:paul:rw-
group::rwx
mask::rwx
other::r-x
default:user::rwx
default:user:paul:rw-
default:group::rwx
default:mask::rwx
default:other::r-x

Afficher les ACL de manière récursive

Pour voir les ACL de tout un répertoire et de ses sous-fichiers:

getfacl -R /srv/projet

Cela liste:

• Les ACL de chaque fichier.
• Les ACL par défaut si elles existent sur les répertoires.

Sauvegarder les ACL pour restauration

Il est aussi possible de sauvegarder toutes les ACL d’un répertoire :

getfacl -R /srv/projet > sauvegarde-acl.txt

On pourra ainsi restaurer les permissions plus tard avec setfacl (vu dans le chapitre suivant).

Comment lire et comprendre les informations affichées par getfacl

Lorsque vous utilisez la commande getfacl sur un fichier ou un répertoire, le résultat est structuré de manière précise pour refléter toutes les permissions actuelles, qu’elles soient standards ou ajoutées via ACL. Voici comment lire et interpréter un exemple typique :

# file: home/bob/Projets/astro-blog-doc
# owner: bob
# group: bob
user::rwx
user:paul:rw-
group::rwx
mask::rwx
other::r-x
default:user::rwx
default:user:paul:rw-
default:group::rwx
default:mask::rwx
default:other::r-x

Première partie : Métadonnées du fichier

Les deux premières lignes fournissent des informations générales :

• # file: indique le chemin complet du fichier ou du répertoire analysé.
• # owner: indique le propriétaire du fichier.
• # group: indique le groupe propriétaire du fichier.

Ces données sont issues directement du système de fichiers.

Deuxième partie : Permissions effectives (ACL standards)

Les lignes suivantes décrivent les permissions réelles appliquées actuellement, ligne par ligne :

• user::rwx Permissions rwx pour le propriétaire (ici, bob).

• user:paul:rw- Permissions spécifiques pour l’utilisateur paul : lecture et écriture, pas d’exécution.

• group::rwx Permissions pour le groupe propriétaire (bob) : lecture, écriture et exécution.

• mask::rwx Masque de permissions : il définit la limite maximale de permissions pour les entrées utilisateur spécifiques et le groupe.

• other::r-x Permissions pour tous les autres utilisateurs : lecture et exécution, pas d’écriture.

Troisième partie : Permissions par défaut (Default ACL)

Les lignes commençant par default: indiquent les permissions par défaut appliquées aux nouveaux fichiers et répertoires créés sous ce répertoire :

• default:user::rwx Permissions par défaut pour le propriétaire sur les nouveaux éléments : rwx.

• default:user:paul:rw- Permissions par défaut pour paul : lecture et écriture.

• default:group::rwx Permissions par défaut pour le groupe du fichier : rwx.

• default:mask::rwx Masque par défaut : permissions maximales à l’initialisation.

• default:other::r-x Permissions par défaut pour les autres utilisateurs : lecture et exécution.

Comment est structurée l’information ?

La sortie de getfacl suit toujours cette structure logique :

1. Informations générales (file, owner, group).
2. Permissions actuelles :
   • user:: → propriétaire
   • user:<nom> → utilisateurs spécifiques
   • group:: → groupe propriétaire
   • group:<nom> → groupes spécifiques (non présent ici)
   • mask:: → restrictions maximales
   • other:: → autres utilisateurs
3. Permissions par défaut :
   • default:user::, default:user:<nom>, default:group::, default:group:<nom>, default:mask::, default:other::

Chaque section précise qui possède quels droits et dans quelles conditions ces droits s’appliqueront automatiquement (en création de fichiers ou dans l’état actuel).

Résumé du cheminement de lecture

Pour analyser correctement un résultat de getfacl :

• Lire d’abord les métadonnées pour connaître le propriétaire et le groupe.
• Examiner les permissions standards pour comprendre l’accès actuel.
• Vérifier la présence et le rôle du mask pour évaluer les permissions effectives.
• Étudier les permissions default si l’objet est un répertoire, afin d’anticiper les futurs droits lors de la création de fichiers ou sous-dossiers.

Modifier les ACL avec setfacl

La commande setfacl permet de créer, modifier ou supprimer des ACL sur un fichier ou un répertoire sous Linux. Elle offre une grande souplesse pour attribuer des droits spécifiques à plusieurs utilisateurs et groupes.

Ajouter ou modifier une entrée ACL

Pour attribuer ou modifier des permissions pour un utilisateur :

setfacl -m u:<utilisateur>:<permissions> <fichier>

Exemple : donner lecture et écriture à l’utilisateur bob sur le fichier rapport.txt :

setfacl -m u:paul:rw /home/bob/Projets/astro-blog-doc

Pour un groupe :

setfacl -m g:<groupe>:<permissions> <fichier>

Exemple : donner lecture seule au groupe projet :

setfacl -m g:projet:r-- rapport.txt

Définir des ACL par défaut sur un répertoire

Pour que tous les nouveaux fichiers et sous-dossiers créés héritent automatiquement des permissions :

setfacl -d -m u:<utilisateur>:<permissions> <répertoire>

Exemple : permettre à caroline de modifier tous les fichiers créés dans /srv/projet :

setfacl -d -m u:paul:rw /home/bob/Projets/astro-blog-doc

Important : seuls les répertoires peuvent recevoir des ACL par défaut.

Supprimer une entrée ACL spécifique

Pour supprimer les permissions spéciales d’un utilisateur ou groupe :

setfacl -x u:<utilisateur> <fichier>

Exemple : retirer les droits spécifiques de bob :

setfacl -x u:bob rapport.txt

Supprimer toutes les ACL d’un fichier ou répertoire

Pour réinitialiser complètement les ACL et revenir aux permissions classiques :

setfacl -b <fichier>

Exemple :

setfacl -b rapport.txt

Le fichier utilisera uniquement les permissions propriétaire, groupe, et autres, comme en UNIX classique.

Cas pratiques d’utilisation des ACL

Les ACL permettent de résoudre de nombreux problèmes d’attribution de droits d’accès dans des environnements où les permissions classiques ne suffisent plus. Voici quelques situations concrètes où elles s’avèrent particulièrement utiles.

Partager un fichier entre utilisateurs non membres du même groupe

Un fichier doit être partagé entre deux utilisateurs n’appartenant pas au même groupe.

Exemple : Le fichier rapport.txt appartient à alice, mais bob doit pouvoir le lire.

Commande :

setfacl -m u:bob:r-- rapport.txt

Bob a désormais lecture seule sur le fichier, sans avoir besoin de modifier les groupes système.

Gestion des droits dans des projets collaboratifs

Dans un projet où plusieurs utilisateurs travaillent sur les mêmes fichiers, il est pratique de définir des ACL par défaut sur le répertoire principal.

Exemple : Le répertoire /srv/projet doit permettre à bob et caroline d’écrire sur tous les nouveaux fichiers.

Commandes :

setfacl -m u:bob:rw /srv/projet
setfacl -m u:caroline:rw /srv/projet
setfacl -d -m u:bob:rw /srv/projet
setfacl -d -m u:caroline:rw /srv/projet

Tous les fichiers futurs auront automatiquement les bons droits.

Donner un accès en lecture seule à un utilisateur externe

Un prestataire externe doit consulter des documents sans pouvoir les modifier.

Exemple :

setfacl -m u:consultant:r-- /srv/documents

Cela sécurise les données tout en permettant leur consultation.

Permettre à un groupe spécifique de modifier des fichiers

Sans changer la propriété d’un fichier, on peut accorder des droits d’écriture à un groupe entier.

Exemple :

setfacl -m g:developpeurs:rw /srv/app/config.yml

Le fichier reste la propriété de son créateur, mais le groupe developpeurs peut aussi le modifier.

Bonnes pratiques et précautions

L’utilisation des ACL sous Linux offre une grande flexibilité, mais elle doit être encadrée pour éviter des erreurs de gestion des droits d’accès et garantir la sécurité des données.

Comprendre le fonctionnement du mask

Le mask détermine les permissions maximales qui peuvent être exercées par les utilisateurs et groupes définis par des ACL spécifiques.

• Après chaque modification d’une ACL, il est indispensable de vérifier le mask pour s’assurer qu’il ne limite pas involontairement les droits attribués.
• Si nécessaire, ajuster le mask :

setfacl -m m::rw- fichier.txt

Cela redonne aux utilisateurs spécifiques les droits de lecture et écriture.

Utiliser les ACL avec parcimonie

Même si les ACL permettent de gérer les permissions très finement, une utilisation excessive peut compliquer :

• La lisibilité des droits d’accès.
• La maintenance des systèmes.
• La gestion des incidents de sécurité.

Conseil : Privilégier les permissions classiques et les groupes système si cela suffit, et utiliser les ACL uniquement lorsque nécessaire.

Documenter toutes les modifications ACL

Pour éviter toute confusion, il est recommandé de :

• Lister les ACL modifiées dans une documentation interne.
• Tenir à jour un historique des commandes utilisées pour attribuer ou modifier des ACL.
• Sauvegarder régulièrement les ACL existantes avec getfacl.

Exemple pour sauvegarder les ACL d’un projet :

getfacl -R /srv/projet > sauvegarde-acl.txt

Sauvegarde et restauration des ACL

Lors de migrations ou de sauvegardes de systèmes, il est important de conserver les ACL associées aux fichiers.

• Sauvegarder :

getfacl -R /srv/donnees > sauvegarde-acl.txt

• Restaurer :

setfacl --restore=sauvegarde-acl.txt

Cela garantit que les permissions spécifiques sont préservées lors d’une restauration.

Contrôle de connaissances

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

10 questions

5 min.

80% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

Conclusion

La gestion des ACL sous Linux permet d’adapter les permissions aux besoins complexes des environnements modernes. Grâce à des outils simples comme getfacl et setfacl, il devient facile d’attribuer des droits précis à chaque utilisateur ou groupe, tout en renforçant la sécurité et l’organisation des accès. Maîtriser les ACL est une compétence essentielle pour tout administrateur système souhaitant aller au-delà des permissions classiques.

×

📖 Voir la documentation →